commands-nas.c

   1 #include "qmi-message.h"
   2
   3 static struct qmi_nas_set_system_selection_preference_request sel_req;
   4
   5 #define cmd_nas_do_set_system_selection_cb no_cb
   6 static enum qmi_cmd_result
   7 cmd_nas_do_set_system_selection_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
   8 {
   9         qmi_set_nas_set_system_selection_preference_request(msg, &sel_req);
  10         return QMI_CMD_REQUEST;
  11 }
  12
  13 static enum qmi_cmd_result
  14 do_sel_network(void)
  15 {
  16         static bool use_sel_req = false;
  17
  18         if (!use_sel_req) {
  19                 use_sel_req = true;
  20                 uqmi_add_command(NULL, __UQMI_COMMAND_nas_do_set_system_selection);
  21         }
  22
  23         return QMI_CMD_DONE;
  24 }
  25
  26 #define cmd_nas_set_network_modes_cb no_cb
  27 static enum qmi_cmd_result
  28 cmd_nas_set_network_modes_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
  29 {
  30         static const struct {
  31                 const char *name;
  32                 QmiNasRatModePreference val;
  33         } modes[] = {
  34                 { "cdma", QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1X | QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1XEVDO },
  35                 { "td-scdma", QMI_NAS_RAT_MODE_PREFERENCE_TD_SCDMA },
  36                 { "gsm", QMI_NAS_RAT_MODE_PREFERENCE_GSM },
  37                 { "umts", QMI_NAS_RAT_MODE_PREFERENCE_UMTS },
  38                 { "lte", QMI_NAS_RAT_MODE_PREFERENCE_LTE },
  39         };
  40         QmiNasRatModePreference val = 0;
  41         char *word;
  42         int i;
  43
  44         for (word = strtok(arg, ",");
  45              word;
  46              word = strtok(NULL, ",")) {
  47                 bool found = false;
  48
  49                 for (i = 0; i < ARRAY_SIZE(modes); i++) {
  50                         if (strcmp(word, modes[i].name) != 0 &&
  51                                 strcmp(word, "all") != 0)
  52                                 continue;
  53
  54                         val |= modes[i].val;
  55                         found = true;
  56                 }
  57
  58                 if (!found) {
  59                         uqmi_add_error("Invalid network mode");
  60                         return QMI_CMD_EXIT;
  61                 }
  62         }
  63
  64         qmi_set(&sel_req, mode_preference, val);
  65         return do_sel_network();
  66 }
  67
  68 #define cmd_nas_set_network_preference_cb no_cb
  69 static enum qmi_cmd_result
  70 cmd_nas_set_network_preference_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
  71 {
  72         QmiNasGsmWcdmaAcquisitionOrderPreference pref = QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_AUTOMATIC;
  73
  74         if (!strcmp(arg, "gsm"))
  75                 pref = QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_GSM;
  76         else if (!strcmp(arg, "wcdma"))
  77                 pref = QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_WCDMA;
  78
  79         qmi_set(&sel_req, gsm_wcdma_acquisition_order_preference, pref);
  80         return do_sel_network();
  81 }
  82
  83 #define cmd_nas_set_roaming_cb no_cb
  84 static enum qmi_cmd_result
  85 cmd_nas_set_roaming_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
  86 {
  87         QmiNasRoamingPreference pref;
  88
  89         if (!strcmp(arg, "any"))
  90                 pref = QMI_NAS_ROAMING_PREFERENCE_ANY;
  91         else if (!strcmp(arg, "only"))
  92                 pref = QMI_NAS_ROAMING_PREFERENCE_NOT_OFF;
  93         else if (!strcmp(arg, "off"))
  94                 pref = QMI_NAS_ROAMING_PREFERENCE_OFF;
  95         else
  96                 return uqmi_add_error("Invalid argument");
  97
  98         qmi_set(&sel_req, roaming_preference, pref);
  99         return do_sel_network();
 100 }
 101
 102 #define cmd_nas_initiate_network_register_cb no_cb
 103 static enum qmi_cmd_result
 104 cmd_nas_initiate_network_register_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 105 {
 106         static struct qmi_nas_initiate_network_register_request register_req;
 107         qmi_set_nas_initiate_network_register_request(msg, &register_req);
 108         return QMI_CMD_REQUEST;
 109 }
 110
 111 static void
 112 cmd_nas_get_signal_info_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 113 {
 114         struct qmi_nas_get_signal_info_response res;
 115         void *c;
 116
 117         qmi_parse_nas_get_signal_info_response(msg, &res);
 118
 119         c = blobmsg_open_table(&status, NULL);
 120         if (res.set.cdma_signal_strength) {
 121                 blobmsg_add_string(&status, "type", "cdma");
 122                 blobmsg_add_u32(&status, "rssi", (int32_t) res.data.cdma_signal_strength.rssi);
 123                 blobmsg_add_u32(&status, "ecio", (int32_t) res.data.cdma_signal_strength.ecio);
 124         }
 125
 126         if (res.set.hdr_signal_strength) {
 127                 blobmsg_add_string(&status, "type", "hdr");
 128                 blobmsg_add_u32(&status, "rssi", (int32_t) res.data.hdr_signal_strength.rssi);
 129                 blobmsg_add_u32(&status, "ecio", (int32_t) res.data.hdr_signal_strength.ecio);
 130                 blobmsg_add_u32(&status, "io", res.data.hdr_signal_strength.io);
 131         }
 132
 133         if (res.set.gsm_signal_strength) {
 134                 blobmsg_add_string(&status, "type", "gsm");
 135                 blobmsg_add_u32(&status, "signal", (int32_t) res.data.gsm_signal_strength);
 136         }
 137
 138         if (res.set.wcdma_signal_strength) {
 139                 blobmsg_add_string(&status, "type", "wcdma");
 140                 blobmsg_add_u32(&status, "rssi", (int32_t) res.data.wcdma_signal_strength.rssi);
 141                 blobmsg_add_u32(&status, "ecio", (int32_t) res.data.wcdma_signal_strength.ecio);
 142         }
 143
 144         if (res.set.lte_signal_strength) {
 145                 blobmsg_add_string(&status, "type", "lte");
 146                 blobmsg_add_u32(&status, "rssi", (int32_t) res.data.lte_signal_strength.rssi);
 147                 blobmsg_add_u32(&status, "rsrq", (int32_t) res.data.lte_signal_strength.rsrq);
 148                 blobmsg_add_u32(&status, "rsrp", (int32_t) res.data.lte_signal_strength.rsrp);
 149                 blobmsg_add_u32(&status, "snr", (int32_t) res.data.lte_signal_strength.snr);
 150         }
 151
 152         blobmsg_close_table(&status, c);
 153 }
 154
 155 static enum qmi_cmd_result
 156 cmd_nas_get_signal_info_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 157 {
 158         qmi_set_nas_get_signal_info_request(msg);
 159         return QMI_CMD_REQUEST;
 160 }
 161
 162 static void
 163 cmd_nas_get_serving_system_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 164 {
 165         struct qmi_nas_get_serving_system_response res;
 166         static const char *reg_states[] = {
 167                 [QMI_NAS_REGISTRATION_STATE_NOT_REGISTERED] = "not_registered",
 168                 [QMI_NAS_REGISTRATION_STATE_REGISTERED] = "registered",
 169                 [QMI_NAS_REGISTRATION_STATE_NOT_REGISTERED_SEARCHING] = "searching",
 170                 [QMI_NAS_REGISTRATION_STATE_REGISTRATION_DENIED] = "registering_denied",
 171                 [QMI_NAS_REGISTRATION_STATE_UNKNOWN] = "unknown",
 172         };
 173         void *c;
 174
 175         qmi_parse_nas_get_serving_system_response(msg, &res);
 176
 177         c = blobmsg_open_table(&status, NULL);
 178         if (res.set.serving_system) {
 179                 int state = res.data.serving_system.registration_state;
 180
 181                 if (state > QMI_NAS_REGISTRATION_STATE_UNKNOWN)
 182                         state = QMI_NAS_REGISTRATION_STATE_UNKNOWN;
 183
 184                 blobmsg_add_string(&status, "registration", reg_states[state]);
 185         }
 186         if (res.set.current_plmn) {
 187                 blobmsg_add_u32(&status, "plmn_mcc", res.data.current_plmn.mcc);
 188                 blobmsg_add_u32(&status, "plmn_mnc", res.data.current_plmn.mnc);
 189                 if (res.data.current_plmn.description)
 190                         blobmsg_add_string(&status, "plmn_description", res.data.current_plmn.description);
 191         }
 192
 193         if (res.set.roaming_indicator)
 194                 blobmsg_add_u8(&status, "roaming", !res.data.roaming_indicator);
 195
 196         blobmsg_close_table(&status, c);
 197 }
 198
 199 static enum qmi_cmd_result
 200 cmd_nas_get_serving_system_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 201 {
 202         qmi_set_nas_get_serving_system_request(msg);
 203         return QMI_CMD_REQUEST;
 204 }
 205
 206 static void
 207 cmd_nas_network_scan_cb(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg)
 208 {
 209         static struct qmi_nas_network_scan_response res;
 210         const char *network_status[] = {
 211                 "current_serving",
 212                 "available",
 213                 "home",
 214                 "roaming",
 215                 "forbidden",
 216                 "not_forbidden",
 217                 "preferred",
 218                 "not_preferred",
 219         };
 220         const char *radio[] = {
 221                 [QMI_NAS_RADIO_INTERFACE_NONE] = "none",
 222                 [QMI_NAS_RADIO_INTERFACE_CDMA_1X] = "cdma-1x",
 223                 [QMI_NAS_RADIO_INTERFACE_CDMA_1XEVDO] = "cdma-1x_evdo",
 224                 [QMI_NAS_RADIO_INTERFACE_AMPS] = "amps",
 225                 [QMI_NAS_RADIO_INTERFACE_GSM] = "gsm",
 226                 [QMI_NAS_RADIO_INTERFACE_UMTS] = "umts",
 227                 [QMI_NAS_RADIO_INTERFACE_LTE] = "lte",
 228                 [QMI_NAS_RADIO_INTERFACE_TD_SCDMA] = "td-scdma",
 229         };
 230         void *t, *c, *info, *stat;
 231         int i, j;
 232
 233         qmi_parse_nas_network_scan_response(msg, &res);
 234
 235         t = blobmsg_open_table(&status, NULL);
 236
 237         c = blobmsg_open_array(&status, "network_info");
 238         for (i = 0; i < res.data.network_information_n; i++) {
 239                 info = blobmsg_open_table(&status, NULL);
 240                 blobmsg_add_u32(&status, "mcc", res.data.network_information[i].mcc);
 241                 blobmsg_add_u32(&status, "mnc", res.data.network_information[i].mnc);
 242                 if (res.data.network_information[i].description)
 243                         blobmsg_add_string(&status, "description", res.data.network_information[i].description);
 244                 stat = blobmsg_open_array(&status, "status");
 245                 for (j = 0; j < ARRAY_SIZE(network_status); j++) {
 246                         if (!(res.data.network_information[i].network_status & (1 << j)))
 247                                 continue;
 248
 249                         blobmsg_add_string(&status, NULL, network_status[j]);
 250                 }
 251                 blobmsg_close_array(&status, stat);
 252                 blobmsg_close_table(&status, info);
 253         }
 254         blobmsg_close_array(&status, c);
 255
 256         c = blobmsg_open_array(&status, "radio_access_technology");
 257         for (i = 0; i < res.data.radio_access_technology_n; i++) {
 258                 const char *r = "unknown";
 259                 int r_i = res.data.radio_access_technology[i].radio_interface;
 260
 261                 info = blobmsg_open_table(&status, NULL);
 262                 blobmsg_add_u32(&status, "mcc", res.data.radio_access_technology[i].mcc);
 263                 blobmsg_add_u32(&status, "mnc", res.data.radio_access_technology[i].mnc);
 264                 if (r_i >= 0 && r_i < ARRAY_SIZE(radio))
 265                         r = radio[r_i];
 266
 267                 blobmsg_add_string(&status, "radio", r);
 268                 blobmsg_close_table(&status, info);
 269         }
 270         blobmsg_close_array(&status, c);
 271
 272         blobmsg_close_table(&status, t);
 273 }
 274
 275 static enum qmi_cmd_result
 276 cmd_nas_network_scan_prepare(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, char *arg)
 277 {
 278         struct qmi_nas_network_scan_request sreq = {};
 279
 280         qmi_set_nas_network_scan_request(msg, &sreq);
 281         return QMI_CMD_REQUEST;
 282 }