os_intf.h

00001 /*
00002  * Copyright (c) 2013 Digi International Inc.,
00003  * All rights not expressly granted are reserved.
00004  *
00005  * This Source Code Form is subject to the terms of the Mozilla Public
00006  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
00007  * You can obtain one at http://mozilla.org/MPL/2.0/.
00008  *
00009  * Digi International Inc. 11001 Bren Road East, Minnetonka, MN 55343
00010  * =======================================================================
00011  */
00012 #include "debug.h"
00013 
00014 /* facility opcodes */
00015 #define E_MSG_MT2_MSG_NUM          0x0000
00016 #define E_MSG_FAC_FW_NUM           0x0070
00017 #define E_MSG_FAC_RCI_NUM          0x00a0
00018 #define E_MSG_FAC_MSG_NUM          0x00c0
00019 #define E_MSG_FAC_DEV_LOOP_NUM     0xff00
00020 #define E_MSG_FAC_CC_NUM           0xffff
00021 
00022 #define named_buffer_id(name)  name##_static_buffer_id
00023 typedef enum
00024 {
00025     named_buffer_id(none) = 0,
00026     named_buffer_id(msg_facility),
00027     named_buffer_id(msg_session),
00028     named_buffer_id(msg_service),
00029     named_buffer_id(msg_session_client),
00030     named_buffer_id(put_request),
00031     named_buffer_id(sm_session),
00032     named_buffer_id(sm_data_block),
00033     named_buffer_id(sm_packet),
00034     named_buffer_id(data_point_block),
00035     named_buffer_id(connector_data) = 29,
00036     named_buffer_id(cc_facility) = 30,
00037     named_buffer_id(fw_facility) = 31
00038 
00039 } connector_static_buffer_id_t;
00040 
00041 #ifdef CONNECTOR_NO_MALLOC
00042 static connector_status_t malloc_static_data(connector_data_t * const connector_ptr,
00043                                                   size_t const size,
00044                                                   connector_static_buffer_id_t const buffer_id,
00045                                                   void ** const ptr);
00046 
00047 static void free_static_data(connector_data_t * const connector_ptr,
00048                                  connector_static_buffer_id_t const buffer_id,
00049                                  void * const ptr);
00050 #endif
00051 
00052 
00053 static connector_callback_status_t connector_callback(connector_callback_t  const callback, connector_class_id_t const class_id,  connector_request_id_t const request_id,
00054                                                                        void * const data)
00055 {
00056     connector_callback_status_t status = callback(class_id, request_id, data);
00057 
00058     switch (status)
00059     {
00060         case connector_callback_continue:
00061         case connector_callback_busy:
00062         case connector_callback_error:
00063             break;
00064 
00065         case connector_callback_unrecognized:
00066             connector_debug_printf("connector_callback : callback returns unrecognized request for request=%d class_id = %d\n",
00067                         request_id.config_request, class_id);
00068             break;
00069 
00070         case connector_callback_abort:
00071             connector_debug_printf("connector_callback: callback for class id = %d request id = %d returned abort\n", class_id, request_id.config_request);
00072             break;
00073 
00074         default:
00075             connector_debug_printf("connector_callback: callback for class id = %d request id = %d returned invalid return code %d\n", class_id, request_id.config_request, status);
00076             status = connector_callback_abort;
00077             break;
00078     }
00079 
00080     return status;
00081 }
00082 
00083 
00084 static connector_status_t get_system_time(connector_data_t * const connector_ptr, unsigned long * const uptime)
00085 {
00086     connector_status_t result = connector_abort;
00087     connector_callback_status_t status;
00088     connector_request_id_t request_id;
00089     connector_os_system_up_time_t data;
00090 
00091     *uptime = 0;
00092 
00093     /* Call callback to get system up time in second */
00094     request_id.os_request = connector_request_id_os_system_up_time;
00095     status = connector_callback(connector_ptr->callback, connector_class_id_operating_system, request_id, &data);
00096     switch (status)
00097     {
00098     case connector_callback_continue:
00099         /* coverity[uninit_use] */
00100         *uptime = data.sys_uptime;
00101         result = connector_working;
00102         break;
00103     case connector_callback_abort:
00104         break;
00105     default:
00106         ASSERT(connector_false);
00107         break;
00108     }
00109 
00110     return result;
00111 }
00112 
00113 #ifndef CONNECTOR_NO_MALLOC
00114 static connector_status_t malloc_cb(connector_callback_t  const callback, size_t const length, void ** ptr)
00115 {
00116     connector_status_t result = connector_working;
00117     connector_callback_status_t status;
00118     connector_os_malloc_t data;
00119     connector_request_id_t request_id;
00120 
00121     request_id.os_request = connector_request_id_os_malloc;
00122     data.size = length;
00123     data.ptr = *ptr = NULL;
00124 
00125     status = connector_callback(callback, connector_class_id_operating_system, request_id, &data);
00126     switch (status)
00127     {
00128     case connector_callback_continue:
00129         if (data.ptr == NULL)
00130         {
00131             result = (notify_error_status(callback, connector_class_id_operating_system, request_id, connector_invalid_data) == connector_working) ? connector_pending : connector_abort;
00132         }
00133         else
00134         {
00135             *ptr = data.ptr;
00136         }
00137         break;
00138 
00139     case connector_callback_busy:
00140         result = connector_pending;
00141         break;
00142 
00143     case connector_callback_abort:
00144     case connector_callback_unrecognized:
00145     case connector_callback_error:
00146         result = connector_abort;
00147         break;
00148     }
00149     return result;
00150 }
00151 
00152 static connector_status_t malloc_data(connector_data_t * const connector_ptr, size_t const length, void ** ptr)
00153 {
00154     return malloc_cb(connector_ptr->callback, length, ptr);
00155 }
00156 
00157 static connector_status_t free_data(connector_data_t * const connector_ptr, void * const ptr)
00158 {
00159     connector_status_t result = connector_working;
00160     connector_request_id_t request_id;
00161     connector_os_free_t data;
00162 
00163     request_id.os_request = connector_request_id_os_free;
00164     data.ptr = ptr;
00165 
00166     {
00167         connector_callback_status_t const callback_status = connector_callback(connector_ptr->callback, connector_class_id_operating_system, request_id, &data);
00168         switch (callback_status)
00169         {
00170             case connector_callback_continue:
00171                 break;
00172             default:
00173                 result = connector_abort;
00174                 break;
00175         }
00176     }
00177 
00178     return result;
00179 }
00180 #endif
00181 
00182 
00183 static connector_status_t malloc_data_buffer(connector_data_t * const connector_ptr, size_t const length, connector_static_buffer_id_t id, void ** ptr)
00184 {
00185     connector_status_t status;
00186 
00187 #ifndef CONNECTOR_NO_MALLOC
00188     UNUSED_PARAMETER(id);
00189     status = malloc_data(connector_ptr, length, ptr);
00190 #else
00191     status = malloc_static_data(connector_ptr, length, id, ptr);
00192 #endif
00193     return status;
00194 }
00195 
00196 static connector_status_t free_data_buffer(connector_data_t * const connector_ptr, connector_static_buffer_id_t id, void * const ptr)
00197 {
00198     connector_status_t status = connector_working;
00199 
00200 #ifndef CONNECTOR_NO_MALLOC
00201     UNUSED_PARAMETER(id);
00202     status = free_data(connector_ptr, ptr);
00203 #else
00204     free_static_data(connector_ptr, id, ptr);
00205 #endif
00206 
00207     return status;
00208 }
00209 
00210 static connector_status_t yield_process(connector_data_t * const connector_ptr, connector_status_t const status)
00211 {
00212     connector_status_t result = connector_working;
00213 
00214     {
00215         connector_request_id_t request_id;
00216         connector_os_yield_t data;
00217         connector_callback_status_t callback_status;
00218 
00219         request_id.os_request = connector_request_id_os_yield;
00220         data.status = status;
00221 
00222         callback_status = connector_callback(connector_ptr->callback, connector_class_id_operating_system, request_id, &data);
00223 
00224         switch (callback_status)
00225         {
00226             case connector_callback_continue:
00227                 break;
00228             default:
00229                 result = connector_abort;
00230                 break;
00231         }
00232     }
00233 
00234     return result;
00235 }
00236 
00237 static connector_status_t connector_reboot(connector_data_t * const connector_ptr)
00238 {
00239     connector_status_t result;
00240 
00241     connector_callback_status_t status = connector_callback_continue;
00242     connector_request_id_t request_id;
00243 
00244     connector_class_id_t class_id = connector_class_id_operating_system;
00245     request_id.os_request = connector_request_id_os_reboot;
00246 
00247     /* Device Cloud reboots us */
00248 
00249     status = connector_callback(connector_ptr->callback, class_id, request_id, NULL);
00250     switch (status)
00251     {
00252     case connector_callback_continue:
00253         result = connector_working;
00254         break;
00255     case connector_callback_busy:
00256         result = connector_pending;
00257         break;
00258     default:
00259         result = connector_abort;
00260         break;
00261     }
00262 
00263     return result;
00264 
00265 }
00266