src/fw-plugins/common-public/slp-device/src/slp_device_info.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include "slp_device_info.h"
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <sys/utsname.h>
  23 #include <vconf.h>
  24 #include <vconf-keys.h>
  25
  26 #include <tapi_common.h>
  27 #include <ITapiModem.h>
  28 #include <ITapiSim.h>
  29 #include <system_info.h>
  30
  31 #include "fsapi/operation.h"
  32 #include "plugin/device_info_interface.h"
  33
  34 /* for log */
  35 #include "utility/sync_util.h"
  36
  37 #ifndef SYNC_AGENT_LOG
  38 #undef LOG_TAG
  39 #define LOG_TAG "SLP_DEVICE_INFO"
  40 #endif
  41
  42 #define _D_MSC_FIRMWARE_MAXSTRING_      64
  43 #define _D_SIZE_64_                     64
  44 #define _D_SIZE_128_                    128
  45
  46 /* todo : temporary definition */
  47 #define SW_VERSION            "SLP-v1.0"
  48 #define HW_VERSION                              "GT-I8800-v1.0"
  49 #define FW_VERSION                              "1.0"
  50 #define MODEM_VERSION           "M.I8800XXUI"
  51 #define PDA_VERSION                     "P.I8800XXJI-"
  52 #define PDA_BIN_VERSION                            "/usr/etc/info.ini"
  53 #define PDA_VERSION_INFO_FILE   "/etc/info.ini"
  54 #define CSC_DB_VERSION                                          "/mnt/csc/info.ini"
  55 #define _D_PDA_BUILD_INFO_MAJOR_              "Major="
  56 #define _D_PDA_BUILD_INFO_BUILD_               "Build="
  57
  58 #define MANUFACTURE                     "Samsung electronics"
  59 #define MODEL                                           "GT-I8800"
  60 #define OEM                                                     "Samsung Electronics"
  61 #define DEV_TYPE                                        "phone"
  62
  63 #define BATTERY_LEVEL                                   "/sys/class/power_supply/battery/capacity"
  64
  65 /* ========================================*/
  66 /* version information
  67  *      software version
  68  *      hardware version
  69  *      modem version
  70  *      PDA version
  71  *      CSC version
  72  *      firmware version
  73  */
  74 /* ========================================*/
  75 char *slp_device_info_get_software_version()
  76 {
  77         _EXTERN_FUNC_ENTER;
  78
  79         /* TODO */
  80         char *sw_version = (char *)calloc(_D_SIZE_128_, sizeof(char));
  81         if (sw_version == NULL) {
  82                 _DEBUG_ERROR("CALLOC failed !!!");
  83                 return 0;
  84         }
  85         /*snprintf(sw_version, _D_SIZE_128_ - 1, SW_VERSION, strlen(SW_VERSION)); */
  86         snprintf(sw_version, _D_SIZE_128_ - 1, "%s", SW_VERSION);
  87         _DEBUG_INFO("SW version = %s\n", sw_version);
  88
  89         _EXTERN_FUNC_EXIT;
  90
  91         return sw_version;
  92 }
  93
  94 char *slp_device_info_get_hardware_version()
  95 {
  96         _EXTERN_FUNC_ENTER;
  97
  98         /* TODO */
  99         char *HW_version = (char *)calloc(_D_SIZE_128_, sizeof(char));
 100         if (HW_version == NULL) {
 101                 _DEBUG_ERROR("CALLOC failed !!!");
 102                 return 0;
 103         }
 104         /*snprintf(HW_version, _D_SIZE_128_ - 1, HW_VERSION, strlen(HW_VERSION)); */
 105         snprintf(HW_version, _D_SIZE_128_ - 1, "%s", HW_VERSION);
 106         _DEBUG_INFO("HW version = %s\n", HW_version);
 107
 108         _EXTERN_FUNC_EXIT;
 109
 110         return HW_version;
 111 }
 112
 113 char *slp_device_info_get_modem_version()
 114 {
 115         _EXTERN_FUNC_ENTER;
 116
 117 /*
 118         char *get_str;
 119         char str_key_name[_D_SIZE_128_ * 2] = { 0, };
 120         snprintf(str_key_name, _D_SIZE_128_ * 2, "%s", VCONFKEY_TELEPHONY_SWVERSION);
 121         get_str = vconf_get_str(str_key_name);
 122         _DEBUG_INFO("Modem version = %s\n", get_str);
 123         return get_str;
 124 */
 125         char *get_str = NULL;
 126 /*
 127         TapiHandle *handle = tel_init(NULL);
 128         if (!handle)
 129                 _DEBUG_INFO("tapi handle is null\n");
 130
 131         //TelMiscVersionInformation *info = tel_get_misc_me_version_sync(handle);
 132         TelMiscVersionInformation *info = NULL; // this code is rsa & emulator
 133         if (!info) {
 134                 _DEBUG_INFO("tet_get_misc_me_version_sync -> return Fail\n");
 135                 get_str = strdup("I8800XXKI1");
 136         } else {
 137                 _DEBUG_INFO("szSwVersion [%s], szHwVersion [%s], szRfCalDate [%s], szProductCode [%s]\n", info->szSwVersion, info->szHwVersion, info->szRfCalDate, info->szProductCode);
 138                 get_str = strdup((char *)(info->szSwVersion));  // I9200XXKI2
 139                 free(info);
 140         }
 141
 142         if (!handle)
 143                 tel_deinit(handle);
 144 */
 145         get_str = strdup("I8800XXKI1");
 146         _DEBUG_INFO("Modem version = %s\n", get_str);
 147
 148         _EXTERN_FUNC_EXIT;
 149
 150         return get_str;
 151 }
 152
 153 /* pre source */
 154 /*char *slp_device_info_get_pda_version()
 155 {
 156       FILE *file_des;
 157     //file_des =fopen("/usr/etc/info.ini","rb");
 158
 159     file_des =fopen(PDA_VERSION_INFO_FILE,"rb");
 160     int i = 0 ;
 161       if(file_des==NULL)
 162       {
 163                         _DEBUG_INFO("fopen fail - info.ini \n");
 164                         return g_strdup_printf("%s", PDA_VERSION);
 165       }
 166
 167       char *pda_version = 0;
 168     while( ! feof(file_des) )
 169     {
 170                 char info_temp[20] = {0,} ;
 171                 int result = 1 ;
 172                 fseek(file_des,i,SEEK_SET);
 173                 i++ ;
 174
 175                 fread(info_temp, sizeof(char) , strlen("Major=") , file_des );
 176                 result = memcmp( info_temp , "Major=" , strlen("Major=") ) ;
 177                 if( !result )
 178                 {
 179                         if (pda_version == NULL)
 180                                 pda_version = (char*) calloc(20, sizeof(char));
 181                                 if( pda_version == NULL ) {
 182                                         _DEBUG_ERROR("CALLOC failed !!!");
 183                                         return NULL;
 184                                 }
 185
 186                         memcpy(pda_version, "P." , strlen("P.") );
 187                         fread(pda_version+strlen("P."), sizeof(char) , strlen(PDA_VERSION) , file_des );
 188                         _DEBUG_INFO("fread pda_version - %s\n" , pda_version);
 189                         break;
 190                 }
 191         }
 192
 193     if( file_des != NULL )
 194                 fclose(file_des);
 195
 196 }*/
 197
 198 char *slp_device_info_get_pda_version()
 199 {
 200         _EXTERN_FUNC_ENTER;
 201
 202 /*
 203         char *pda_version = (char *)calloc(_D_SIZE_128_, sizeof(char));
 204         if( pda_version == NULL ) {
 205                 _DEBUG_ERROR("CALLOC failed !!!");
 206                 return 0;
 207         }
 208         FILE *file_des;
 209         file_des = fopen(PDA_BIN_VERSION, "rb");
 210         int i = 0;
 211
 212         if (file_des == NULL) {
 213                 _DEBUG_INFO("fopen fail - info.ini \n");
 214                 snprintf(pda_version, _D_SIZE_128_ / 2, "%s", PDA_VERSION);
 215                 return 0;
 216         }
 217
 218         while (!feof(file_des)) {
 219                 char info_temp[20] = { 0, };
 220                 int result = 1;
 221                 fseek(file_des, i, SEEK_SET);
 222                 i++;
 223
 224                 fread(info_temp, sizeof(char), strlen(_D_PDA_BUILD_INFO_BUILD_), file_des);     // 2011/10/05 SCM request  _D_PDA_BUILD_INFO_MAJOR_ -> _D_PDA_BUILD_INFO_BUILD_
 225                 result = memcmp(info_temp, _D_PDA_BUILD_INFO_BUILD_, strlen(_D_PDA_BUILD_INFO_BUILD_));
 226                 if (!result) {
 227                         char pda_version_check[64] = { 0 };
 228                         int read_pos = 0;
 229                         //memcpy(pda_version_check, "P." , strlen("P.") );
 230                         //   read_pos = strlen(pda_version_check);
 231                         while (!feof(file_des)) {
 232                                 fread(pda_version_check + read_pos, sizeof(char), 1, file_des);
 233                                 if (pda_version_check[read_pos] == '_')
 234                                         pda_version_check[read_pos] = '-';
 235                                 else if (pda_version_check[read_pos] == '\n')
 236                                         break;
 237                                 else if (pda_version_check[read_pos] == ';') {
 238                                         //pda_version_check[read_pos] = NULL;
 239                                         pda_version_check[read_pos] = 0;
 240                                         break;
 241                                 }
 242                                 read_pos++;
 243                         }
 244
 245                         snprintf(pda_version, _D_SIZE_128_ / 2, "%s", pda_version_check);
 246                         _DEBUG_INFO("fread pda_version - [%s]\n", pda_version);
 247                         break;
 248                 }
 249         }
 250
 251         if (file_des != NULL)
 252                 fclose(file_des);
 253
 254         return pda_version;
 255 */
 256         char *pda_version = NULL;
 257         int sys_result = SYSTEM_INFO_ERROR_NONE;
 258         sys_result = system_info_get_value_string(SYSTEM_INFO_KEY_BUILD_STRING, &pda_version);  /* GT-I8800_c210_2012_09_10_1 */
 259         if (sys_result == SYSTEM_INFO_ERROR_NONE) {
 260                 if (pda_version != NULL) {
 261                         _DEBUG_INFO("system_info_get_value_string [%s]\n", pda_version);
 262                         //free(pda_version);
 263                 } else {
 264                         pda_version = strdup("GT-I8800_c210_2012_09_10_1");
 265                 }
 266         } else {
 267                 _DEBUG_INFO("system_info_get_value_string error [%d]\n", sys_result);
 268                 pda_version = strdup("GT-I8800_c210_2012_09_10_2");
 269         }
 270
 271         _DEBUG_INFO("pda_version [%s]\n", pda_version);
 272
 273         _EXTERN_FUNC_EXIT;
 274
 275         return pda_version;
 276 }
 277
 278 char *slp_device_info_get_csc_version()
 279 {
 280         _EXTERN_FUNC_ENTER;
 281
 282 /*
 283         char *csc_version = (char *)calloc(_D_SIZE_128_, sizeof(char));
 284         if( csc_version == NULL ) {
 285                 _DEBUG_ERROR("CALLOC failed !!!");
 286                 return 0;
 287         }
 288
 289         FILE *file_des;
 290         file_des = fopen(CSC_DB_VERSION, "rb");
 291         int i = 0;
 292         if (file_des == NULL) {
 293                 _DEBUG_INFO("fopen fail - info.ini \n");
 294                 snprintf(csc_version, _D_SIZE_128_ / 2, "%s", "C.");
 295                 return 0;
 296         }
 297         while (!feof(file_des)) {
 298                 char info_temp[20] = { 0, };
 299                 int result = 1;
 300                 fseek(file_des, i, SEEK_SET);
 301                 i++;
 302
 303                 fread(info_temp, sizeof(char), strlen(_D_PDA_BUILD_INFO_BUILD_), file_des);     // 2011/10/05 SCM request  _D_PDA_BUILD_INFO_MAJOR_ -> _D_PDA_BUILD_INFO_BUILD_
 304                 result = memcmp(info_temp, _D_PDA_BUILD_INFO_BUILD_, strlen(_D_PDA_BUILD_INFO_BUILD_));
 305                 if (!result) {
 306                         char csc_version_check[64] = { 0 };
 307                         int read_pos = 0;
 308                         // memcpy(csc_version_check, "C." , strlen("C.") );
 309                         //   read_pos = strlen(csc_version_check);
 310                         while (!feof(file_des)) {
 311                                 fread(csc_version_check + read_pos, sizeof(char), 1, file_des);
 312                                 if (csc_version_check[read_pos] == '_')
 313                                         csc_version_check[read_pos] = '-';
 314                                 else if (csc_version_check[read_pos] == '\n')
 315                                         break;
 316                                 else if (csc_version_check[read_pos] == ';') {
 317                                         //csc_version_check[read_pos] = NULL;
 318                                         csc_version_check[read_pos] = 0;
 319                                         break;
 320                                 }
 321                                 read_pos++;
 322                         }
 323
 324                         snprintf(csc_version, _D_SIZE_128_ / 2, "%s", csc_version_check);
 325                         _DEBUG_INFO("fread csc_version - [%s]\n", csc_version);
 326                         break;
 327                 }
 328         }
 329
 330         if (file_des != NULL)
 331                 fclose(file_des);
 332
 333         return csc_version;
 334 */
 335 /*
 336         char *csc_version = NULL;
 337         TapiHandle *handle = tel_init(NULL);
 338         if (!handle)
 339                 _DEBUG_INFO("tapi handle is null\n");
 340
 341         TelMiscVersionInformation *info = tel_get_misc_me_version_sync(handle);
 342         if (!info) {
 343                 _DEBUG_INFO("tet_get_misc_me_version_sync -> return Fail\n");
 344                 csc_version = strdup("XXX");
 345         } else {
 346                 _DEBUG_INFO("szSwVersion [%s], szHwVersion [%s], szRfCalDate [%s], szProductCode [%s]\n", info->szSwVersion, info->szHwVersion, info->szRfCalDate, info->szProductCode);
 347                 csc_version = strdup((char *)(info->szProductCode));
 348                 free(info);
 349         }
 350
 351         if (!handle)
 352                 tel_deinit(handle);
 353
 354         _DEBUG_INFO("Modem version = %s\n", csc_version);
 355 */
 356         char *csc_version = NULL;
 357         char CSC_Ver[64] = {0,};
 358         int err = 0;
 359         if (err == 0) {
 360                 _DEBUG_ERROR("CSC_Ver get fail\n");
 361                 snprintf(CSC_Ver, 64, "%s", "I8800OXAALJ4");
 362         }
 363
 364         csc_version = strdup(CSC_Ver);
 365         _EXTERN_FUNC_EXIT;
 366
 367         return csc_version;
 368 }
 369
 370 char *slp_device_info_get_firmware_version()
 371 {
 372         _EXTERN_FUNC_ENTER;
 373
 374         int index = 0;
 375         char *firmware_version = (char *)calloc(_D_SIZE_64_, sizeof(char));
 376         if (firmware_version == NULL) {
 377                 _DEBUG_ERROR("CALLOC failed !!!");
 378                 return 0;
 379         }
 380         char *firmware_ver = (char *)calloc(_D_SIZE_128_, sizeof(char));
 381         if (firmware_ver == NULL) {
 382                 _DEBUG_ERROR("CALLOC failed !!!");
 383                 free(firmware_version);
 384                 return 0;
 385         }
 386
 387
 388         char *pda_version = slp_device_info_get_pda_version();  // GT-I8800_c210_2012_09_10_2
 389         _DEBUG_INFO("firmware_ver pda [%s]\n", pda_version);
 390         if (pda_version != NULL) {
 391                 snprintf(firmware_ver + index, _D_SIZE_128_ / 3, "%s/", pda_version);
 392         }
 393
 394         if (firmware_ver != NULL) {
 395                 index = strlen(firmware_ver);
 396         } else {
 397                 _DEBUG_ERROR("firmware_ver is NULL !!");
 398                 /* todo : exception handling */
 399                 free(firmware_version);
 400                 return 0;
 401         }
 402         _DEBUG_INFO("index = %d\n", index);
 403         _DEBUG_INFO("firmware Ver1 = %s\n", firmware_ver);
 404
 405         char *csc_version = slp_device_info_get_csc_version();
 406         _DEBUG_INFO("firmware_ver pda/csc [%s]\n", csc_version);
 407         if (csc_version != NULL) {
 408                 snprintf(firmware_ver + index, _D_SIZE_128_ / 3, "%s/", csc_version);
 409         }
 410
 411         if (firmware_ver != NULL) {
 412                 index = strlen(firmware_ver);
 413                 _DEBUG_INFO("index = %d\n", index);
 414                 _DEBUG_INFO("firmware Ver2 = %s\n", firmware_ver);
 415         } else {
 416                 _DEBUG_ERROR("firmware_ver is NULL !!");
 417                 /* todo : exception handling */
 418                 return 0;
 419         }
 420
 421         char *modem_version = slp_device_info_get_modem_version();
 422         _DEBUG_INFO("firmware_ver modem - [%s]\n", modem_version);
 423         if (modem_version != NULL) {
 424                 //snprintf(firmware_ver + index, _D_SIZE_128_ / 3, "%s", modem_version + sizeof(char) * (strlen("I8800")));
 425                 snprintf(firmware_ver + index, _D_SIZE_128_ / 3, "%s", modem_version);
 426         } else {
 427                 snprintf(firmware_ver + index, _D_SIZE_128_ / 3, "%s", "XXKI1");
 428         }
 429
 430
 431
 432         if (modem_version != NULL) {
 433                 free(modem_version);
 434                 modem_version = NULL;
 435         }
 436         if (pda_version != NULL) {
 437                 free(pda_version);
 438                 pda_version = NULL;
 439         }
 440         if (csc_version != NULL) {
 441                 free(csc_version);
 442                 csc_version = NULL;
 443         }
 444
 445         _DEBUG_INFO("firmware_ver [%s]\n", firmware_ver);
 446         snprintf(firmware_version, _D_MSC_FIRMWARE_MAXSTRING_, "%s", firmware_ver);
 447         if (firmware_ver != NULL)
 448                 free(firmware_ver);
 449         _DEBUG_INFO("firmware_version [%s]\n", firmware_version);
 450
 451         vconf_set_str(DEF_DEVDETAIL_FWV, firmware_version);
 452
 453         _EXTERN_FUNC_EXIT;
 454
 455         return firmware_version;
 456 }
 457
 458 /* ====================================
 459  * device etc information
 460  * =====================================*/
 461 char *slp_device_info_get_device_type()
 462 {
 463         _EXTERN_FUNC_ENTER;
 464
 465         char *dev_type = (char *)calloc(_D_SIZE_128_, sizeof(char));
 466         if (dev_type == NULL) {
 467                 _DEBUG_ERROR("CALLOC failed !!!");
 468                 return 0;
 469         }
 470         snprintf(dev_type, _D_SIZE_128_ - 1, "%s", DEV_TYPE);
 471         _DEBUG_INFO("Device Type = %s\n", DEV_TYPE);
 472
 473         _EXTERN_FUNC_EXIT;
 474
 475         return dev_type;
 476 }
 477
 478 char *slp_device_info_get_device_id()
 479 {
 480         _EXTERN_FUNC_ENTER;
 481
 482 //      char *DeviceID = (char *)calloc(_D_SIZE_128_, sizeof(char));
 483 //      if( DeviceID == NULL ) {
 484 //              _DEBUG_ERROR("CALLOC failed !!!");
 485 //              return 0;
 486 //      }
 487 //      if (vconf_get_str(VCONFKEY_TELEPHONY_IMEI) != NULL)
 488 //              snprintf(DeviceID, _D_SIZE_128_ - 1, "IMEI:%s", vconf_get_str(VCONFKEY_TELEPHONY_IMEI));
 489 //      else
 490 //              snprintf(DeviceID, _D_SIZE_128_ - 1, "IMEI:%s", "355310046608752");
 491 //
 492 //      /*snprintf(DeviceID, _D_SIZE_128_-1, "%s", vconf_get_str(VCONFKEY_TELEPHONY_IMEI)); */
 493 //      return DeviceID;
 494
 495         TapiHandle *handle;
 496         handle = tel_init(NULL);
 497         char *imei = 0;
 498         char imei_value[30] = { 0, };
 499         if (handle == NULL) {
 500                 _DEBUG_INFO("handle is NULL !!");
 501         } else {
 502                 _DEBUG_INFO("handle : %d", handle);
 503                 //imei = tel_get_misc_me_imei_sync(handle);
 504                 imei = strdup("333333333333333");  // this code is rsa & emulator.
 505                 _DEBUG_INFO("imei : %s", imei);
 506         }
 507
 508         tel_deinit(handle);
 509
 510         if (imei != NULL) {
 511                 snprintf(imei_value, sizeof(imei_value), "%s:%s", "IMEI", imei);
 512                 _EXTERN_FUNC_EXIT;
 513                 return strdup(imei_value);
 514         } else {
 515                 return 0;
 516         }
 517
 518 }
 519
 520 char *slp_device_info_get_model_info()
 521 {
 522         _EXTERN_FUNC_ENTER;
 523
 524         char *model_info = (char *)calloc(_D_SIZE_128_, sizeof(char));
 525         if (model_info == NULL) {
 526                 _DEBUG_ERROR("CALLOC failed !!!");
 527                 return 0;
 528         }
 529         snprintf(model_info, _D_SIZE_128_ - 1, "%s", MODEL);
 530         _DEBUG_INFO("Model info = %s\n", model_info);
 531
 532         _EXTERN_FUNC_EXIT;
 533
 534         return model_info;      /* prevent */
 535 }
 536
 537 char *slp_device_info_get_manufacturer_info()
 538 {
 539         _EXTERN_FUNC_ENTER;
 540
 541         char *ManufacturerInfo = (char *)calloc(_D_SIZE_128_, sizeof(char));
 542         if (ManufacturerInfo == NULL) {
 543                 _DEBUG_ERROR("CALLOC failed !!!");
 544                 return 0;
 545         }
 546         snprintf(ManufacturerInfo, _D_SIZE_128_ - 1, "%s", MANUFACTURE);        /* prevent */
 547
 548         _DEBUG_INFO("Manufacturer = %s\n", MANUFACTURE);
 549
 550         _EXTERN_FUNC_EXIT;
 551
 552         return ManufacturerInfo;
 553 }
 554
 555 char *slp_device_info_get_oem_info()
 556 {
 557         _EXTERN_FUNC_ENTER;
 558
 559         char *oem_info = (char *)calloc(_D_SIZE_128_, sizeof(char));
 560         if (oem_info == NULL) {
 561                 _DEBUG_ERROR("CALLOC failed !!!");
 562                 return 0;
 563         }
 564         snprintf(oem_info, _D_SIZE_128_ - 1, "%s", OEM);
 565
 566         _DEBUG_INFO("OEM = %s\n", OEM);
 567
 568         _EXTERN_FUNC_EXIT;
 569
 570         return oem_info;
 571 }
 572
 573 char *slp_device_info_get_battery_level()
 574 {
 575         _EXTERN_FUNC_ENTER;
 576
 577         FILE *file = 0;
 578         unsigned char read_buf[10] = { 0, };
 579         char *battery_level = 0;
 580         int read_size = 0;
 581
 582         _DEBUG_INFO("path:%s", BATTERY_LEVEL);
 583         file = fopen(BATTERY_LEVEL, "rb");
 584         if (file != NULL) {
 585                 read_size = fread(read_buf, 10, sizeof(unsigned char), file);
 586                 battery_level = strdup((char *)read_buf);
 587
 588                 _DEBUG_INFO("read size:%d, read_buf:%s, battery:%s", read_size, read_buf, battery_level);
 589
 590         } else {
 591                 _DEBUG_INFO("ERROR: cannot read %s", BATTERY_LEVEL);
 592         }
 593
 594         if (file != NULL)
 595                 fclose(file);
 596
 597         _EXTERN_FUNC_EXIT;
 598
 599         return battery_level;
 600 }
 601
 602 /*static char *__slp_device_info_get_modem_version_for_fw()
 603 {
 604       char *ModemVersion = (char*)calloc(_D_SIZE_128_, sizeof(char));
 605           if( ModemVersion == NULL ) {
 606                   _DEBUG_ERROR("CALLOC failed !!!");
 607                   return NULL;
 608           }
 609
 610       char * get_str = slp_device_info_get_modem_version();
 611       _DEBUG_INFO("vconf telephony swversion  = %s\n", get_str);
 612       if( get_str != NULL )
 613       {
 614                         if( strncmp(get_str,"I9200", sizeof(char)*strlen("I9200") ) == 0 )
 615                                 snprintf(ModemVersion, _D_SIZE_128_/2 , "%s-", get_str + sizeof(char)*strlen("I9200") );
 616                         else
 617                                 snprintf(ModemVersion, _D_SIZE_128_/2 , "%s-", get_str);
 618        } else {
 619                         snprintf(ModemVersion, _D_SIZE_128_/2 , "%s-", "XXKH2");
 620        }
 621
 622       _DEBUG_INFO("Modem version for FirmV = %s\n", ModemVersion);
 623       return ModemVersion;
 624 }*/
 625
 626 /*char *__slp_device_info_get_CSC_version_for_fw()
 627 {
 628       char *csc_version = (char*)calloc(_D_SIZE_128_, sizeof(char));
 629           if( csc_version == NULL ) {
 630                   _DEBUG_ERROR("CALLOC failed !!!");
 631                   return NULL;
 632           }
 633
 634       FILE *file_des;
 635    file_des =fopen(CSC_DB_VERSION,"rb");
 636    int i = 0 ;
 637       if(file_des==NULL)
 638       {
 639                 _DEBUG_INFO("fopen fail - info.ini \n");
 640                 snprintf(csc_version,_D_SIZE_128_/2, "%s" , "C." );
 641                 return 0;
 642       }
 643     while( ! feof(file_des) )
 644     {
 645                 char info_temp[20] = {0,} ;
 646                 int result = 1 ;
 647                 fseek(file_des,i,SEEK_SET);
 648                 i++ ;
 649
 650                 fread(info_temp, sizeof(char) , strlen(_D_PDA_BUILD_INFO_BUILD_) , file_des ); // 2011/10/05 SCM request  _D_PDA_BUILD_INFO_MAJOR_ -> _D_PDA_BUILD_INFO_BUILD_
 651                 result = memcmp( info_temp , _D_PDA_BUILD_INFO_BUILD_ , strlen(_D_PDA_BUILD_INFO_BUILD_) ) ;
 652                 if( !result )
 653                 {
 654                         char csc_version_check[64] = {0};
 655                         int read_pos = 0 ;
 656                         //memcpy(csc_version_check, "C." , strlen("C.") );
 657                         //read_pos = strlen(csc_version_check);
 658                         while( !feof(file_des) )
 659                         {
 660                                 fread(csc_version_check+read_pos,sizeof(char), 1, file_des);
 661                                 if( csc_version_check[read_pos] == '_' )
 662                                         csc_version_check[read_pos] = '-' ;
 663                                 else if( csc_version_check[read_pos] == '\n' )
 664                                         break;
 665                                 else if( csc_version_check[read_pos] == ';' )
 666                                 {
 667                                         csc_version_check[read_pos] = NULL;
 668                                         break;
 669                                 }
 670
 671                                 read_pos++;
 672                         }
 673
 674                         if( strncmp(csc_version_check,"I9200OXA-c210-2011", sizeof(char)*strlen("I9200OXA-c210-2011") ) == 0 )
 675                                 snprintf(csc_version,_D_SIZE_128_/2,"%s", csc_version_check + sizeof(char)*strlen("I9200OXA-c210-2011"));
 676                         else if( strncmp(csc_version_check,"I9200OXA-2011", sizeof(char)*strlen("I9200OXA-2011") ) == 0 )
 677                                 snprintf(csc_version,_D_SIZE_128_/2,"%s", csc_version_check + sizeof(char)*strlen("I9200OXA-c210-2011"));
 678
 679                         else if( strncmp(csc_version_check,"I9200-c210-2011", sizeof(char)*strlen("I9200-c210-2011") ) == 0 )
 680                                 snprintf(csc_version,_D_SIZE_128_/2,"%s", csc_version_check + sizeof(char)*strlen("I9200-c210-2011"));
 681                         else if( strncmp(csc_version_check,"I9200-2011", sizeof(char)*strlen("I9200-2011") ) == 0 )
 682                                 snprintf(csc_version,_D_SIZE_128_/2,"%s", csc_version_check + sizeof(char)*strlen("I9200-2011"));
 683                         else
 684                                 snprintf(csc_version,_D_SIZE_128_/2,"%s", csc_version_check );
 685
 686                                 _DEBUG_INFO("fread csc_version - [%s]\n" , csc_version);
 687                                 break;
 688                         }
 689                 }
 690
 691                 if( file_des != NULL )
 692                         fclose(file_des);
 693
 694                 return csc_version;
 695 }*/
 696
 697 /*
 698 char *__slp_device_info_get_PDA_version_for_fw()
 699 {
 700       char *pda_version = (char*)calloc(_D_SIZE_128_, sizeof(char));
 701           if( pda_version == NULL ) {
 702                   _DEBUG_ERROR("CALLOC failed !!!");
 703                   return NULL;
 704           }
 705       FILE *file_des;
 706       file_des =fopen(PDA_BIN_VERSION,"rb");
 707       int i = 0 ;
 708
 709       if(file_des==NULL)
 710       {
 711                         _DEBUG_INFO("fopen fail - info.ini \n");
 712                         snprintf(pda_version,_D_SIZE_128_/2, "%s" , "P.I9200XXJI-" );
 713                         return 0;
 714       }
 715
 716     while( ! feof(file_des) )
 717     {
 718                 char info_temp[20] = {0,} ;
 719                 int result = 1 ;
 720                 fseek(file_des,i,SEEK_SET);
 721                 i++ ;
 722
 723                 fread(info_temp, sizeof(char) , strlen(_D_PDA_BUILD_INFO_BUILD_) , file_des ); // 2011/10/05 SCM request  _D_PDA_BUILD_INFO_MAJOR_ -> _D_PDA_BUILD_INFO_BUILD_
 724                 result = memcmp( info_temp , _D_PDA_BUILD_INFO_BUILD_ , strlen(_D_PDA_BUILD_INFO_BUILD_) ) ;
 725                 If( !result )
 726                 {
 727                         char pda_version_check[64] = {0};
 728                         int read_pos = 0 ;
 729                         //memcpy(pda_version_check, "P." , strlen("P.") );
 730                         //read_pos = strlen(pda_version_check);
 731                         while( !feof(file_des) )
 732                         {
 733                                 fread(pda_version_check+read_pos,sizeof(char), 1, file_des);
 734                                 if( pda_version_check[read_pos] == '_' )
 735                                         pda_version_check[read_pos] = '-' ;
 736                                 else if( pda_version_check[read_pos] == '\n' )
 737                                         break;
 738                                 else if( pda_version_check[read_pos] == ';' )
 739                                 {
 740                                         pda_version_check[read_pos] = NULL;
 741                                         break;
 742                                 }
 743
 744                                 read_pos++;
 745                         }
 746                         pda_version_check[read_pos] = '-';
 747                         _DEBUG_INFO( "pda_version_check = %s\n", pda_version_check);
 748
 749                         if( strncmp(pda_version_check,"I9200-c210-2011", sizeof(char)*strlen("I9200-c210-2011") ) == 0 )
 750                                 snprintf(pda_version,_D_SIZE_128_/2,"%s", pda_version_check + sizeof(char)*strlen("I9200-c210-2011"));
 751                         else if( strncmp(pda_version_check,"I9200-2011", sizeof(char)*strlen("I9200-2011") ) == 0 )
 752                                 snprintf(pda_version,_D_SIZE_128_/2,"%s", pda_version_check + sizeof(char)*strlen("I9200-2011"));
 753                         else
 754                                 snprintf(pda_version,_D_SIZE_128_/2,"%s", pda_version_check );
 755
 756                         _DEBUG_INFO("fread pda_version - [%s]\n" , pda_version);
 757                         break;
 758                 }
 759         }
 760
 761         if( file_des != NULL )
 762                 fclose(file_des);
 763
 764         return pda_version;
 765 }
 766 */