commands-nas.c

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