lwm2m_os.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2022 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef LWM2M_OS_H__
#define LWM2M_OS_H__
 
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define LWM2M_OS_MAX_WORK_QS 2
 
#define LWM2M_OS_MAX_TIMER_COUNT (4 + (LWM2M_OS_MAX_WORK_QS * 4))
 
typedef int lwm2m_os_work_q_t;
typedef int lwm2m_os_timer_t;
 
#define LWM2M_OS_MAX_SEM_COUNT (6 + (LWM2M_OS_MAX_WORK_QS * 1))
 
typedef int lwm2m_os_sem_t;
 
#define LWM2M_OS_LTE_MODE_NONE   -1
/* LTE Rel-13 Cat-M1 HD-FDD == E-UTRAN == LTE-M */
#define LWM2M_OS_LTE_MODE_CAT_M1  6
/* LTE Rel-13 Cat-NB1 HD-FDD || LTE Rel-14 Cat-NB1 and Cat-NB2 HD-FDD == E-UTRAN NB-S1 == NB-IoT */
#define LWM2M_OS_LTE_MODE_CAT_NB1 7
 
#define LWM2M_OS_STORAGE_BASE 0xCA00
#define LWM2M_OS_STORAGE_END  0xCAFF
 
typedef void (*lwm2m_os_at_handler_callback_t)(const char *notif);
 
typedef void (*lwm2m_os_timer_handler_t)(lwm2m_os_timer_t *timer);
 
struct lwm2m_os_sms_deliver_address {
        char   *address_str;
        uint8_t length;
};
 
struct lwm2m_os_sms_udh_app_port {
        bool present;
        uint16_t dest_port;
        uint16_t src_port;
};
 
struct lwm2m_os_sms_deliver_header {
        struct lwm2m_os_sms_deliver_address originating_address;
        struct lwm2m_os_sms_udh_app_port    app_port;
};
 
union lwm2m_os_sms_header {
        struct lwm2m_os_sms_deliver_header deliver;
};
 
struct lwm2m_os_sms_data {
        union lwm2m_os_sms_header header;
        int payload_len;
        char *payload;
};
 
typedef void (*lwm2m_os_sms_callback_t)(struct lwm2m_os_sms_data *const data, void *context);
 
#define LWM2M_OS_DOWNLOAD_EVT_FRAGMENT 0
#define LWM2M_OS_DOWNLOAD_EVT_ERROR    1
#define LWM2M_OS_DOWNLOAD_EVT_DONE     2
#define LWM2M_OS_DOWNLOAD_EVT_CLOSED   3
struct lwm2m_os_download_evt {
        int id;
        union {
                int error;
                struct lwm2m_os_fragment {
                        const void *buf;
                        size_t len;
                } fragment;
        };
};
 
enum lwm2m_os_pdn_fam {
        LWM2M_OS_PDN_FAM_IPV4,
        LWM2M_OS_PDN_FAM_IPV6,
        LWM2M_OS_PDN_FAM_IPV4V6,
        LWM2M_OS_PDN_FAM_NONIP,
};
 
struct lwm2m_os_download_cfg {
        const int *sec_tag_list;
        uint8_t sec_tag_count;
        int pdn_id;
        enum lwm2m_os_pdn_fam family;
};
 
typedef int (*lwm2m_os_download_callback_t)(const struct lwm2m_os_download_evt *event);
 
enum lwm2m_os_pdn_event {
        LWM2M_OS_PDN_EVENT_CNEC_ESM,
        LWM2M_OS_PDN_EVENT_ACTIVATED,
        LWM2M_OS_PDN_EVENT_DEACTIVATED,
        LWM2M_OS_PDN_EVENT_IPV6_UP,
        LWM2M_OS_PDN_EVENT_IPV6_DOWN,
        LWM2M_OS_PDN_EVENT_NETWORK_DETACHED,
};
 
typedef void (*lwm2m_os_pdn_event_handler_t)
        (uint8_t cid, enum lwm2m_os_pdn_event event, int reason);
 
int lwm2m_os_pdn_ctx_create(uint8_t *cid, lwm2m_os_pdn_event_handler_t cb);
 
int lwm2m_os_pdn_ctx_configure(uint8_t cid, const char *apn, enum lwm2m_os_pdn_fam family);
 
int lwm2m_os_pdn_ctx_destroy(uint8_t cid);
 
int lwm2m_os_pdn_activate(uint8_t cid, int *esm, enum lwm2m_os_pdn_fam *family);
 
int lwm2m_os_pdn_deactivate(uint8_t cid);
 
int lwm2m_os_pdn_id_get(uint8_t cid);
 
int lwm2m_os_pdn_default_callback_set(lwm2m_os_pdn_event_handler_t cb);
 
void *lwm2m_os_malloc(size_t size);
 
void lwm2m_os_free(void *ptr);
 
int lwm2m_os_sem_init(lwm2m_os_sem_t **sem, unsigned int initial_count, unsigned int limit);
 
int lwm2m_os_sem_take(lwm2m_os_sem_t *sem, int timeout);
 
void lwm2m_os_sem_give(lwm2m_os_sem_t *sem);
 
void lwm2m_os_sem_reset(lwm2m_os_sem_t *sem);
 
int64_t lwm2m_os_uptime_get(void);
 
int64_t lwm2m_os_uptime_delta(int64_t *ref);
 
int lwm2m_os_sleep(int ms);
 
void lwm2m_os_sys_reset(void);
 
uint32_t lwm2m_os_rand_get(void);
 
int lwm2m_os_storage_delete(uint16_t id);
 
int lwm2m_os_storage_read(uint16_t id, void *data, size_t len);
 
int lwm2m_os_storage_write(uint16_t id, const void *data, size_t len);
 
lwm2m_os_work_q_t *lwm2m_os_work_q_start(int index, const char *name);
 
void lwm2m_os_timer_get(lwm2m_os_timer_handler_t handler, lwm2m_os_timer_t **timer);
 
void lwm2m_os_timer_release(lwm2m_os_timer_t *timer);
 
int lwm2m_os_timer_start(lwm2m_os_timer_t *timer, int64_t delay);
 
int lwm2m_os_timer_start_on_q(lwm2m_os_work_q_t *work_q, lwm2m_os_timer_t *timer, int64_t delay);
 
void lwm2m_os_timer_cancel(lwm2m_os_timer_t *timer, bool sync);
 
int64_t lwm2m_os_timer_remaining(lwm2m_os_timer_t *timer);
 
bool lwm2m_os_timer_is_pending(lwm2m_os_timer_t *timer);
 
int lwm2m_os_at_init(lwm2m_os_at_handler_callback_t callback);
 
int lwm2m_os_sms_client_register(lwm2m_os_sms_callback_t lib_callback, void *context);
 
void lwm2m_os_sms_client_deregister(int handle);
 
int lwm2m_os_download_get(const char *host, const struct lwm2m_os_download_cfg *cfg, size_t from);
 
int lwm2m_os_download_disconnect(void);
 
int lwm2m_os_download_init(lwm2m_os_download_callback_t lib_callback);
 
int lwm2m_os_download_file_size_get(size_t *size);
 
size_t lwm2m_os_lte_modes_get(int32_t *modes);
 
void lwm2m_os_lte_mode_request(int32_t prefer);
 
int lwm2m_os_nrf_errno(void);
 
#define LWM2M_OS_DFU_IMG_TYPE_NONE             0
#define LWM2M_OS_DFU_IMG_TYPE_APPLICATION      1
#define LWM2M_OS_DFU_IMG_TYPE_MODEM_DELTA      2
#define LWM2M_OS_DFU_IMG_TYPE_APPLICATION_FILE 3
struct __attribute__((__packed__)) lwm2m_os_dfu_header {
        /* Number of the image file in the sequence. */
        uint8_t number;
        /* Flag indicating if the image file is the last in the sequence. */
        uint8_t is_last;
        /* Offset within the whole image in bytes. */
        uint32_t offset;
        /* Null-terminated image version. */
        char version[32];
};
 
#define LWM2M_OS_DFU_HEADER_MAGIC     0x424ad2dc
#define LWM2M_OS_DFU_HEADER_MAGIC_LEN sizeof(uint32_t)
#define LWM2M_OS_DFU_HEADER_LEN (LWM2M_OS_DFU_HEADER_MAGIC_LEN + sizeof(struct lwm2m_os_dfu_header))
 
int lwm2m_os_dfu_img_type(const void *const buf, size_t len, struct lwm2m_os_dfu_header **header);
 
int lwm2m_os_dfu_start(int img_type, size_t max_file_size, bool crc_validate);
 
int lwm2m_os_dfu_fragment(const char *buf, size_t len, uint32_t crc32);
 
int lwm2m_os_dfu_done(bool successful, uint32_t crc32);
 
int lwm2m_os_dfu_pause(void);
 
int lwm2m_os_dfu_schedule_update(void);
 
void lwm2m_os_dfu_reset(void);
 
bool lwm2m_os_dfu_application_update_validate(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LWM2M_OS_H__ */