src/co_modem.c

   1 /*
   2  * libtcore
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co. Ltd. All rights reserved.
   5  * Copyright (c) 2013 Intel Corporation. All rights reserved.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <glib.h>
  21
  22 #include "tcore.h"
  23 #include "plugin.h"
  24 #include "co_modem.h"
  25
  26 typedef struct {
  27         TcoreModemOps *ops;
  28
  29         gboolean flight_mode;
  30         gboolean powered;
  31 } PrivateObject;
  32
  33 static void _po_free_hook(CoreObject *co)
  34 {
  35         PrivateObject *po = tcore_object_ref_object(co);
  36         tcore_check_return(po != NULL);
  37
  38         tcore_free(po->ops);
  39         tcore_free(po);
  40         tcore_object_link_object(co, NULL);
  41 }
  42
  43 static void _po_clone_hook(CoreObject *src, CoreObject *dest)
  44 {
  45         PrivateObject *dest_po = NULL;
  46         PrivateObject *src_po = tcore_object_ref_object(src);
  47
  48         tcore_check_return_assert(src_po != NULL);
  49         tcore_check_return_assert(src_po->ops != NULL);
  50
  51         dest_po = tcore_malloc0(sizeof(PrivateObject));
  52         dest_po->ops = tcore_memdup(src_po->ops, sizeof(TcoreModemOps));
  53         tcore_object_link_object(dest, dest_po);
  54 }
  55
  56 static TelReturn _dispatcher(CoreObject *co,
  57         TcoreCommand command, const void *request,
  58         TcoreObjectResponseCallback cb, const void *user_data)
  59 {
  60         TcoreModemOps *modem = NULL;
  61         PrivateObject *po = tcore_object_ref_object(co);
  62         tcore_check_return_value_assert(po != NULL, TEL_RETURN_INVALID_PARAMETER);
  63         tcore_check_return_value_assert(po->ops != NULL, TEL_RETURN_INVALID_PARAMETER);
  64         modem = po->ops;
  65
  66         switch (command) {
  67         case TCORE_COMMAND_MODEM_SET_POWER_STATUS:
  68                 if (modem->set_power_status)
  69                         return modem->set_power_status(co,
  70                                         *((TelModemPowerStatus *)request),
  71                                         cb, (void *)user_data);
  72                 break;
  73
  74         case TCORE_COMMAND_MODEM_SET_FLIGHTMODE:
  75                 if (modem->set_flight_mode)
  76                         return modem->set_flight_mode(co,
  77                                         *(gboolean *)request,
  78                                         cb, (void *)user_data);
  79                 break;
  80
  81         case TCORE_COMMAND_MODEM_GET_IMEI:
  82                 if (modem->get_imei)
  83                         return modem->get_imei(co, cb, (void *)user_data);
  84                 break;
  85
  86         case TCORE_COMMAND_MODEM_GET_VERSION:
  87                 if (modem->get_version)
  88                         return modem->get_version(co, cb, (void *)user_data);
  89                 break;
  90
  91         case TCORE_COMMAND_MODEM_GET_FLIGHTMODE:
  92                 if (modem->get_flight_mode)
  93                         return modem->get_flight_mode(co, cb, (void *)user_data);
  94                 break;
  95
  96         default:
  97                 err("Unsupported Command [0x%x]", command);
  98                 break;
  99         }
 100         err("Operation NOT Supported");
 101         return TEL_RETURN_OPERATION_NOT_SUPPORTED;
 102 }
 103
 104 void tcore_modem_override_ops(CoreObject *co, TcoreModemOps *ops)
 105 {
 106         PrivateObject *po = tcore_object_ref_object(co);
 107
 108         tcore_check_return_assert(po != NULL);
 109         tcore_check_return_assert(po->ops != NULL);
 110         tcore_check_return_assert(ops != NULL);
 111
 112         if (ops->set_power_status)
 113                 po->ops->set_power_status = ops->set_power_status;
 114         if (ops->set_flight_mode)
 115                 po->ops->set_flight_mode = ops->set_flight_mode;
 116         if (ops->get_imei)
 117                 po->ops->get_imei = ops->get_imei;
 118         if (ops->get_version)
 119                 po->ops->get_version = ops->get_version;
 120         if (ops->get_flight_mode)
 121                 po->ops->get_flight_mode = ops->get_flight_mode;
 122 }
 123
 124 gboolean tcore_modem_set_ops(CoreObject *co, TcoreModemOps *ops)
 125 {
 126         PrivateObject *po;
 127         tcore_check_return_value(co != NULL, FALSE);
 128
 129         po = tcore_object_ref_object(co);
 130         tcore_check_return_value_assert(po != NULL, FALSE);
 131
 132         if (po->ops != NULL) {
 133                 tcore_free(po->ops);
 134                 po->ops = NULL;
 135         }
 136
 137         if (ops != NULL)
 138                 po->ops = tcore_memdup((gconstpointer)ops, sizeof(TcoreModemOps));
 139
 140         return TRUE;
 141 }
 142
 143 CoreObject *tcore_modem_new(TcorePlugin *p,
 144                         TcoreModemOps *ops, TcoreHal *hal)
 145 {
 146         CoreObject *co = NULL;
 147         PrivateObject *po = NULL;
 148         tcore_check_return_value_assert(p != NULL, NULL);
 149
 150         co = tcore_object_new(p, hal);
 151         tcore_check_return_value_assert(co != NULL, NULL);
 152
 153         po = tcore_malloc0(sizeof(PrivateObject));
 154
 155         if (ops != NULL)
 156                 po->ops = tcore_memdup(ops, sizeof(TcoreModemOps));
 157
 158         tcore_object_set_type(co, CORE_OBJECT_TYPE_MODEM);
 159         tcore_object_link_object(co, po);
 160         tcore_object_set_free_hook(co, _po_free_hook);
 161         tcore_object_set_clone_hook(co, _po_clone_hook);
 162         tcore_object_set_dispatcher(co, _dispatcher);
 163         return co;
 164 }
 165
 166 void tcore_modem_free(CoreObject *co)
 167 {
 168         CORE_OBJECT_CHECK(co, CORE_OBJECT_TYPE_MODEM);
 169         tcore_object_free(co);
 170 }
 171
 172 gboolean tcore_modem_set_flight_mode_state(CoreObject *co, gboolean state)
 173 {
 174         PrivateObject *po = tcore_object_ref_object(co);
 175         tcore_check_return_value_assert(po != NULL, FALSE);
 176
 177         po->flight_mode = state;
 178         return TRUE;
 179 }
 180
 181 gboolean tcore_modem_get_flight_mode_state(CoreObject *co, gboolean *state)
 182 {
 183         PrivateObject *po = tcore_object_ref_object(co);
 184         tcore_check_return_value_assert(po != NULL, FALSE);
 185
 186         *state = po->flight_mode;
 187         return TRUE;
 188 }
 189
 190 gboolean tcore_modem_set_powered(CoreObject *co, gboolean pwr)
 191 {
 192         PrivateObject *po = tcore_object_ref_object(co);
 193         tcore_check_return_value_assert(po != NULL, FALSE);
 194
 195         po->powered = pwr;
 196         return TRUE;
 197 }
 198
 199 gboolean tcore_modem_get_powered(CoreObject *co, gboolean *pwr)
 200 {
 201         PrivateObject *po = tcore_object_ref_object(co);
 202         tcore_check_return_value_assert(po != NULL, FALSE);
 203
 204         *pwr = po->powered;
 205         return TRUE;
 206 }