hl7800.h

Go to the documentation of this file.

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_MODEM_HL7800_H_
#define ZEPHYR_INCLUDE_DRIVERS_MODEM_HL7800_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <zephyr/types.h>
 
#include <time.h>

 
/* The size includes the NUL character, the strlen doesn't */
#define MDM_HL7800_REVISION_MAX_SIZE 29
#define MDM_HL7800_REVISION_MAX_STRLEN (MDM_HL7800_REVISION_MAX_SIZE - 1)

#define MDM_HL7800_IMEI_SIZE 16
#define MDM_HL7800_IMEI_STRLEN (MDM_HL7800_IMEI_SIZE - 1)

#define MDM_HL7800_ICCID_MAX_SIZE 21
#define MDM_HL7800_ICCID_MAX_STRLEN (MDM_HL7800_ICCID_MAX_SIZE - 1)

#define MDM_HL7800_SERIAL_NUMBER_SIZE 15
#define MDM_HL7800_SERIAL_NUMBER_STRLEN (MDM_HL7800_SERIAL_NUMBER_SIZE - 1)

#define MDM_HL7800_APN_MAX_SIZE 64
#define MDM_HL7800_APN_USERNAME_MAX_SIZE 65
#define MDM_HL7800_APN_PASSWORD_MAX_SIZE 65

#define MDM_HL7800_APN_MAX_STRLEN (MDM_HL7800_APN_MAX_SIZE - 1)
#define MDM_HL7800_APN_USERNAME_MAX_STRLEN                                     \
        (MDM_HL7800_APN_USERNAME_MAX_SIZE - 1)

#define MDM_HL7800_APN_PASSWORD_MAX_STRLEN                                     \
        (MDM_HL7800_APN_PASSWORD_MAX_SIZE - 1)

#define MDM_HL7800_APN_CMD_MAX_SIZE                                            \
        (32 + MDM_HL7800_APN_USERNAME_MAX_STRLEN +                             \
         MDM_HL7800_APN_PASSWORD_MAX_STRLEN)
 
#define MDM_HL7800_APN_CMD_MAX_STRLEN (MDM_HL7800_APN_CMD_MAX_SIZE - 1)

struct mdm_hl7800_apn {
        char value[MDM_HL7800_APN_MAX_SIZE];               
        char username[MDM_HL7800_APN_USERNAME_MAX_SIZE];   
        char password[MDM_HL7800_APN_PASSWORD_MAX_SIZE];   
};

#define MDM_HL7800_LTE_BAND_STR_SIZE 21
#define MDM_HL7800_LTE_BAND_STRLEN (MDM_HL7800_LTE_BAND_STR_SIZE - 1)

#define MDM_HL7800_OPERATOR_INDEX_SIZE 3
#define MDM_HL7800_OPERATOR_INDEX_STRLEN (MDM_HL7800_OPERATOR_INDEX_SIZE - 1)

#define MDM_HL7800_IMSI_MIN_STR_SIZE 15
#define MDM_HL7800_IMSI_MAX_STR_SIZE 16
#define MDM_HL7800_IMSI_MAX_STRLEN (MDM_HL7800_IMSI_MAX_STR_SIZE - 1)

#define MDM_HL7800_MODEM_FUNCTIONALITY_SIZE 2
#define MDM_HL7800_MODEM_FUNCTIONALITY_STRLEN                                  \
        (MDM_HL7800_MODEM_FUNCTIONALITY_SIZE - 1)

#define MDM_HL7800_MAX_GPS_STR_SIZE 33

#define MDM_HL7800_MAX_POLTE_USER_ID_SIZE 16
#define MDM_HL7800_MAX_POLTE_PASSWORD_SIZE 16
#define MDM_HL7800_MAX_POLTE_LOCATION_STR_SIZE 33

#define MDM_HL7800_POLTE_SERVER_ERROR 10

#define MDM_HL7800_SET_POLTE_USER_AND_PASSWORD_FMT_STR "AT%%POLTECMD=\"SERVERAUTH\",\"%s\",\"%s\""

struct mdm_hl7800_site_survey {
        uint32_t earfcn; 
        uint32_t cell_id; 
        int rsrp; 
        int rsrq; 
};

enum mdm_hl7800_radio_mode {
        MDM_RAT_CAT_M1 = 0, 
        MDM_RAT_CAT_NB1     
};

enum mdm_hl7800_event {
        HL7800_EVENT_RESERVED = 0,
        HL7800_EVENT_NETWORK_STATE_CHANGE,
        HL7800_EVENT_APN_UPDATE,
        HL7800_EVENT_RSSI,
        HL7800_EVENT_SINR,
        HL7800_EVENT_STARTUP_STATE_CHANGE,
        HL7800_EVENT_SLEEP_STATE_CHANGE,
        HL7800_EVENT_RAT,
        HL7800_EVENT_BANDS,
        HL7800_EVENT_ACTIVE_BANDS,
        HL7800_EVENT_FOTA_STATE,
        HL7800_EVENT_FOTA_COUNT,
        HL7800_EVENT_REVISION,
        HL7800_EVENT_GPS,
        HL7800_EVENT_GPS_POSITION_STATUS,
        HL7800_EVENT_POLTE_REGISTRATION,
        HL7800_EVENT_POLTE_LOCATE_STATUS,
        HL7800_EVENT_POLTE,
        HL7800_EVENT_SITE_SURVEY,
        HL7800_EVENT_STATE,
};

enum mdm_hl7800_state {
        HL7800_STATE_NOT_READY = 0, 
        HL7800_STATE_INITIALIZED,   
};

enum mdm_hl7800_startup_state {
        HL7800_STARTUP_STATE_READY = 0,                
        HL7800_STARTUP_STATE_WAITING_FOR_ACCESS_CODE,  
        HL7800_STARTUP_STATE_SIM_NOT_PRESENT,          
        HL7800_STARTUP_STATE_SIMLOCK,                  
        HL7800_STARTUP_STATE_UNRECOVERABLE_ERROR,      
        HL7800_STARTUP_STATE_UNKNOWN,                  
        HL7800_STARTUP_STATE_INACTIVE_SIM              
};

enum mdm_hl7800_network_state {
        HL7800_NOT_REGISTERED = 0,   
        HL7800_HOME_NETWORK,         
        HL7800_SEARCHING,            
        HL7800_REGISTRATION_DENIED,  
        HL7800_OUT_OF_COVERAGE,      
        HL7800_ROAMING,              
        HL7800_EMERGENCY = 8,        
        /* Laird defined states */
        HL7800_UNABLE_TO_CONFIGURE = 0xf0 
};

enum mdm_hl7800_sleep {
        HL7800_SLEEP_UNINITIALIZED = 0, 
        HL7800_SLEEP_HIBERNATE,         
        HL7800_SLEEP_AWAKE,             
        HL7800_SLEEP_LITE_HIBERNATE,    
        HL7800_SLEEP_SLEEP,             
};

enum mdm_hl7800_fota_state {
        HL7800_FOTA_IDLE,                   
        HL7800_FOTA_START,                  
        HL7800_FOTA_WIP,                    
        HL7800_FOTA_PAD,                    
        HL7800_FOTA_SEND_EOT,               
        HL7800_FOTA_FILE_ERROR,             
        HL7800_FOTA_INSTALL,                
        HL7800_FOTA_REBOOT_AND_RECONFIGURE, 
        HL7800_FOTA_COMPLETE,               
};

enum mdm_hl7800_functionality {
        HL7800_FUNCTIONALITY_MINIMUM = 0, 
        HL7800_FUNCTIONALITY_FULL = 1,    
        HL7800_FUNCTIONALITY_AIRPLANE = 4 
};

struct mdm_hl7800_compound_event {
        uint8_t code; 
        char *string; 
};

enum mdm_hl7800_gnss_event {
        HL7800_GNSS_EVENT_INVALID = -1, 
        HL7800_GNSS_EVENT_INIT,         
        HL7800_GNSS_EVENT_START,        
        HL7800_GNSS_EVENT_STOP,         
        HL7800_GNSS_EVENT_POSITION,     
};

enum mdm_hl7800_gnss_status {
        HL7800_GNSS_STATUS_INVALID = -1, 
        HL7800_GNSS_STATUS_FAILURE,      
        HL7800_GNSS_STATUS_SUCCESS,      
};

enum mdm_hl7800_gnss_position_event {
        HL7800_GNSS_POSITION_EVENT_INVALID = -1,              
        HL7800_GNSS_POSITION_EVENT_LOST_OR_NOT_AVAILABLE_YET, 
        HL7800_GNSS_POSITION_EVENT_PREDICTION_AVAILABLE,      
        HL7800_GNSS_POSITION_EVENT_2D_AVAILABLE,              
        HL7800_GNSS_POSITION_EVENT_3D_AVAILABLE,              
        HL7800_GNSS_POSITION_EVENT_FIXED_TO_INVALID,          
};

enum mdm_hl7800_gps_string_types {
        HL7800_GPS_STR_LATITUDE,  
        HL7800_GPS_STR_LONGITUDE, 
        HL7800_GPS_STR_GPS_TIME,  
        HL7800_GPS_STR_FIX_TYPE,  
        HL7800_GPS_STR_HEPE,      
        HL7800_GPS_STR_ALTITUDE,  
        HL7800_GPS_STR_ALT_UNC,   
        HL7800_GPS_STR_DIRECTION, 
        HL7800_GPS_STR_HOR_SPEED, 
        HL7800_GPS_STR_VER_SPEED  
};

struct mdm_hl7800_polte_registration_event_data {
        int status;     
        char *user;     
        char *password; 
};

struct mdm_hl7800_polte_location_data {
        uint32_t timestamp;
        int status;
        char latitude[MDM_HL7800_MAX_POLTE_LOCATION_STR_SIZE];
        char longitude[MDM_HL7800_MAX_POLTE_LOCATION_STR_SIZE];
        char confidence_in_meters[MDM_HL7800_MAX_POLTE_LOCATION_STR_SIZE];
};

typedef void (*mdm_hl7800_event_callback_t)(enum mdm_hl7800_event event,
                                            void *event_data);

struct mdm_hl7800_callback_agent {
        sys_snode_t node;
        mdm_hl7800_event_callback_t event_callback;
};

int32_t mdm_hl7800_power_off(void);

int32_t mdm_hl7800_reset(void);

void mdm_hl7800_wakeup(bool awake);

int32_t mdm_hl7800_send_at_cmd(const uint8_t *data, uint8_t resp_timeout, char *resp,
                               uint16_t *resp_len);

void mdm_hl7800_get_signal_quality(int *rsrp, int *sinr);

char *mdm_hl7800_get_iccid(void);

char *mdm_hl7800_get_sn(void);

char *mdm_hl7800_get_imei(void);

char *mdm_hl7800_get_fw_version(void);

char *mdm_hl7800_get_imsi(void);

int32_t mdm_hl7800_update_apn(char *access_point_name);

int32_t mdm_hl7800_update_rat(enum mdm_hl7800_radio_mode value);

bool mdm_hl7800_valid_rat(uint8_t value);

int mdm_hl7800_register_event_callback(struct mdm_hl7800_callback_agent *agent);

int mdm_hl7800_unregister_event_callback(struct mdm_hl7800_callback_agent *agent);

void mdm_hl7800_generate_status_events(void);

int32_t mdm_hl7800_get_local_time(struct tm *tm, int32_t *offset);
 
#if defined(CONFIG_MODEM_HL7800_FW_UPDATE) || defined(__DOXYGEN__)
int32_t mdm_hl7800_update_fw(char *file_path);
#endif

int32_t mdm_hl7800_get_operator_index(void);

int32_t mdm_hl7800_get_functionality(void);

int32_t mdm_hl7800_set_functionality(enum mdm_hl7800_functionality mode);

int32_t mdm_hl7800_set_gps_rate(uint32_t rate);

int32_t mdm_hl7800_polte_register(void);

int32_t mdm_hl7800_polte_enable(char *user, char *password);

int32_t mdm_hl7800_polte_locate(void);

int32_t mdm_hl7800_perform_site_survey(void);

int mdm_hl7800_set_desired_sleep_level(enum mdm_hl7800_sleep level);

void mdm_hl7800_register_wake_test_point_callback(void (*func)(int state));

void mdm_hl7800_register_gpio6_callback(void (*func)(int state));

void mdm_hl7800_register_cts_callback(void (*func)(int state));

int32_t mdm_hl7800_set_bands(const char *bands);

uint32_t mdm_hl7800_log_filter_set(uint32_t level);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_MODEM_HL7800_H_ */