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
 
/* Assign the server error code (location response) to a value
 * that isn't used by locate response so that a single status
 * callback can be used.
 */
#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; /* EUTRA Absolute Radio Frequency Channel Number */
        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,
};
 
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
};
 
/* The modem reports state values as an enumeration and a string.
 * GPS values are reported with a type of value and string.
 */
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
};
 
/* status: negative errno, 0 on success
 * user and password aren't valid if status is non-zero.
 */
struct mdm_hl7800_polte_registration_event_data {
        int status;
        char *user;
        char *password;
};
 
/* status: negative errno, 0 on success, non-zero error code
 * Data is not valid if status is non-zero.
 */
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);
 
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);
 
#ifdef CONFIG_MODEM_HL7800_FW_UPDATE
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_ */