biscuit

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README

qmicli.h (8928B)


      1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
      2 /*
      3  * qmicli -- Command line interface to control QMI devices
      4  *
      5  * This program is free software: you can redistribute it and/or modify
      6  * it under the terms of the GNU General Public License as published by
      7  * the Free Software Foundation, either version 2 of the License, or
      8  * (at your option) any later version.
      9  *
     10  * This program is distributed in the hope that it will be useful,
     11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13  * GNU General Public License for more details.
     14  *
     15  * You should have received a copy of the GNU General Public License
     16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
     17  *
     18  * Copyright (C) 2012-2017 Aleksander Morgado <aleksander@aleksander.es>
     19  */
     20 
     21 #include <glib.h>
     22 #include <libqmi-glib.h>
     23 
     24 #ifndef __QMICLI_H__
     25 #define __QMICLI_H__
     26 
     27 /* Common */
     28 void          qmicli_async_operation_done (gboolean reported_operation_status,
     29                                            gboolean skip_cid_release);
     30 void          qmicli_expect_indications   (void);
     31 
     32 /* qmi_wwan specific */
     33 GOptionGroup *qmicli_qmiwwan_get_option_group (void);
     34 gboolean      qmicli_qmiwwan_options_enabled  (void);
     35 void          qmicli_qmiwwan_run              (QmiDevice    *device,
     36                                                GCancellable *cancellable);
     37 
     38 /* link management */
     39 GOptionGroup *qmicli_link_management_get_option_group (void);
     40 gboolean      qmicli_link_management_options_enabled  (void);
     41 void          qmicli_link_management_run              (QmiDevice    *device,
     42                                                        GCancellable *cancellable);
     43 
     44 #if defined HAVE_QMI_SERVICE_DMS
     45 GOptionGroup *qmicli_dms_get_option_group (void);
     46 gboolean      qmicli_dms_options_enabled  (void);
     47 void          qmicli_dms_run              (QmiDevice *device,
     48                                            QmiClientDms *client,
     49                                            GCancellable *cancellable);
     50 #endif
     51 
     52 #if defined HAVE_QMI_SERVICE_WDS
     53 GOptionGroup *qmicli_wds_get_option_group (void);
     54 gboolean      qmicli_wds_options_enabled  (void);
     55 void          qmicli_wds_run              (QmiDevice *device,
     56                                            QmiClientWds *client,
     57                                            GCancellable *cancellable);
     58 #endif
     59 
     60 #if defined HAVE_QMI_SERVICE_NAS
     61 GOptionGroup *qmicli_nas_get_option_group (void);
     62 gboolean      qmicli_nas_options_enabled  (void);
     63 void          qmicli_nas_run              (QmiDevice *device,
     64                                            QmiClientNas *client,
     65                                            GCancellable *cancellable);
     66 #endif
     67 
     68 #if defined HAVE_QMI_SERVICE_PBM
     69 GOptionGroup *qmicli_pbm_get_option_group (void);
     70 gboolean      qmicli_pbm_options_enabled  (void);
     71 void          qmicli_pbm_run              (QmiDevice *device,
     72                                            QmiClientPbm *client,
     73                                            GCancellable *cancellable);
     74 #endif
     75 
     76 #if defined HAVE_QMI_SERVICE_PDC
     77 GOptionGroup *qmicli_pdc_get_option_group (void);
     78 gboolean      qmicli_pdc_options_enabled  (void);
     79 void          qmicli_pdc_run              (QmiDevice *device,
     80                                            QmiClientPdc *client,
     81                                            GCancellable *cancellable);
     82 #endif
     83 
     84 #if defined HAVE_QMI_SERVICE_UIM
     85 GOptionGroup *qmicli_uim_get_option_group (void);
     86 gboolean      qmicli_uim_options_enabled  (void);
     87 void          qmicli_uim_run              (QmiDevice *device,
     88                                            QmiClientUim *client,
     89                                            GCancellable *cancellable);
     90 #endif
     91 
     92 #if defined HAVE_QMI_SERVICE_WMS
     93 GOptionGroup *qmicli_wms_get_option_group (void);
     94 gboolean      qmicli_wms_options_enabled  (void);
     95 void          qmicli_wms_run              (QmiDevice *device,
     96                                            QmiClientWms *client,
     97                                            GCancellable *cancellable);
     98 #endif
     99 
    100 #if defined HAVE_QMI_SERVICE_WDA
    101 GOptionGroup *qmicli_wda_get_option_group (void);
    102 gboolean      qmicli_wda_options_enabled  (void);
    103 void          qmicli_wda_run              (QmiDevice *device,
    104                                            QmiClientWda *client,
    105                                            GCancellable *cancellable);
    106 #endif
    107 
    108 #if defined HAVE_QMI_SERVICE_VOICE
    109 GOptionGroup *qmicli_voice_get_option_group (void);
    110 gboolean      qmicli_voice_options_enabled  (void);
    111 void          qmicli_voice_run              (QmiDevice *device,
    112                                              QmiClientVoice *client,
    113                                              GCancellable *cancellable);
    114 #endif
    115 
    116 #if defined HAVE_QMI_SERVICE_LOC
    117 GOptionGroup *qmicli_loc_get_option_group (void);
    118 gboolean      qmicli_loc_options_enabled  (void);
    119 void          qmicli_loc_run              (QmiDevice *device,
    120                                            QmiClientLoc *client,
    121                                            GCancellable *cancellable);
    122 #endif
    123 
    124 #if defined HAVE_QMI_SERVICE_QOS
    125 GOptionGroup *qmicli_qos_get_option_group (void);
    126 gboolean      qmicli_qos_options_enabled  (void);
    127 void          qmicli_qos_run              (QmiDevice *device,
    128                                            QmiClientQos *client,
    129                                            GCancellable *cancellable);
    130 #endif
    131 
    132 #if defined HAVE_QMI_SERVICE_GAS
    133 GOptionGroup *qmicli_gas_get_option_group (void);
    134 gboolean      qmicli_gas_options_enabled  (void);
    135 void          qmicli_gas_run              (QmiDevice *device,
    136                                            QmiClientGas *client,
    137                                            GCancellable *cancellable);
    138 #endif
    139 
    140 #if defined HAVE_QMI_SERVICE_GMS
    141 GOptionGroup *qmicli_gms_get_option_group (void);
    142 gboolean      qmicli_gms_options_enabled  (void);
    143 void          qmicli_gms_run              (QmiDevice *device,
    144                                            QmiClientGms *client,
    145                                            GCancellable *cancellable);
    146 #endif
    147 
    148 #if defined HAVE_QMI_SERVICE_DSD
    149 GOptionGroup *qmicli_dsd_get_option_group (void);
    150 gboolean      qmicli_dsd_options_enabled  (void);
    151 void          qmicli_dsd_run              (QmiDevice *device,
    152                                            QmiClientDsd *client,
    153                                            GCancellable *cancellable);
    154 #endif
    155 
    156 #if defined HAVE_QMI_SERVICE_SAR
    157 GOptionGroup *qmicli_sar_get_option_group (void);
    158 gboolean      qmicli_sar_options_enabled  (void);
    159 void          qmicli_sar_run              (QmiDevice *device,
    160                                            QmiClientSar *client,
    161                                            GCancellable *cancellable);
    162 #endif
    163 
    164 #if defined HAVE_QMI_SERVICE_DPM
    165 GOptionGroup *qmicli_dpm_get_option_group (void);
    166 gboolean      qmicli_dpm_options_enabled  (void);
    167 void          qmicli_dpm_run              (QmiDevice *device,
    168                                            QmiClientDpm *client,
    169                                            GCancellable *cancellable);
    170 #endif
    171 
    172 #if defined HAVE_QMI_SERVICE_FOX
    173 GOptionGroup *qmicli_fox_get_option_group (void);
    174 gboolean      qmicli_fox_options_enabled  (void);
    175 void          qmicli_fox_run              (QmiDevice *device,
    176                                            QmiClientFox *client,
    177                                            GCancellable *cancellable);
    178 #endif
    179 
    180 #if defined HAVE_QMI_SERVICE_ATR
    181 GOptionGroup *qmicli_atr_get_option_group (void);
    182 gboolean      qmicli_atr_options_enabled  (void);
    183 void          qmicli_atr_run              (QmiDevice *device,
    184                                            QmiClientAtr *client,
    185                                            GCancellable *cancellable);
    186 #endif
    187 
    188 #if defined HAVE_QMI_SERVICE_IMSP
    189 GOptionGroup *qmicli_imsp_get_option_group (void);
    190 gboolean      qmicli_imsp_options_enabled  (void);
    191 void          qmicli_imsp_run              (QmiDevice *device,
    192                                             QmiClientImsp *client,
    193                                             GCancellable *cancellable);
    194 #endif
    195 
    196 #if defined HAVE_QMI_SERVICE_IMSA
    197 GOptionGroup *qmicli_imsa_get_option_group (void);
    198 gboolean      qmicli_imsa_options_enabled  (void);
    199 void          qmicli_imsa_run              (QmiDevice *device,
    200                                             QmiClientImsa *client,
    201                                             GCancellable *cancellable);
    202 #endif
    203 
    204 #if defined HAVE_QMI_SERVICE_IMS
    205 GOptionGroup *qmicli_ims_get_option_group (void);
    206 gboolean      qmicli_ims_options_enabled  (void);
    207 void          qmicli_ims_run              (QmiDevice *device,
    208                                            QmiClientIms *client,
    209                                            GCancellable *cancellable);
    210 #endif
    211 
    212 #endif /* __QMICLI_H__ */