4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Junhwan An <jh48.an@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
34 #include <user_request.h>
36 #include <core_object.h>
40 #define SERVER_INIT_WAIT_TIMEOUT 500
42 #define DEVICE_NAME_LEN_MAX 16
43 #define DEVICE_NAME_PREFIX "pdp"
45 #define BUF_LEN_MAX 512
47 #define CORE_OBJECT_NAME_MAX 16
49 #define MODEM_PLUGIN_NAME "atmodem-plugin.so"
51 #define BIT_SIZE(type) (sizeof(type) * 8)
53 #define COPY_MASK(type) ((0xffffffff) >> (32 - BIT_SIZE(type)))
55 #define MASK(width, offset, data) \
56 (((width) == BIT_SIZE(data)) ? (data) : \
57 ((((COPY_MASK(data) << (BIT_SIZE(data) - ((width) % BIT_SIZE(data)))) & COPY_MASK(data)) >> (offset)) & (data))) \
60 #define MASK_AND_SHIFT(width, offset, shift, data) \
61 ((((signed) (shift)) < 0) ? \
62 MASK((width), (offset), (data)) << -(shift) : \
63 MASK((width), (offset), (data)) >> (((signed) (shift)))) \
67 guint watch_id_vdpram;
77 char co_name[CORE_OBJECT_NAME_MAX];
80 static char __util_unpackb(const char *src, int pos, int len)
88 rshift = MAX(8 - (pos + len), 0);
91 result = MASK_AND_SHIFT(len, pos, rshift, (unsigned char)*src);
93 result = MASK(8 - pos, pos, (unsigned char)*src);
97 if (len > 0) result = (result << len) | (*src >> (8 - len)); // if any bits left
103 static char __util_convert_byte_hexchar(char val)
108 hex_char = (char) (val + '0');
109 } else if (val >= 10 && val <= 15) {
110 hex_char = (char) (val - 10 + 'A');
118 static gboolean __util_byte_to_hex(const char *byte_pdu, char *hex_pdu, int num_bytes)
124 for (i = 0; i < num_bytes * 2; i++) {
125 nibble = __util_unpackb(byte_pdu, buf_pos, 4);
127 hex_pdu[i] = __util_convert_byte_hexchar(nibble);
133 static TcoreModem *__get_modem(TcorePlugin *modem_iface_plugin)
135 PluginData *user_data;
137 if (modem_iface_plugin == NULL)
140 user_data = tcore_plugin_ref_user_data(modem_iface_plugin);
141 if (user_data == NULL)
144 /* 'modem' corresponding to Modem Interface plug-in */
145 return user_data->modem;
148 static guint __vmodem_reencode_mt_sms(gchar *mt_sms, guint mt_sms_len)
150 #define VMODEM_CR 0x0D
151 #define VMODEM_LF 0x0A
152 #define VMODEM_COLON 0x3A
154 gchar sms_buf[BUF_LEN_MAX] = {0, };
155 guint sca_len, pdu_len, tpdu_len;
156 gushort tpdu_len_ptr = 0;
157 gchar tpdu_len_str[8] = {0};
158 guint i, local_index = 0;
160 if (mt_sms_len > BUF_LEN_MAX)
161 mt_sms_len = BUF_LEN_MAX-2;
163 for (i = 0; i < mt_sms_len; i++) {
164 if ((mt_sms[i] == VMODEM_CR)
165 && (mt_sms[i+1] == VMODEM_LF)) {
166 sms_buf[i] = mt_sms[i];
168 sms_buf[i] = mt_sms[i];
172 else if (mt_sms[i] == VMODEM_COLON)
176 sms_buf[i] = mt_sms[i];
179 dbg("SCA length: [%d] TPDU length offset: [%d]", sca_len, tpdu_len_ptr);
181 pdu_len = (mt_sms_len-i);
182 tpdu_len = pdu_len - (sca_len+1);
183 dbg("PDU length: [%d] Actual TPDU Length: [%d]", pdu_len, tpdu_len);
185 if (pdu_len >= 100 && tpdu_len < 100) {
187 * Move back complete buffer by a Byte (to fill up the
188 * void created by hundreds place).
191 sms_buf[i-3] = VMODEM_CR;
192 sms_buf[i-2] = VMODEM_LF;
194 __util_byte_to_hex(&mt_sms[i], &sms_buf[i-1], pdu_len);
195 i += (2*pdu_len - 1);
198 __util_byte_to_hex(&mt_sms[i], &sms_buf[i], pdu_len);
202 /* Update actual TPDU length */
203 snprintf(tpdu_len_str, 8, "%d", tpdu_len);
204 switch (strlen(tpdu_len_str)) {
205 case 4: /* 100s place */
206 dbg("1000s : [%d]", tpdu_len_str[local_index]);
208 sms_buf[tpdu_len_ptr] = tpdu_len_str[local_index];
212 case 3: /* 100s place */
213 dbg("100s : [%d]", tpdu_len_str[local_index]);
215 sms_buf[tpdu_len_ptr] = tpdu_len_str[local_index];
219 case 2: /* 10s place */
220 dbg("10s : [%d]", tpdu_len_str[local_index]);
222 sms_buf[tpdu_len_ptr] = tpdu_len_str[local_index];
226 case 1: /* 1s place */
227 dbg("1s : [%d]", tpdu_len_str[local_index]);
229 sms_buf[tpdu_len_ptr] = tpdu_len_str[local_index];
233 dbg("Unsupported length: [%d]", strlen(tpdu_len_str));
237 /* Append <CR> & <LF> */
241 sms_buf[i++] = VMODEM_CR;
242 sms_buf[i++] = VMODEM_LF;
243 dbg("MT SMS: [%s]", sms_buf);
245 tcore_util_hex_dump(" ", (int)i, sms_buf);
250 * 'data_len' is not accessed hence it need not be updated.
252 g_strlcpy(mt_sms, sms_buf, i+1);
253 dbg("Encoded MT SMS: [%d][%s]", i, mt_sms);
258 static guint __register_gio_watch(TcoreHal *h, int fd, void *callback)
260 GIOChannel *channel = NULL;
263 dbg("Register to Watch list - fd: [%d]", fd);
265 if ((fd < 0) || (callback == NULL))
268 channel = g_io_channel_unix_new(fd);
269 source = g_io_add_watch(channel, G_IO_IN, (GIOFunc) callback, h);
270 g_io_channel_unref(channel);
276 static void __deregister_gio_watch(guint watch_id)
278 dbg("Deregister Watch ID: [%d]", watch_id);
281 g_source_remove(watch_id);
284 static gboolean __load_modem_plugin(gpointer data)
288 struct custom_data *user_data;
290 unsigned int slot_count = 1;
300 plugin = tcore_hal_ref_plugin(hal);
301 modem = __get_modem(plugin);
303 /* Load Modem Plug-in */
304 if (tcore_server_load_modem_plugin(tcore_plugin_ref_server(plugin),
305 modem, MODEM_PLUGIN_NAME) == TCORE_RETURN_FAILURE) {
306 err("Load Modem Plug-in - [FAIL]");
310 dbg("Load Modem Plug-in - [SUCCESS]");
313 tcore_server_send_notification(tcore_plugin_ref_server(plugin),
314 NULL, TNOTI_SERVER_ADDED_MODEM_PLUGIN_COMPLETED,
315 sizeof(slot_count), &slot_count);
317 /* To stop the cycle need to return FALSE */
321 user_data = tcore_hal_ref_user_data(hal);
322 if (user_data == NULL)
325 /* Deregister from Watch list */
326 __deregister_gio_watch(user_data->watch_id_vdpram);
331 /* Close VDPRAM device */
332 vdpram_close(user_data->vdpram_fd);
334 /* Free custom data */
340 static TReturn _modem_power(TcoreHal *hal, gboolean enable)
342 struct custom_data *user_data;
344 user_data = tcore_hal_ref_user_data(hal);
345 if (user_data == NULL) {
346 err(" User data is NULL");
347 return TCORE_RETURN_FAILURE;
350 if (enable == TRUE) { /* POWER ON */
351 if (FALSE == vdpram_poweron(user_data->vdpram_fd)) {
352 err(" Power ON - [FAIL]");
353 return TCORE_RETURN_FAILURE;
356 /* Set Power State - ON */
357 tcore_hal_set_power_state(hal, TRUE);
358 } else { /* POWER OFF */
359 if (vdpram_poweroff(user_data->vdpram_fd) == FALSE) {
360 err(" Power OFF - [FAIL]");
361 return TCORE_RETURN_FAILURE;
364 /* Set Power state - OFF */
365 tcore_hal_set_power_state(hal, FALSE);
368 return TCORE_RETURN_SUCCESS;
371 static gboolean on_recv_vdpram_message(GIOChannel *channel,
372 GIOCondition condition, gpointer data)
374 TcoreHal *hal = data;
375 struct custom_data *custom;
376 char buf[BUF_LEN_MAX];
380 custom = tcore_hal_ref_user_data(hal);
381 memset(buf, 0x0, BUF_LEN_MAX);
383 /* Read from Device */
384 n = vdpram_tty_read(custom->vdpram_fd, buf, BUF_LEN_MAX);
386 err(" Read error - Data received: [%d]", n);
389 dbg(" DPRAM Receive - Data length: [%d]", n);
391 msg("\n---------- [RECV] Length of received data: [%d] ----------\n", n);
393 /* Emit receive callback */
394 tcore_hal_emit_recv_callback(hal, n, buf);
397 * This is to ensure that the received MT SMS (+CMT:) is
398 * encoded according to 3GPP standard
400 if (buf[0] == 0x2B && buf[1] == 0x43 && buf[2] == 0x4D
401 && buf[3] == 0x54 && buf[4] == 0x3A) {
402 dbg("Received - [MT SMS]");
403 n = __vmodem_reencode_mt_sms((gchar *)buf, n);
405 else if (buf[0] == 0x25) {
406 dbg("Replaced % --> +");
410 /* Dispatch received data to response handler */
411 dbg("Invoking tcore_hal_dispatch_response_data()");
412 ret = tcore_hal_dispatch_response_data(hal, 0, n, buf);
413 msg("\n---------- [RECV FINISH] Receive processing: [%d] ----------\n", ret);
418 static TReturn hal_power(TcoreHal *hal, gboolean flag)
420 return _modem_power(hal, flag);
423 static TReturn hal_send(TcoreHal *hal, unsigned int data_len, void *data)
426 struct custom_data *user_data;
428 if (tcore_hal_get_power_state(hal) == FALSE) {
429 err(" HAL Power state - OFF");
430 return TCORE_RETURN_FAILURE;
433 user_data = tcore_hal_ref_user_data(hal);
434 if (user_data == NULL) {
435 err(" User data is NULL");
436 return TCORE_RETURN_FAILURE;
439 ret = vdpram_tty_write(user_data->vdpram_fd, data, data_len);
441 err(" Write failed");
442 return TCORE_RETURN_FAILURE;
445 dbg("vdpram_tty_write success ret=%d (fd=%d, len=%d)",
446 ret, user_data->vdpram_fd, data_len);
447 return TCORE_RETURN_SUCCESS;
451 static TReturn hal_setup_netif(CoreObject *co,
452 TcoreHalSetupNetifCallback func, void *user_data,
453 unsigned int cid, gboolean enable)
455 char ifname[DEVICE_NAME_LEN_MAX];
459 const char *control = NULL;
462 err(" Context ID: [%d]", cid);
463 return TCORE_RETURN_EINVAL;
466 if (enable == TRUE) {
467 dbg(" ACTIVATE - Context ID: [%d]", cid);
468 control = "/sys/class/net/svnet0/pdp/activate";
470 dbg(" DEACTIVATE - Context ID: [%d]", cid);
471 control = "/sys/class/net/svnet0/pdp/deactivate";
474 fd = open(control, O_WRONLY);
476 err(" Failed to Open interface: [%s]", control);
478 /* Invoke callback function */
480 func(co, -1, NULL, user_data);
482 return TCORE_RETURN_FAILURE;
485 /* Context ID needs to be written to the Device */
486 snprintf(buf, sizeof(buf), "%d", cid);
487 size = write(fd, buf, strlen(buf));
488 dbg(" SIZE [%d]", size);
494 snprintf(ifname, DEVICE_NAME_LEN_MAX, "%s%d", DEVICE_NAME_PREFIX, (cid - 1));
495 dbg(" Interface Name: [%s]", ifname);
497 /* Invoke callback function */
499 func(co, 0, ifname, user_data);
501 return TCORE_RETURN_SUCCESS;
505 static struct tcore_hal_operations hal_ops = {
508 .setup_netif = hal_setup_netif,
511 static gboolean on_load()
518 static gboolean on_init(TcorePlugin *plugin)
521 PluginData *user_data;
522 struct custom_data *data;
526 if (plugin == NULL) {
527 err(" PLug-in is NULL");
531 /* User Data for Modem Interface Plug-in */
532 user_data = g_try_new0(PluginData, 1);
533 if (user_data == NULL) {
534 err(" Failed to allocate memory for Plugin data");
538 /* Register to Server */
539 user_data->modem = tcore_server_register_modem(tcore_plugin_ref_server(plugin), plugin);
540 if (user_data->modem == NULL){
541 err(" Registration Failed");
545 dbg(" Registered from Server");
548 data = g_try_new0(struct custom_data, 1);
550 err(" Failed to allocate memory for Custom data");
552 /* Unregister from Server */
553 tcore_server_unregister_modem(tcore_plugin_ref_server(plugin), user_data->modem);
560 data->vdpram_fd = vdpram_open();
563 * Create and initialize HAL
565 hal = tcore_hal_new(plugin, "vmodem", &hal_ops, TCORE_HAL_MODE_AT);
567 /* Close VDPRAM device */
568 vdpram_close(data->vdpram_fd);
570 /* Fre custom data */
573 /* Fre Plugin data */
576 /* Unregister from Server */
577 tcore_server_unregister_modem(tcore_plugin_ref_server(plugin), user_data->modem);
581 user_data->hal = hal;
583 /* Link custom data to HAL user data */
584 tcore_hal_link_user_data(hal, data);
586 /* Set HAL as Modem Interface Plug-in's User data */
587 tcore_plugin_link_user_data(plugin, user_data);
589 /* Register to Watch list */
590 data->watch_id_vdpram = __register_gio_watch(hal,
591 data->vdpram_fd, on_recv_vdpram_message);
592 dbg(" fd: [%d] Watch ID: [%d]",
593 data->vdpram_fd, data->watch_id_vdpram);
595 /* Power ON VDPRAM device */
596 if (_modem_power(hal, TRUE) == TCORE_RETURN_SUCCESS) {
597 dbg(" Power ON - [SUCCESS]");
599 err(" Power ON - [FAIL]");
603 /* Check CP Power ON */
604 g_timeout_add_full(G_PRIORITY_HIGH, SERVER_INIT_WAIT_TIMEOUT, __load_modem_plugin, hal, 0);
606 dbg("[VMMODEM] Exit");
610 /* Deregister from Watch list */
611 __deregister_gio_watch(data->watch_id_vdpram);
616 /* Close VDPRAM device */
617 vdpram_close(data->vdpram_fd);
619 /* Free custom data */
625 /* Unregister from Server */
626 tcore_server_unregister_modem(tcore_plugin_ref_server(plugin), user_data->modem);
631 static void on_unload(TcorePlugin *plugin)
634 struct custom_data *data;
635 PluginData *user_data;
642 user_data = tcore_plugin_ref_user_data(plugin);
643 if (user_data == NULL)
646 hal = user_data->hal;
648 /* Unload Modem Plug-in */
649 #if 0 /* TODO - Open the code below */
650 tcore_server_unload_modem_plugin(tcore_plugin_ref_server(plugin), plugin);
652 data = tcore_hal_ref_user_data(hal);
656 /* Deregister from Watch list */
657 __deregister_gio_watch(data->watch_id_vdpram);
658 dbg(" Deregistered Watch ID");
664 /* Close VDPRAM device */
665 vdpram_close(data->vdpram_fd);
666 dbg(" Closed VDPRAM device");
668 /* Free custom data */
671 tcore_server_unregister_modem(tcore_plugin_ref_server(plugin), user_data->modem);
672 dbg(" Unregistered from Server");
674 dbg(" Unloaded MODEM");
678 /* VMODEM Descriptor Structure */
679 EXPORT_API struct tcore_plugin_define_desc plugin_define_desc = {
681 .priority = TCORE_PLUGIN_PRIORITY_HIGH,