Home | History | Annotate | Download | only in utils
      1 /* Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
      2  *
      3  * Redistribution and use in source and binary forms, with or without
      4  * modification, are permitted provided that the following conditions are
      5  * met:
      6  *     * Redistributions of source code must retain the above copyright
      7  *       notice, this list of conditions and the following disclaimer.
      8  *     * Redistributions in binary form must reproduce the above
      9  *       copyright notice, this list of conditions and the following
     10  *       disclaimer in the documentation and/or other materials provided
     11  *       with the distribution.
     12  *     * Neither the name of The Linux Foundation nor the names of its
     13  *       contributors may be used to endorse or promote products derived
     14  *       from this software without specific prior written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27  *
     28  */
     29 
     30 #include <stdio.h>
     31 #include <stdlib.h>
     32 #include <string.h>
     33 #include <sys/types.h>
     34 #include <sys/stat.h>
     35 #include <fcntl.h>
     36 #include <errno.h>
     37 #include <hardware/gps.h>
     38 #include <cutils/properties.h>
     39 #include "loc_target.h"
     40 #include "loc_log.h"
     41 #include "log_util.h"
     42 
     43 #define APQ8064_ID_1 "109"
     44 #define APQ8064_ID_2 "153"
     45 #define MPQ8064_ID_1 "130"
     46 #define MSM8930_ID_1 "142"
     47 #define MSM8930_ID_2 "116"
     48 #define APQ8030_ID_1 "157"
     49 #define APQ8074_ID_1 "184"
     50 
     51 #define LINE_LEN 100
     52 #define STR_LIQUID    "Liquid"
     53 #define STR_SURF      "Surf"
     54 #define STR_MTP       "MTP"
     55 #define STR_APQ       "apq"
     56 #define STR_AUTO      "auto"
     57 #define IS_STR_END(c) ((c) == '\0' || (c) == '\n' || (c) == '\r')
     58 #define LENGTH(s) (sizeof(s) - 1)
     59 #define GPS_CHECK_NO_ERROR 0
     60 #define GPS_CHECK_NO_GPS_HW 1
     61 /* When system server is started, it uses 20 seconds as ActivityManager
     62  * timeout. After that it sends SIGSTOP signal to process.
     63  */
     64 #define QCA1530_DETECT_TIMEOUT 15
     65 #define QCA1530_DETECT_PRESENT "yes"
     66 #define QCA1530_DETECT_PROGRESS "detect"
     67 
     68 static unsigned int gTarget = (unsigned int)-1;
     69 
     70 static int read_a_line(const char * file_path, char * line, int line_size)
     71 {
     72     FILE *fp;
     73     int result = 0;
     74 
     75     * line = '\0';
     76     fp = fopen(file_path, "r" );
     77     if( fp == NULL ) {
     78         LOC_LOGE("open failed: %s: %s\n", file_path, strerror(errno));
     79         result = -1;
     80     } else {
     81         int len;
     82         fgets(line, line_size, fp);
     83         len = strlen(line);
     84         len = len < line_size - 1? len : line_size - 1;
     85         line[len] = '\0';
     86         LOC_LOGD("cat %s: %s", file_path, line);
     87         fclose(fp);
     88     }
     89     return result;
     90 }
     91 
     92 /*!
     93  * \brief Checks if QCA1530 is avalable.
     94  *
     95  * Function verifies if qca1530 SoC is configured on the device. The test is
     96  * based on property value. For 1530 scenario, the value shall be one of the
     97  * following: "yes", "no", "detect". All other values are treated equally to
     98  * "no". When the value is "detect" the system waits for SoC detection to
     99  * finish before returning result.
    100  *
    101  * \retval true - QCA1530 is available.
    102  * \retval false - QCA1530 is not available.
    103  */
    104 static bool is_qca1530(void)
    105 {
    106     static const char qca1530_property_name[] = "sys.qca1530";
    107     bool res = false;
    108     int ret, i;
    109     char buf[PROPERTY_VALUE_MAX];
    110 
    111     memset(buf, 0, sizeof(buf));
    112 
    113     for (i = 0; i < QCA1530_DETECT_TIMEOUT; ++i)
    114     {
    115         ret = property_get(qca1530_property_name, buf, NULL);
    116         if (ret < 0)
    117         {
    118             LOC_LOGV( "qca1530: property %s is not accessible, ret=%d",
    119                   qca1530_property_name,
    120                   ret);
    121 
    122             break;
    123         }
    124 
    125         LOC_LOGV( "qca1530: property %s is set to %s",
    126                   qca1530_property_name,
    127                   buf);
    128 
    129         if (!memcmp(buf, QCA1530_DETECT_PRESENT,
    130                     sizeof(QCA1530_DETECT_PRESENT)))
    131         {
    132             res = true;
    133             break;
    134         }
    135         if (!memcmp(buf, QCA1530_DETECT_PROGRESS,
    136                     sizeof(QCA1530_DETECT_PROGRESS)))
    137         {
    138             LOC_LOGV("qca1530: SoC detection is in progress.");
    139             sleep(1);
    140             continue;
    141         }
    142         break;
    143     }
    144 
    145     LOC_LOGD("qca1530: detected=%s", res ? "true" : "false");
    146     return res;
    147 }
    148 
    149 /*The character array passed to this function should have length
    150   of atleast PROPERTY_VALUE_MAX*/
    151 void loc_get_target_baseband(char *baseband, int array_length)
    152 {
    153     if(baseband && (array_length >= PROPERTY_VALUE_MAX)) {
    154         property_get("ro.baseband", baseband, "");
    155         LOC_LOGD("%s:%d]: Baseband: %s\n", __func__, __LINE__, baseband);
    156     }
    157     else {
    158         LOC_LOGE("%s:%d]: NULL parameter or array length less than PROPERTY_VALUE_MAX\n",
    159                  __func__, __LINE__);
    160     }
    161 }
    162 
    163 /*The character array passed to this function should have length
    164   of atleast PROPERTY_VALUE_MAX*/
    165 void loc_get_platform_name(char *platform_name, int array_length)
    166 {
    167     if(platform_name && (array_length >= PROPERTY_VALUE_MAX)) {
    168         property_get("ro.board.platform", platform_name, "");
    169         LOC_LOGD("%s:%d]: Target name: %s\n", __func__, __LINE__, platform_name);
    170     }
    171     else {
    172         LOC_LOGE("%s:%d]: Null parameter or array length less than PROPERTY_VALUE_MAX\n",
    173                  __func__, __LINE__);
    174     }
    175 }
    176 
    177 unsigned int loc_get_target(void)
    178 {
    179     if (gTarget != (unsigned int)-1)
    180         return gTarget;
    181 
    182     static const char hw_platform[]      = "/sys/devices/soc0/hw_platform";
    183     static const char id[]               = "/sys/devices/soc0/soc_id";
    184     static const char hw_platform_dep[]  =
    185         "/sys/devices/system/soc/soc0/hw_platform";
    186     static const char id_dep[]           = "/sys/devices/system/soc/soc0/id";
    187     static const char mdm[]              = "/dev/mdm"; // No such file or directory
    188 
    189     char rd_hw_platform[LINE_LEN];
    190     char rd_id[LINE_LEN];
    191     char rd_mdm[LINE_LEN];
    192     char baseband[LINE_LEN];
    193 
    194     if (is_qca1530()) {
    195         gTarget = TARGET_QCA1530;
    196         goto detected;
    197     }
    198 
    199     loc_get_target_baseband(baseband, sizeof(baseband));
    200 
    201     if (!access(hw_platform, F_OK)) {
    202         read_a_line(hw_platform, rd_hw_platform, LINE_LEN);
    203     } else {
    204         read_a_line(hw_platform_dep, rd_hw_platform, LINE_LEN);
    205     }
    206     if (!access(id, F_OK)) {
    207         read_a_line(id, rd_id, LINE_LEN);
    208     } else {
    209         read_a_line(id_dep, rd_id, LINE_LEN);
    210     }
    211     if( !memcmp(baseband, STR_AUTO, LENGTH(STR_AUTO)) )
    212     {
    213           gTarget = TARGET_AUTO;
    214           goto detected;
    215     }
    216     if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ){
    217 
    218         if( !memcmp(rd_id, MPQ8064_ID_1, LENGTH(MPQ8064_ID_1))
    219             && IS_STR_END(rd_id[LENGTH(MPQ8064_ID_1)]) )
    220             gTarget = TARGET_MPQ;
    221         else
    222             gTarget = TARGET_APQ_SA;
    223     }
    224     else {
    225         if( (!memcmp(rd_hw_platform, STR_LIQUID, LENGTH(STR_LIQUID))
    226              && IS_STR_END(rd_hw_platform[LENGTH(STR_LIQUID)])) ||
    227             (!memcmp(rd_hw_platform, STR_SURF,   LENGTH(STR_SURF))
    228              && IS_STR_END(rd_hw_platform[LENGTH(STR_SURF)])) ||
    229             (!memcmp(rd_hw_platform, STR_MTP,   LENGTH(STR_MTP))
    230              && IS_STR_END(rd_hw_platform[LENGTH(STR_MTP)]))) {
    231 
    232             if (!read_a_line( mdm, rd_mdm, LINE_LEN))
    233                 gTarget = TARGET_MDM;
    234         }
    235         else if( (!memcmp(rd_id, MSM8930_ID_1, LENGTH(MSM8930_ID_1))
    236                    && IS_STR_END(rd_id[LENGTH(MSM8930_ID_1)])) ||
    237                   (!memcmp(rd_id, MSM8930_ID_2, LENGTH(MSM8930_ID_2))
    238                    && IS_STR_END(rd_id[LENGTH(MSM8930_ID_2)])) )
    239              gTarget = TARGET_MSM_NO_SSC;
    240         else
    241              gTarget = TARGET_UNKNOWN;
    242     }
    243 
    244 detected:
    245     LOC_LOGD("HAL: %s returned %d", __FUNCTION__, gTarget);
    246     return gTarget;
    247 }
    248 
    249 /*Reads the property ro.lean to identify if this is a lean target
    250   Returns:
    251   0 if not a lean and mean target
    252   1 if this is a lean and mean target
    253 */
    254 int loc_identify_lean_target()
    255 {
    256     int ret = 0;
    257     char lean_target[PROPERTY_VALUE_MAX];
    258     property_get("ro.lean", lean_target, "");
    259     LOC_LOGD("%s:%d]: lean target: %s\n", __func__, __LINE__, lean_target);
    260     return !(strncmp(lean_target, "true", PROPERTY_VALUE_MAX));
    261 }
    262