modem_cellular.c

/*
 * Copyright (c) 2023 Bjarki Arge Andreasen
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/cellular.h>
#include <zephyr/drivers/modem/modem_cellular.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/modem/chat.h>
#include <zephyr/modem/cmux.h>
#include <zephyr/modem/pipe.h>
#include <zephyr/modem/pipelink.h>
#include <zephyr/modem/ppp.h>
#include <zephyr/modem/backend/uart.h>
#include <zephyr/net/ppp.h>
#include <zephyr/pm/device.h>
#include <zephyr/pm/device_runtime.h>
#include <zephyr/sys/atomic.h>

#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(modem_cellular, CONFIG_MODEM_LOG_LEVEL);

#include <string.h>
#include <stdlib.h>

#define MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT \
	K_MSEC(CONFIG_MODEM_CELLULAR_PERIODIC_SCRIPT_MS)

/* Magic constants */
#define MODEM_CELLULAR_MAX_SCRIPT_FAILURES   (3)
#define CSQ_RSSI_UNKNOWN		     (99)
#define CESQ_RSRP_UNKNOWN		     (255)
#define CESQ_RSRQ_UNKNOWN		     (255)

/* Magic numbers to units conversions */
#define CSQ_RSSI_TO_DB(v) (-113 + (2 * (v)))
#define CESQ_RSRP_TO_DB(v) (-140 + (v))
#define CESQ_RSRQ_TO_DB(v) (-20 + ((v) / 2))

#ifdef CONFIG_MODEM_CELLULAR_APN
BUILD_ASSERT(sizeof(CONFIG_MODEM_CELLULAR_APN) - 1 < MODEM_CELLULAR_DATA_APN_LEN,
			"CONFIG_MODEM_CELLULAR_APN too long for data->apn");
#endif

static void modem_cellular_enter_state(struct modem_cellular_data *data,
				       enum modem_cellular_state state);

static void modem_cellular_delegate_event(struct modem_cellular_data *data,
					  enum modem_cellular_event evt);

static void modem_cellular_event_handler(struct modem_cellular_data *data,
					 enum modem_cellular_event evt);

static const char *modem_cellular_state_str(enum modem_cellular_state state)
{
	switch (state) {
	case MODEM_CELLULAR_STATE_IDLE:
		return "idle";
	case MODEM_CELLULAR_STATE_RESET_PULSE:
		return "reset pulse";
	case MODEM_CELLULAR_STATE_AWAIT_RESET:
		return "await reset";
	case MODEM_CELLULAR_STATE_POWER_ON_PULSE:
		return "power pulse";
	case MODEM_CELLULAR_STATE_AWAIT_POWER_ON:
		return "await power on";
	case MODEM_CELLULAR_STATE_SET_BAUDRATE:
		return "set baudrate";
	case MODEM_CELLULAR_STATE_RUN_INIT_SCRIPT:
		return "run init script";
	case MODEM_CELLULAR_STATE_CONNECT_CMUX:
		return "connect cmux";
	case MODEM_CELLULAR_STATE_OPEN_DLCI1:
		return "open dlci1";
	case MODEM_CELLULAR_STATE_OPEN_DLCI2:
		return "open dlci2";
	case MODEM_CELLULAR_STATE_WAIT_FOR_APN:
		return "wait for apn";
	case MODEM_CELLULAR_STATE_AWAIT_REGISTERED:
		return "await registered";
	case MODEM_CELLULAR_STATE_RUN_APN_SCRIPT:
		return "run apn script";
	case MODEM_CELLULAR_STATE_RUN_NETWORK_SCRIPT:
		return "run network script";
	case MODEM_CELLULAR_STATE_RUN_DIAL_SCRIPT:
		return "run dial script";
	case MODEM_CELLULAR_STATE_REGISTERED:
		return "registered";
	case MODEM_CELLULAR_STATE_AWAIT_PPP_DEAD:
		return "await PPP dead";
	case MODEM_CELLULAR_STATE_INIT_POWER_OFF:
		return "init power off";
	case MODEM_CELLULAR_STATE_RUN_SHUTDOWN_SCRIPT:
		return "run shutdown script";
	case MODEM_CELLULAR_STATE_POWER_OFF_PULSE:
		return "power off pulse";
	case MODEM_CELLULAR_STATE_AWAIT_POWER_OFF:
		return "await power off";
	}

	return "";
}

static const char *modem_cellular_event_str(enum modem_cellular_event event)
{
	switch (event) {
	case MODEM_CELLULAR_EVENT_RESUME:
		return "resume";
	case MODEM_CELLULAR_EVENT_SUSPEND:
		return "suspend";
	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		return "script success";
	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		return "script failed";
	case MODEM_CELLULAR_EVENT_CMUX_CONNECTED:
		return "cmux connected";
	case MODEM_CELLULAR_EVENT_CMUX_DISCONNECTED:
		return "cmux disconnected";
	case MODEM_CELLULAR_EVENT_DLCI1_OPENED:
		return "dlci1 opened";
	case MODEM_CELLULAR_EVENT_DLCI2_OPENED:
		return "dlci2 opened";
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		return "timeout";
	case MODEM_CELLULAR_EVENT_REGISTERED:
		return "registered";
	case MODEM_CELLULAR_EVENT_DEREGISTERED:
		return "deregistered";
	case MODEM_CELLULAR_EVENT_BUS_OPENED:
		return "bus opened";
	case MODEM_CELLULAR_EVENT_BUS_CLOSED:
		return "bus closed";
	case MODEM_CELLULAR_EVENT_PPP_DEAD:
		return "ppp dead";
	case MODEM_CELLULAR_EVENT_MODEM_READY:
		return "modem ready";
	case MODEM_CELLULAR_EVENT_APN_SET:
		return "apn set";
	case MODEM_CELLULAR_EVENT_RING:
		return "RING";
	}

	return "";
}

static bool modem_cellular_apn_change_allowed(enum modem_cellular_state st)
{
	switch (st) {
	case MODEM_CELLULAR_STATE_IDLE:
	case MODEM_CELLULAR_STATE_RESET_PULSE:
	case MODEM_CELLULAR_STATE_AWAIT_RESET:
	case MODEM_CELLULAR_STATE_POWER_ON_PULSE:
	case MODEM_CELLULAR_STATE_AWAIT_POWER_ON:
	case MODEM_CELLULAR_STATE_SET_BAUDRATE:
	case MODEM_CELLULAR_STATE_RUN_INIT_SCRIPT:
	case MODEM_CELLULAR_STATE_CONNECT_CMUX:
	case MODEM_CELLULAR_STATE_OPEN_DLCI1:
	case MODEM_CELLULAR_STATE_OPEN_DLCI2:
	case MODEM_CELLULAR_STATE_WAIT_FOR_APN:
		return true;
	default:
		return false;
	}
}

static bool modem_cellular_has_network_script(const struct modem_cellular_config *config)
{
	return config->scripts->network != NULL;
}

static void modem_cellular_emit_event(struct modem_cellular_data *data,
				      enum cellular_event evt, const void *payload)
{
	if ((data->cb.fn != NULL) && (data->cb.mask & evt)) {
		data->cb.fn(data->dev, evt, payload, data->cb.user_data);
	}
}

static void modem_cellular_emit_modem_info(struct modem_cellular_data *data,
					   enum cellular_modem_info_type field)
{
	struct cellular_evt_modem_info evt = {
		.field = field,
	};

	modem_cellular_emit_event(data, CELLULAR_EVENT_MODEM_INFO_CHANGED, &evt);
}

static void modem_cellular_emit_reg_state(struct modem_cellular_data *data,
					   enum cellular_registration_status status)
{
	struct cellular_evt_registration_status evt = {
		.status = status,
	};

	modem_cellular_emit_event(data, CELLULAR_EVENT_REGISTRATION_STATUS_CHANGED, &evt);
}

static bool modem_cellular_gpio_is_enabled(const struct gpio_dt_spec *gpio)
{
	return gpio->port != NULL;
}

static bool modem_cellular_needs_apn(const struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	if (config->use_default_apn) {
		return false;
	}
	return data->apn[0] == '\0';
}

static void modem_cellular_enter_state_network_or_dial(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	if (modem_cellular_has_network_script(config)) {
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_NETWORK_SCRIPT);
	} else {
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_DIAL_SCRIPT);
	}
}

static void modem_cellular_notify_user_pipes_connected(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;
	struct modem_cellular_user_pipe *user_pipe;
	struct modem_pipelink *pipelink;

	for (uint8_t i = 0; i < config->user_pipes_size; i++) {
		user_pipe = &config->user_pipes[i];
		pipelink = user_pipe->pipelink;
		modem_pipelink_notify_connected(pipelink);
	}
}

static void modem_cellular_notify_user_pipes_disconnected(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;
	struct modem_cellular_user_pipe *user_pipe;
	struct modem_pipelink *pipelink;

	for (uint8_t i = 0; i < config->user_pipes_size; i++) {
		user_pipe = &config->user_pipes[i];
		pipelink = user_pipe->pipelink;
		modem_pipelink_notify_disconnected(pipelink);
	}
}

static void modem_cellular_bus_pipe_handler(struct modem_pipe *pipe,
					    enum modem_pipe_event event,
					    void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	switch (event) {
	case MODEM_PIPE_EVENT_OPENED:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_BUS_OPENED);
		break;

	case MODEM_PIPE_EVENT_CLOSED:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_BUS_CLOSED);
		break;

	default:
		break;
	}
}

static void modem_cellular_dlci1_pipe_handler(struct modem_pipe *pipe,
					      enum modem_pipe_event event,
					      void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	switch (event) {
	case MODEM_PIPE_EVENT_OPENED:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_DLCI1_OPENED);
		break;

	default:
		break;
	}
}

static void modem_cellular_dlci2_pipe_handler(struct modem_pipe *pipe,
					      enum modem_pipe_event event,
					      void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	switch (event) {
	case MODEM_PIPE_EVENT_OPENED:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_DLCI2_OPENED);
		break;

	default:
		break;
	}
}

void modem_cellular_chat_callback_handler(struct modem_chat *chat,
					  enum modem_chat_script_result result,
					  void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (result == MODEM_CHAT_SCRIPT_RESULT_SUCCESS) {
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS);
	} else {
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_SCRIPT_FAILED);
	}
}

void modem_cellular_chat_on_modem_ready(struct modem_chat *chat, char **argv, uint16_t argc,
					void *user_data)
{
	struct modem_cellular_data *data = user_data;

	modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_MODEM_READY);
}


void modem_cellular_chat_on_imei(struct modem_chat *chat, char **argv, uint16_t argc,
				 void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 2) {
		return;
	}

	strncpy(data->imei, argv[1], sizeof(data->imei) - 1);
	modem_cellular_emit_modem_info(data, CELLULAR_MODEM_INFO_IMEI);
}

void modem_cellular_chat_on_cgmm(struct modem_chat *chat, char **argv, uint16_t argc,
				 void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 2) {
		return;
	}

	strncpy(data->model_id, argv[1], sizeof(data->model_id) - 1);
	modem_cellular_emit_modem_info(data, CELLULAR_MODEM_INFO_MODEL_ID);
}

void modem_cellular_chat_on_cgmi(struct modem_chat *chat, char **argv, uint16_t argc,
				 void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 2) {
		return;
	}

	strncpy(data->manufacturer, argv[1], sizeof(data->manufacturer) - 1);
	modem_cellular_emit_modem_info(data, CELLULAR_MODEM_INFO_MANUFACTURER);
}

void modem_cellular_chat_on_cgmr(struct modem_chat *chat, char **argv, uint16_t argc,
				 void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 2) {
		return;
	}

	strncpy(data->fw_version, argv[1], sizeof(data->fw_version) - 1);
	modem_cellular_emit_modem_info(data, CELLULAR_MODEM_INFO_FW_VERSION);
}

void modem_cellular_chat_on_csq(struct modem_chat *chat, char **argv, uint16_t argc,
				void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 3) {
		return;
	}

	data->rssi = (uint8_t)atoi(argv[1]);
}

void modem_cellular_chat_on_cesq(struct modem_chat *chat, char **argv, uint16_t argc,
				 void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 7) {
		return;
	}

	data->rsrq = (uint8_t)atoi(argv[5]);
	data->rsrp = (uint8_t)atoi(argv[6]);
}

void modem_cellular_chat_on_iccid(struct modem_chat *chat, char **argv, uint16_t argc,
				  void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 2) {
		return;
	}

	strncpy(data->iccid, argv[1], sizeof(data->iccid) - 1);
	modem_cellular_emit_modem_info(data, CELLULAR_MODEM_INFO_SIM_ICCID);
}

void modem_cellular_chat_on_imsi(struct modem_chat *chat, char **argv, uint16_t argc,
				 void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	if (argc != 2) {
		return;
	}

	strncpy(data->imsi, argv[1], sizeof(data->imsi) - 1);
	modem_cellular_emit_modem_info(data, CELLULAR_MODEM_INFO_SIM_IMSI);
}

static bool modem_cellular_is_registered(struct modem_cellular_data *data)
{
	return (data->registration_status_gsm == CELLULAR_REGISTRATION_REGISTERED_HOME)
		|| (data->registration_status_gsm == CELLULAR_REGISTRATION_REGISTERED_ROAMING)
		|| (data->registration_status_gprs == CELLULAR_REGISTRATION_REGISTERED_HOME)
		|| (data->registration_status_gprs == CELLULAR_REGISTRATION_REGISTERED_ROAMING)
		|| (data->registration_status_lte == CELLULAR_REGISTRATION_REGISTERED_HOME)
		|| (data->registration_status_lte == CELLULAR_REGISTRATION_REGISTERED_ROAMING);
}

static void modem_cellular_clear_registration_status(struct modem_cellular_data *data)
{
	data->registration_status_gsm = CELLULAR_REGISTRATION_NOT_REGISTERED;
	data->registration_status_gprs = CELLULAR_REGISTRATION_NOT_REGISTERED;
	data->registration_status_lte = CELLULAR_REGISTRATION_NOT_REGISTERED;
}

void modem_cellular_chat_on_cxreg(struct modem_chat *chat, char **argv, uint16_t argc,
				  void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;
	enum cellular_registration_status registration_status = 0;

	/* This receives both +C*REG? read command answers and unsolicited notifications.
	 * Their syntax differs in that the former has one more parameter, <n>, which is first.
	 */
	if (argc >= 3 && argv[2][0] != '"') {
		/* +CEREG: <n>,<stat>[,<tac>[...]] */
		registration_status = atoi(argv[2]);
	} else if (argc >= 2) {
		/* +CEREG: <stat>[,<tac>[...]] */
		registration_status = atoi(argv[1]);
	} else {
		return;
	}

	if (strcmp(argv[0], "+CREG: ") == 0) {
		data->registration_status_gsm = registration_status;
	} else if (strcmp(argv[0], "+CGREG: ") == 0) {
		data->registration_status_gprs = registration_status;
	} else { /* CEREG */
		data->registration_status_lte = registration_status;
	}

	if (modem_cellular_is_registered(data)) {
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_REGISTERED);
	} else {
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_DEREGISTERED);
	}
	modem_cellular_emit_reg_state(data, registration_status);
}

void modem_cellular_chat_on_cgev(struct modem_chat *chat, char **argv, uint16_t argc,
				 void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;
	bool connected;

	if (strcmp(argv[0], "+CGEV: ") != 0) {
		return;
	}
	/* See 3GPP TS 27.007 for +CGEV syntax
	 *
	 * Any of the following means PDN connected:
	 * +CGEV: NW PDN ACT <cid>
	 * +CGEV: ME PDN ACT <cid>[,<reason>[,<cid_other>]]
	 * +CGEV: NW ACT <p_cid>, <cid>, <event_type>
	 * +CGEV: ME ACT <p_cid>, <cid>, <event_type>
	 *
	 * Any of the following means PDN disconnected:
	 * +CGEV: NW DETACH
	 * +CGEV: ME DETACH
	 * +CGEV: NW DEACT <PDP_type>, <PDP_addr>, [<cid>]
	 * +CGEV: ME DEACT <PDP_type>, <PDP_addr>, [<cid>]
	 * +CGEV: NW PDN DEACT <cid>
	 * +CGEV: ME PDN DEACT <cid>
	 * +CGEV: NW DEACT <p_cid>, <cid>, <event_type>
	 * +CGEV: ME DEACT <p_cid>, <cid>, <event_type>
	 */

	if (strstr(argv[0], " ACT")) {
		connected = true;
	} else if ((strstr(argv[0], "DETACH")) ||
		   (strstr(argv[0], "DEACT"))) {
		connected = false;
	} else {
		return;
	}

	/* Only notify the event if the registration status does not
	 * match what our state machine expects.
	 * For example, we might stay registered while losing the PDN connection, and it
	 * might be resumed later without deregistering first.
	 */
	if (modem_cellular_is_registered(data)) {
		if (!connected) {
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_DEREGISTERED);
		}
	} else {
		if (connected) {
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_REGISTERED);
		}
	}
}

MODEM_CHAT_MATCH_DEFINE(ok_match, "OK", "", NULL);
MODEM_CHAT_MATCHES_DEFINE(__maybe_unused allow_match,
			  MODEM_CHAT_MATCH("OK", "", NULL),
			  MODEM_CHAT_MATCH("ERROR", "", NULL));

MODEM_CHAT_MATCH_DEFINE(imei_match __maybe_unused, "", "", modem_cellular_chat_on_imei);
MODEM_CHAT_MATCH_DEFINE(cgmm_match __maybe_unused, "", "", modem_cellular_chat_on_cgmm);
MODEM_CHAT_MATCH_DEFINE(csq_match __maybe_unused, "+CSQ: ", ",", modem_cellular_chat_on_csq);
MODEM_CHAT_MATCH_DEFINE(cesq_match __maybe_unused, "+CESQ: ", ",", modem_cellular_chat_on_cesq);
MODEM_CHAT_MATCH_DEFINE(qccid_match __maybe_unused, "+QCCID: ", "", modem_cellular_chat_on_iccid);
MODEM_CHAT_MATCH_DEFINE(iccid_match __maybe_unused, "+ICCID: ", "", modem_cellular_chat_on_iccid);
MODEM_CHAT_MATCH_DEFINE(ccid_match __maybe_unused, "+CCID: ", "", modem_cellular_chat_on_iccid);
MODEM_CHAT_MATCH_DEFINE(cimi_match __maybe_unused, "", "", modem_cellular_chat_on_imsi);
MODEM_CHAT_MATCH_DEFINE(cgmi_match __maybe_unused, "", "", modem_cellular_chat_on_cgmi);
MODEM_CHAT_MATCH_DEFINE(cgmr_match __maybe_unused, "", "", modem_cellular_chat_on_cgmr);

MODEM_CHAT_MATCHES_DEFINE(abort_matches, MODEM_CHAT_MATCH("ERROR", "", NULL));

MODEM_CHAT_MATCHES_DEFINE(__maybe_unused dial_abort_matches,
			  MODEM_CHAT_MATCH("ERROR", "", NULL),
			  MODEM_CHAT_MATCH("BUSY", "", NULL),
			  MODEM_CHAT_MATCH("NO ANSWER", "", NULL),
			  MODEM_CHAT_MATCH("NO CARRIER", "", NULL),
			  MODEM_CHAT_MATCH("NO DIALTONE", "", NULL));

static int append_apn_cmd(struct modem_cellular_data *data, uint8_t *steps, const char *fmt,
			  const char *apn_value)
{
	int n;

	if (*steps >= MODEM_CELLULAR_MAX_APN_CMDS) {
		return -ENOMEM;
	}

	n = snprintk(data->apn_buf[*steps], MODEM_CELLULAR_APN_BUF_SIZE, fmt, apn_value);

	if (n < 0 || n >= MODEM_CELLULAR_APN_BUF_SIZE) {
		return -ENOMEM;
	}

	/* Fill the matching chat entry */
	modem_chat_script_chat_init(&data->apn_chats[*steps]);
	modem_chat_script_chat_set_request(&data->apn_chats[*steps], data->apn_buf[*steps]);
	modem_chat_script_chat_set_response_matches(&data->apn_chats[*steps], &ok_match, 1);

	(*steps)++;
	return 0;
}

static void modem_cellular_build_apn_script(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;
	uint8_t steps = 0;
	const char *apn_value = data->apn;

	if (config->use_default_apn) {
		/* Omit the APN name AT+CGDCONT=1,"IP","" */
		apn_value = "";
	}
	append_apn_cmd(data, &steps, "AT+CGDCONT=1,\"IP\",\"%s\"", apn_value);

	/* Vendor‑specific extras */
#if DT_HAS_COMPAT_STATUS_OKAY(swir_hl7800)
	append_apn_cmd(data, &steps, "AT+KCNXCFG=1,\"GPRS\",\"%s\",,,\"IPV4\"", apn_value);
#endif

	/* Glue the array into the script object */
	modem_chat_script_set_script_chats(&data->apn_script, data->apn_chats, steps);
}

static void modem_cellular_log_state_changed(enum modem_cellular_state last_state,
					     enum modem_cellular_state new_state)
{
	LOG_DBG("switch from %s to %s", modem_cellular_state_str(last_state),
		modem_cellular_state_str(new_state));
}

static void modem_cellular_log_event(enum modem_cellular_event evt)
{
	LOG_DBG("event %s", modem_cellular_event_str(evt));
}

static void modem_cellular_start_timer(struct modem_cellular_data *data, k_timeout_t timeout)
{
	k_work_schedule(&data->timeout_work, timeout);
}

static void modem_cellular_stop_timer(struct modem_cellular_data *data)
{
	k_work_cancel_delayable(&data->timeout_work);
}

static void modem_cellular_timeout_handler(struct k_work *item)
{
	struct k_work_delayable *dwork = k_work_delayable_from_work(item);
	struct modem_cellular_data *data =
		CONTAINER_OF(dwork, struct modem_cellular_data, timeout_work);

	modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_TIMEOUT);
}

static void modem_cellular_event_dispatch_handler(struct k_work *item)
{
	struct modem_cellular_data *data =
		CONTAINER_OF(item, struct modem_cellular_data, event_dispatch_work);

	enum modem_cellular_event event;
	const size_t len = sizeof(event);

	while (k_pipe_read(&data->event_pipe, (uint8_t *)&event, len, K_NO_WAIT) == len) {
		modem_cellular_event_handler(data, (enum modem_cellular_event)event);
	}
}

static void modem_cellular_delegate_event(struct modem_cellular_data *data,
					  enum modem_cellular_event evt)
{
	k_pipe_write(&data->event_pipe, (const uint8_t *)&evt, sizeof(evt), K_NO_WAIT);
	k_work_submit(&data->event_dispatch_work);
}

static void modem_cellular_begin_power_off_pulse(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	modem_pipe_close_async(data->uart_pipe);

	if (modem_cellular_gpio_is_enabled(&config->power_gpio)) {
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_POWER_OFF_PULSE);
	} else {
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
	}
}

static int modem_cellular_on_idle_state_enter(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	if (modem_cellular_gpio_is_enabled(&config->wake_gpio)) {
		gpio_pin_set_dt(&config->wake_gpio, 0);
	}

	if (modem_cellular_gpio_is_enabled(&config->reset_gpio) && config->hold_reset_on_suspend) {
		gpio_pin_set_dt(&config->reset_gpio, 1);
	}

	modem_cellular_clear_registration_status(data);
	modem_cellular_notify_user_pipes_disconnected(data);
	modem_chat_release(&data->chat);
	modem_ppp_release(data->ppp);
	modem_cmux_release(&data->cmux);
	modem_pipe_close_async(data->uart_pipe);
	k_sem_give(&data->suspended_sem);
	return 0;
}

static void modem_cellular_idle_event_handler(struct modem_cellular_data *data,
					      enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_RESUME:
		if (config->autostarts) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_POWER_ON);
			break;
		}

		if (modem_cellular_gpio_is_enabled(&config->reset_gpio) &&
		    config->reset_on_resume) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RESET_PULSE);
			break;
		}

		if (modem_cellular_gpio_is_enabled(&config->power_gpio)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_POWER_ON_PULSE);
			break;
		}

		if (config->scripts->set_baudrate != NULL) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_SET_BAUDRATE);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_INIT_SCRIPT);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		k_sem_give(&data->suspended_sem);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_idle_state_leave(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	k_sem_take(&data->suspended_sem, K_NO_WAIT);

	if (modem_cellular_gpio_is_enabled(&config->reset_gpio) && config->hold_reset_on_suspend) {
		gpio_pin_set_dt(&config->reset_gpio, 0);
	}

	if (modem_cellular_gpio_is_enabled(&config->wake_gpio)) {
		gpio_pin_set_dt(&config->wake_gpio, 1);
	}

	return 0;
}

static uint32_t modem_cellular_baudrate_update(struct modem_cellular_data *data,
						uint32_t desired_baudrate)
{
	const struct modem_cellular_config *config = data->dev->config;
	struct uart_config cfg = {0};
	uint32_t original_baudrate;
	int ret;

	ret = uart_config_get(config->uart, &cfg);
	if (ret < 0) {
		LOG_ERR("Failed to get UART configuration (%d)", ret);
		return 0;
	}
	original_baudrate = cfg.baudrate;
	cfg.baudrate = desired_baudrate;
	ret = uart_configure(config->uart, &cfg);
	if (ret < 0) {
		LOG_ERR("Failed to set new baudrate (%d)", ret);
		return 0;
	}
	return original_baudrate;
}

static int modem_cellular_on_reset_pulse_state_enter(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	if (modem_cellular_gpio_is_enabled(&config->wake_gpio)) {
		gpio_pin_set_dt(&config->wake_gpio, 0);
	}

	/* Revert to original baudrate if we have changed it */
	if (data->original_baudrate) {
		modem_cellular_baudrate_update(data, data->original_baudrate);
	}

	gpio_pin_set_dt(&config->reset_gpio, 1);
	modem_cellular_start_timer(data, K_MSEC(config->reset_pulse_duration_ms));
	return 0;
}

static void modem_cellular_reset_pulse_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		if (modem_cellular_gpio_is_enabled(&config->power_gpio)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_RESET);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_POWER_ON);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_reset_pulse_state_leave(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	gpio_pin_set_dt(&config->reset_gpio, 0);

	if (modem_cellular_gpio_is_enabled(&config->wake_gpio)) {
		gpio_pin_set_dt(&config->wake_gpio, 1);
	}

	modem_cellular_stop_timer(data);
	return 0;
}

static int modem_cellular_on_await_reset_state_enter(struct modem_cellular_data *data)
{
	modem_cellular_start_timer(data, K_MSEC(CONFIG_MODEM_CELLULAR_RESET_POWER_ON_DELAY_MS));
	return 0;
}

static void modem_cellular_await_reset_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		if (modem_cellular_gpio_is_enabled(&config->power_gpio)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_POWER_ON_PULSE);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_POWER_ON);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_await_reset_state_leave(struct modem_cellular_data *data)
{
	modem_cellular_stop_timer(data);
	return 0;
}

static int modem_cellular_on_power_on_pulse_state_enter(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	gpio_pin_set_dt(&config->power_gpio, 1);
	modem_cellular_start_timer(data, K_MSEC(config->power_pulse_duration_ms));
	return 0;
}

static void modem_cellular_power_on_pulse_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_POWER_ON);
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_power_on_pulse_state_leave(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	gpio_pin_set_dt(&config->power_gpio, 0);
	modem_cellular_stop_timer(data);
	return 0;
}

static int modem_cellular_on_await_power_on_state_enter(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	modem_cellular_start_timer(data, K_MSEC(config->startup_time_ms));
	modem_pipe_attach(data->uart_pipe, modem_cellular_bus_pipe_handler, data);
	return modem_pipe_open_async(data->uart_pipe);
}

static void modem_cellular_await_power_on_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_BUS_OPENED:
		modem_chat_attach(&data->chat, data->uart_pipe);
		break;
	case MODEM_CELLULAR_EVENT_MODEM_READY:
		/* disable the timer and fall through, as we are ready to proceed */
		modem_cellular_stop_timer(data);
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		if (config->scripts->set_baudrate != NULL) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_SET_BAUDRATE);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_INIT_SCRIPT);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_set_baudrate_state_enter(struct modem_cellular_data *data)
{
	modem_pipe_attach(data->uart_pipe, modem_cellular_bus_pipe_handler, data);
	return modem_pipe_open_async(data->uart_pipe);
}

static void modem_cellular_set_baudrate_event_handler(struct modem_cellular_data *data,
						      enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_BUS_OPENED:
		modem_chat_attach(&data->chat, data->uart_pipe);
		modem_chat_run_script_async(&data->chat, config->scripts->set_baudrate);
		break;

	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		/* Some modems save the new speed on first change, meaning the
		 * modem is already at the new baudrate, meaning no reply. So
		 * ignore any failures and continue as if baudrate is already set
		 */
		LOG_DBG("no reply from modem, assuming baudrate is already set");
		__fallthrough;
	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		/* Let modem reconfigure */
		modem_cellular_start_timer(data, K_MSEC(CONFIG_MODEM_CELLULAR_NEW_BAUDRATE_DELAY));
		modem_chat_release(&data->chat);
		modem_pipe_attach(data->uart_pipe, modem_cellular_bus_pipe_handler, data);
		modem_pipe_close_async(data->uart_pipe);
		break;

	case MODEM_CELLULAR_EVENT_BUS_CLOSED:
		/* Update UART port baudrate and preserve the original value */
		data->original_baudrate = modem_cellular_baudrate_update(
			data, CONFIG_MODEM_CELLULAR_NEW_BAUDRATE);
		break;

	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_INIT_SCRIPT);
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_run_init_script_state_enter(struct modem_cellular_data *data)
{
	modem_pipe_attach(data->uart_pipe, modem_cellular_bus_pipe_handler, data);
	return modem_pipe_open_async(data->uart_pipe);
}

static void modem_cellular_run_init_script_event_handler(struct modem_cellular_data *data,
							 enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;
	uint8_t imei_len;
	uint8_t link_addr_len;
	uint8_t *link_addr_ptr;
	int err;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_BUS_OPENED:
		modem_chat_attach(&data->chat, data->uart_pipe);
		modem_chat_run_script_async(&data->chat, config->scripts->init);
		break;

	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		/* Get link_addr_len least significant bytes from IMEI as a link address */
		imei_len = MODEM_CELLULAR_DATA_IMEI_LEN - 1; /* Exclude str end */
		link_addr_len = MIN(NET_LINK_ADDR_MAX_LENGTH, imei_len);
		link_addr_ptr = data->imei + (imei_len - link_addr_len);

		err = net_if_set_link_addr(modem_ppp_get_iface(data->ppp), link_addr_ptr,
					   link_addr_len, NET_LINK_UNKNOWN);
		if (err) {
			LOG_WRN("Failed to set link address on PPP interface (%d)", err);
		}

		modem_chat_release(&data->chat);
		modem_pipe_attach(data->uart_pipe, modem_cellular_bus_pipe_handler, data);
		modem_pipe_close_async(data->uart_pipe);
		break;

	case MODEM_CELLULAR_EVENT_BUS_CLOSED:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_CONNECT_CMUX);
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		if (modem_cellular_gpio_is_enabled(&config->reset_gpio) &&
		    config->reset_on_recovery) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RESET_PULSE);
			break;
		}

		if (modem_cellular_gpio_is_enabled(&config->power_gpio)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_POWER_ON_PULSE);
			break;
		}

		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_connect_cmux_state_enter(struct modem_cellular_data *data)
{
	/*
	 * Allow modem to switch bus into CMUX mode. Some modems disable UART RX while
	 * switching, resulting in UART RX errors as bus is no longer pulled up by modem.
	 */
	modem_cellular_start_timer(data, K_MSEC(100));
	return 0;
}

static void modem_cellular_connect_cmux_event_handler(struct modem_cellular_data *data,
						      enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_pipe_attach(data->uart_pipe, modem_cellular_bus_pipe_handler, data);
		modem_pipe_open_async(data->uart_pipe);
		break;

	case MODEM_CELLULAR_EVENT_BUS_OPENED:
		modem_cmux_attach(&data->cmux, data->uart_pipe);
		modem_cmux_connect_async(&data->cmux);
		break;

	case MODEM_CELLULAR_EVENT_CMUX_CONNECTED:
		modem_cellular_notify_user_pipes_connected(data);
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_OPEN_DLCI1);
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_open_dlci1_state_enter(struct modem_cellular_data *data)
{
	modem_pipe_attach(data->dlci1_pipe, modem_cellular_dlci1_pipe_handler, data);
	return modem_pipe_open_async(data->dlci1_pipe);
}

static void modem_cellular_open_dlci1_event_handler(struct modem_cellular_data *data,
						    enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_DLCI1_OPENED:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_OPEN_DLCI2);
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_open_dlci1_state_leave(struct modem_cellular_data *data)
{
	modem_pipe_release(data->dlci1_pipe);
	return 0;
}

static int modem_cellular_on_open_dlci2_state_enter(struct modem_cellular_data *data)
{
	modem_pipe_attach(data->dlci2_pipe, modem_cellular_dlci2_pipe_handler, data);
	return modem_pipe_open_async(data->dlci2_pipe);
}

static void modem_cellular_open_dlci2_event_handler(struct modem_cellular_data *data,
						    enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_DLCI2_OPENED:
		data->cmd_pipe = data->dlci2_pipe;

		if (config->use_default_pdp_context) {
			modem_cellular_enter_state_network_or_dial(data);
		} else if (!modem_cellular_needs_apn(data)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_APN_SCRIPT);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_WAIT_FOR_APN);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_open_dlci2_state_leave(struct modem_cellular_data *data)
{
	modem_pipe_release(data->dlci2_pipe);
	return 0;
}

static void modem_cellular_wait_for_apn_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_APN_SET:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_APN_SCRIPT);
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;

	default:
		break;
	}
}

static void modem_cellular_script_failed(struct modem_cellular_data *data)
{
	data->script_failure_counter++;
}

static void modem_cellular_script_success(struct modem_cellular_data *data)
{
	data->script_failure_counter = 0;
}

static bool modem_cellular_is_script_retry_exceeded(struct modem_cellular_data *data)
{
	if (data->script_failure_counter >= MODEM_CELLULAR_MAX_SCRIPT_FAILURES) {
		data->script_failure_counter = 0;
		return true;
	}
	return false;
}


static int modem_cellular_on_run_apn_script_state_enter(struct modem_cellular_data *data)
{
	/* Allow modem time to enter command mode before running apn script */
	modem_cellular_start_timer(data, K_MSEC(200));
	modem_cellular_build_apn_script(data);
	return 0;
}

static void modem_cellular_run_apn_script_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_chat_attach(&data->chat, data->dlci1_pipe);
		modem_chat_run_script_async(&data->chat, &data->apn_script);
		break;
	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		modem_cellular_script_success(data);
		modem_cellular_enter_state_network_or_dial(data);
		break;
	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		modem_cellular_script_failed(data);
		if (modem_cellular_is_script_retry_exceeded(data)) {
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_SUSPEND);
		} else {
			modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		}
		break;
	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;
	case MODEM_CELLULAR_EVENT_RING:
		modem_pipe_open_async(data->uart_pipe);
		break;
	default:
		break;
	}
}

static int modem_cellular_on_run_network_script_state_enter(struct modem_cellular_data *data)
{
	modem_chat_attach(&data->chat, data->dlci1_pipe);
	modem_cellular_start_timer(data, K_NO_WAIT);
	return 0;
}

static void modem_cellular_run_network_script_event_handler(struct modem_cellular_data *data,
							    enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config =
		(const struct modem_cellular_config *)data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_chat_run_script_async(&data->chat, config->scripts->network);
		break;
	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		modem_cellular_script_failed(data);
		if (modem_cellular_is_script_retry_exceeded(data)) {
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_SUSPEND);
		} else {
			modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		}
		break;
	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		modem_cellular_script_success(data);
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_REGISTERED);
		break;
	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;
	case MODEM_CELLULAR_EVENT_RING:
		modem_pipe_open_async(data->uart_pipe);
		break;
	default:
		break;
	}
}

static int modem_cellular_on_run_dial_script_state_enter(struct modem_cellular_data *data)
{
	modem_chat_attach(&data->chat, data->dlci2_pipe);
	modem_cellular_start_timer(data, K_NO_WAIT);
	return 0;
}

static void modem_cellular_run_dial_script_event_handler(struct modem_cellular_data *data,
							 enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_chat_run_script_async(&data->chat, config->scripts->dial);
		break;
	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		modem_cellular_script_failed(data);
		if (modem_cellular_is_script_retry_exceeded(data)) {
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_SUSPEND);
		} else {
			modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		}
		break;
	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		modem_cellular_script_success(data);
		modem_chat_release(&data->chat);
		modem_chat_attach(&data->chat, data->dlci1_pipe);

		/* PHY is now up and searching for network */
		net_if_carrier_on(modem_ppp_get_iface(data->ppp));

		if (modem_ppp_attach(data->ppp, data->dlci2_pipe) < 0) {
			LOG_ERR("Failed to attach PPP to DLCI2");
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_SUSPEND);
			break;
		}
		/* Check if we are already registered during the network setup */
		if (modem_cellular_has_network_script(config)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_REGISTERED);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_REGISTERED);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;
	case MODEM_CELLULAR_EVENT_RING:
		LOG_DBG("RING received!");
		modem_pipe_open_async(data->uart_pipe);
		break;
	case MODEM_CELLULAR_EVENT_REGISTERED:
		/* Restart immediately, if we are waiting to retry the dial-script */
		if (!modem_chat_is_running(&data->chat)) {
			modem_cellular_stop_timer(data);
			modem_chat_run_script_async(&data->chat, config->scripts->dial);
		}
		break;
	default:
		break;
	}
}

static int modem_cellular_on_run_dial_script_state_leave(struct modem_cellular_data *data)
{
	return modem_chat_attach(&data->chat, data->dlci1_pipe);
}

static int modem_cellular_on_await_registered_state_enter(struct modem_cellular_data *data)
{
	modem_chat_attach(&data->chat, data->dlci1_pipe);
	modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
	if (modem_cellular_is_registered(data)) {
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_REGISTERED);
	}
	return 0;
}

static void modem_cellular_await_registered_event_handler(struct modem_cellular_data *data,
						  enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		modem_cellular_script_success(data);
		modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		break;

	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		modem_cellular_script_failed(data);
		if (modem_cellular_is_script_retry_exceeded(data)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_RESUME);
		} else {
			modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		}
		break;

	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_chat_run_script_async(&data->chat, config->scripts->periodic);
		break;

	case MODEM_CELLULAR_EVENT_REGISTERED:
		if (modem_cellular_has_network_script(config)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_DIAL_SCRIPT);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_REGISTERED);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		net_if_carrier_off(modem_ppp_get_iface(data->ppp));
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;
	case MODEM_CELLULAR_EVENT_RING:
		LOG_DBG("RING received!");
		modem_pipe_open_async(data->uart_pipe);
		break;
	default:
		break;
	}
}

static int modem_cellular_on_await_registered_state_leave(struct modem_cellular_data *data)
{
	modem_cellular_stop_timer(data);
	return 0;
}

static int modem_cellular_on_registered_state_enter(struct modem_cellular_data *data)
{
	net_if_dormant_off(modem_ppp_get_iface(data->ppp));
	modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
	return 0;
}

static void modem_cellular_registered_event_handler(struct modem_cellular_data *data,
						    enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;
	struct cellular_evt_modem_comms_check_result result;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		modem_cellular_script_success(data);
		modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		result.success = true;
		modem_cellular_emit_event(data, CELLULAR_EVENT_MODEM_COMMS_CHECK_RESULT, &result);
		break;

	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		modem_cellular_script_failed(data);
		if (modem_cellular_is_script_retry_exceeded(data)) {
			net_if_carrier_off(modem_ppp_get_iface(data->ppp));
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
			modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_RESUME);
			LOG_WRN("Maximum script failures reached, restarting modem");
		} else {
			modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		}
		result.success = false;
		modem_cellular_emit_event(data, CELLULAR_EVENT_MODEM_COMMS_CHECK_RESULT, &result);
		break;

	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_chat_run_script_async(&data->chat, config->scripts->periodic);
		break;

	case MODEM_CELLULAR_EVENT_DEREGISTERED:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_PPP_DEAD);
		break;
	case MODEM_CELLULAR_EVENT_PPP_DEAD:
		if (net_if_is_admin_up(modem_ppp_get_iface(data->ppp))) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_PPP_DEAD);
			modem_cellular_start_timer(data, MODEM_CELLULAR_PERIODIC_SCRIPT_TIMEOUT);
		}
		break;

	case MODEM_CELLULAR_EVENT_SUSPEND:
		net_if_carrier_off(modem_ppp_get_iface(data->ppp));
		modem_chat_release(&data->chat);
		modem_ppp_release(data->ppp);
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_INIT_POWER_OFF);
		break;
	case MODEM_CELLULAR_EVENT_RING:
		LOG_DBG("RING received!");
		modem_pipe_open_async(data->uart_pipe);
		break;
	default:
		break;
	}
}

static int modem_cellular_on_registered_state_leave(struct modem_cellular_data *data)
{
	modem_cellular_stop_timer(data);

	return 0;
}

static int modem_cellular_on_await_ppp_dead_state_enter(struct modem_cellular_data *data)
{
	net_if_dormant_on(modem_ppp_get_iface(data->ppp));

	return 0;
}

static void modem_cellular_await_ppp_dead_event_handler(struct modem_cellular_data *data,
						 enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;
	switch (evt) {
	case MODEM_CELLULAR_EVENT_RING:
		LOG_DBG("RING received!");
		modem_pipe_open_async(data->uart_pipe);
	case MODEM_CELLULAR_EVENT_PPP_DEAD:
		/* Wait for the channel to return to AT mode after PPP termination */
		modem_cellular_start_timer(data, K_MSEC(config->reset_pulse_duration_ms));
		break;
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		if (modem_cellular_has_network_script(config) &&
		    !modem_cellular_is_registered(data)) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_REGISTERED);
		} else {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_DIAL_SCRIPT);
		}
		break;
	default:
		break;
	}
}

static int modem_cellular_on_await_ppp_dead_state_leave(struct modem_cellular_data *data)
{
	net_if_carrier_off(modem_ppp_get_iface(data->ppp));
	modem_chat_release(&data->chat);
	modem_ppp_release(data->ppp);

	return 0;
}

static int modem_cellular_on_init_power_off_state_enter(struct modem_cellular_data *data)
{
	modem_cmux_disconnect_async(&data->cmux);
	modem_cellular_start_timer(data, K_MSEC(2000));
	return 0;
}

static void modem_cellular_init_power_off_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	const struct modem_cellular_config *config = data->dev->config;

	switch (evt) {
	case MODEM_CELLULAR_EVENT_CMUX_DISCONNECTED:
		modem_cellular_stop_timer(data);
		data->cmd_pipe = data->uart_pipe;
		/* Assume the same time as reset pulse is enough to return from CMUX to AT mode */
		modem_cellular_start_timer(data, K_MSEC(config->reset_pulse_duration_ms));
		break;
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		/* Shutdown script can only be used if cmd_pipe is available, i.e. we are not in
		 * some intermediary state without a pipe for commands available
		 */
		if (config->scripts->shutdown != NULL && data->cmd_pipe != NULL) {
			modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_RUN_SHUTDOWN_SCRIPT);
			break;
		}

		modem_cellular_begin_power_off_pulse(data);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_init_power_off_state_leave(struct modem_cellular_data *data)
{
	modem_cellular_notify_user_pipes_disconnected(data);
	modem_chat_release(&data->chat);
	modem_ppp_release(data->ppp);
	return 0;
}

static int modem_cellular_on_run_shutdown_script_state_enter(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	modem_chat_attach(&data->chat, data->cmd_pipe);
	return modem_chat_run_script_async(&data->chat, config->scripts->shutdown);
}

static void modem_cellular_run_shutdown_script_event_handler(struct modem_cellular_data *data,
							     enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_SCRIPT_FAILED:
		data->cmd_pipe = NULL;

		/* If shutdown by software failed, try by power pulse if possible */
		modem_cellular_begin_power_off_pulse(data);

		break;

	case MODEM_CELLULAR_EVENT_SCRIPT_SUCCESS:
		modem_pipe_close_async(data->uart_pipe);
		data->cmd_pipe = NULL;
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_run_shutdown_script_state_leave(struct modem_cellular_data *data)
{
	modem_chat_release(&data->chat);
	return 0;
}

static int modem_cellular_on_power_off_pulse_state_enter(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	data->cmd_pipe = NULL;
	gpio_pin_set_dt(&config->power_gpio, 1);
	modem_cellular_start_timer(data, K_MSEC(config->power_pulse_duration_ms));
	return 0;
}

static void modem_cellular_power_off_pulse_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_AWAIT_POWER_OFF);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_power_off_pulse_state_leave(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	gpio_pin_set_dt(&config->power_gpio, 0);
	modem_cellular_stop_timer(data);
	return 0;
}

static int modem_cellular_on_await_power_off_state_enter(struct modem_cellular_data *data)
{
	const struct modem_cellular_config *config = data->dev->config;

	modem_cellular_start_timer(data, K_MSEC(config->shutdown_time_ms));
	return 0;
}

static void modem_cellular_await_power_off_event_handler(struct modem_cellular_data *data,
							enum modem_cellular_event evt)
{
	switch (evt) {
	case MODEM_CELLULAR_EVENT_TIMEOUT:
		modem_cellular_enter_state(data, MODEM_CELLULAR_STATE_IDLE);
		break;

	default:
		break;
	}
}

static int modem_cellular_on_state_enter(struct modem_cellular_data *data)
{
	int ret;

	switch (data->state) {
	case MODEM_CELLULAR_STATE_IDLE:
		ret = modem_cellular_on_idle_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_RESET_PULSE:
		ret = modem_cellular_on_reset_pulse_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_RESET:
		ret = modem_cellular_on_await_reset_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_POWER_ON_PULSE:
		ret = modem_cellular_on_power_on_pulse_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_POWER_ON:
		ret = modem_cellular_on_await_power_on_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_SET_BAUDRATE:
		ret = modem_cellular_on_set_baudrate_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_RUN_INIT_SCRIPT:
		ret = modem_cellular_on_run_init_script_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_CONNECT_CMUX:
		ret = modem_cellular_on_connect_cmux_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_OPEN_DLCI1:
		ret = modem_cellular_on_open_dlci1_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_OPEN_DLCI2:
		ret = modem_cellular_on_open_dlci2_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_RUN_APN_SCRIPT:
		ret = modem_cellular_on_run_apn_script_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_RUN_NETWORK_SCRIPT:
		ret = modem_cellular_on_run_network_script_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_RUN_DIAL_SCRIPT:
		ret = modem_cellular_on_run_dial_script_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_REGISTERED:
		ret = modem_cellular_on_await_registered_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_REGISTERED:
		ret = modem_cellular_on_registered_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_PPP_DEAD:
		ret = modem_cellular_on_await_ppp_dead_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_INIT_POWER_OFF:
		ret = modem_cellular_on_init_power_off_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_RUN_SHUTDOWN_SCRIPT:
		ret = modem_cellular_on_run_shutdown_script_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_POWER_OFF_PULSE:
		ret = modem_cellular_on_power_off_pulse_state_enter(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_POWER_OFF:
		ret = modem_cellular_on_await_power_off_state_enter(data);
		break;

	default:
		ret = 0;
		break;
	}

	return ret;
}

static int modem_cellular_on_state_leave(struct modem_cellular_data *data)
{
	int ret;

	switch (data->state) {
	case MODEM_CELLULAR_STATE_IDLE:
		ret = modem_cellular_on_idle_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_RESET_PULSE:
		ret = modem_cellular_on_reset_pulse_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_RESET:
		ret = modem_cellular_on_await_reset_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_POWER_ON_PULSE:
		ret = modem_cellular_on_power_on_pulse_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_OPEN_DLCI1:
		ret = modem_cellular_on_open_dlci1_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_OPEN_DLCI2:
		ret = modem_cellular_on_open_dlci2_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_RUN_DIAL_SCRIPT:
		ret = modem_cellular_on_run_dial_script_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_REGISTERED:
		ret = modem_cellular_on_await_registered_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_REGISTERED:
		ret = modem_cellular_on_registered_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_PPP_DEAD:
		ret = modem_cellular_on_await_ppp_dead_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_INIT_POWER_OFF:
		ret = modem_cellular_on_init_power_off_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_RUN_SHUTDOWN_SCRIPT:
		ret = modem_cellular_on_run_shutdown_script_state_leave(data);
		break;

	case MODEM_CELLULAR_STATE_POWER_OFF_PULSE:
		ret = modem_cellular_on_power_off_pulse_state_leave(data);
		break;

	default:
		ret = 0;
		break;
	}

	return ret;
}

static void modem_cellular_enter_state(struct modem_cellular_data *data,
				       enum modem_cellular_state state)
{
	int ret;

	ret = modem_cellular_on_state_leave(data);

	if (ret < 0) {
		LOG_WRN("failed to leave state, error: %i", ret);

		return;
	}

	data->state = state;
	ret = modem_cellular_on_state_enter(data);

	if (ret < 0) {
		LOG_WRN("failed to enter state error: %i", ret);
	}
}

static void modem_cellular_event_handler(struct modem_cellular_data *data,
					 enum modem_cellular_event evt)
{
	enum modem_cellular_state state;

	state = data->state;

	modem_cellular_log_event(evt);

	switch (data->state) {
	case MODEM_CELLULAR_STATE_IDLE:
		modem_cellular_idle_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_RESET_PULSE:
		modem_cellular_reset_pulse_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_RESET:
		modem_cellular_await_reset_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_POWER_ON_PULSE:
		modem_cellular_power_on_pulse_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_POWER_ON:
		modem_cellular_await_power_on_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_SET_BAUDRATE:
		modem_cellular_set_baudrate_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_RUN_INIT_SCRIPT:
		modem_cellular_run_init_script_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_CONNECT_CMUX:
		modem_cellular_connect_cmux_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_OPEN_DLCI1:
		modem_cellular_open_dlci1_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_OPEN_DLCI2:
		modem_cellular_open_dlci2_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_WAIT_FOR_APN:
		modem_cellular_wait_for_apn_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_RUN_APN_SCRIPT:
		modem_cellular_run_apn_script_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_RUN_NETWORK_SCRIPT:
		modem_cellular_run_network_script_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_RUN_DIAL_SCRIPT:
		modem_cellular_run_dial_script_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_REGISTERED:
		modem_cellular_await_registered_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_REGISTERED:
		modem_cellular_registered_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_PPP_DEAD:
		modem_cellular_await_ppp_dead_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_INIT_POWER_OFF:
		modem_cellular_init_power_off_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_RUN_SHUTDOWN_SCRIPT:
		modem_cellular_run_shutdown_script_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_POWER_OFF_PULSE:
		modem_cellular_power_off_pulse_event_handler(data, evt);
		break;

	case MODEM_CELLULAR_STATE_AWAIT_POWER_OFF:
		modem_cellular_await_power_off_event_handler(data, evt);
		break;
	}

	if (state != data->state) {
		modem_cellular_log_state_changed(state, data->state);
	}
}

static void modem_cellular_cmux_handler(struct modem_cmux *cmux, enum modem_cmux_event event,
					void *user_data)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)user_data;

	switch (event) {
	case MODEM_CMUX_EVENT_CONNECTED:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_CMUX_CONNECTED);
		break;
	case MODEM_CMUX_EVENT_DISCONNECTED:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_CMUX_DISCONNECTED);
		break;
	default:
		break;
	}
}

MODEM_CHAT_SCRIPT_CMDS_DEFINE(get_signal_csq_chat_script_cmds,
			      MODEM_CHAT_SCRIPT_CMD_RESP("AT+CSQ", csq_match),
			      MODEM_CHAT_SCRIPT_CMD_RESP("", ok_match));

MODEM_CHAT_SCRIPT_DEFINE(get_signal_csq_chat_script, get_signal_csq_chat_script_cmds,
			 abort_matches, modem_cellular_chat_callback_handler, 2);

static inline int modem_cellular_csq_parse_rssi(uint8_t rssi, int16_t *value)
{
	/* AT+CSQ returns a response +CSQ: <rssi>,<ber> where:
	 * - rssi is a integer from 0 to 31 whose values describes a signal strength
	 *   between -113 dBm for 0 and -51dbM for 31 or unknown for 99
	 * - ber is an integer from 0 to 7 that describes the error rate, it can also
	 *   be 99 for an unknown error rate
	 */
	if (rssi == CSQ_RSSI_UNKNOWN) {
		return -EINVAL;
	}

	*value = (int16_t)CSQ_RSSI_TO_DB(rssi);
	return 0;
}

MODEM_CHAT_SCRIPT_CMDS_DEFINE(get_signal_cesq_chat_script_cmds,
			      MODEM_CHAT_SCRIPT_CMD_RESP("AT+CESQ", cesq_match),
			      MODEM_CHAT_SCRIPT_CMD_RESP("", ok_match));

MODEM_CHAT_SCRIPT_DEFINE(get_signal_cesq_chat_script, get_signal_cesq_chat_script_cmds,
			 abort_matches, modem_cellular_chat_callback_handler, 2);

/* AT+CESQ returns a response +CESQ: <rxlev>,<ber>,<rscp>,<ecn0>,<rsrq>,<rsrp> where:
 * - rsrq is a integer from 0 to 34 whose values describes the Reference Signal Receive
 *   Quality between -20 dB for 0 and -3 dB for 34 (0.5 dB steps), or unknown for 255
 * - rsrp is an integer from 0 to 97 that describes the Reference Signal Receive Power
 *   between -140 dBm for 0 and -44 dBm for 97 (1 dBm steps), or unknown for 255
 */
static inline int modem_cellular_cesq_parse_rsrp(uint8_t rsrp, int16_t *value)
{
	if (rsrp == CESQ_RSRP_UNKNOWN) {
		return -EINVAL;
	}

	*value = (int16_t)CESQ_RSRP_TO_DB(rsrp);
	return 0;
}

static inline int modem_cellular_cesq_parse_rsrq(uint8_t rsrq, int16_t *value)
{
	if (rsrq == CESQ_RSRQ_UNKNOWN) {
		return -EINVAL;
	}

	*value = (int16_t)CESQ_RSRQ_TO_DB(rsrq);
	return 0;
}

static int modem_cellular_get_signal(const struct device *dev,
				     const enum cellular_signal_type type,
				     int16_t *value)
{
	int ret = -ENOTSUP;
	struct modem_cellular_data *data = (struct modem_cellular_data *)dev->data;

	if ((data->state != MODEM_CELLULAR_STATE_AWAIT_REGISTERED) &&
	    (data->state != MODEM_CELLULAR_STATE_REGISTERED)) {
		return -ENODATA;
	}

	/* Run chat script */
	switch (type) {
	case CELLULAR_SIGNAL_RSSI:
		ret = modem_chat_run_script(&data->chat, &get_signal_csq_chat_script);
		break;

	case CELLULAR_SIGNAL_RSRP:
	case CELLULAR_SIGNAL_RSRQ:
		ret = modem_chat_run_script(&data->chat, &get_signal_cesq_chat_script);
		break;

	default:
		ret = -ENOTSUP;
		break;
	}

	/* Verify chat script ran successfully */
	if (ret < 0) {
		return ret;
	}

	/* Parse received value */
	switch (type) {
	case CELLULAR_SIGNAL_RSSI:
		ret = modem_cellular_csq_parse_rssi(data->rssi, value);
		break;

	case CELLULAR_SIGNAL_RSRP:
		ret = modem_cellular_cesq_parse_rsrp(data->rsrp, value);
		break;

	case CELLULAR_SIGNAL_RSRQ:
		ret = modem_cellular_cesq_parse_rsrq(data->rsrq, value);
		break;

	default:
		ret = -ENOTSUP;
		break;
	}

	return ret;
}

static int modem_cellular_get_modem_info(const struct device *dev,
					 enum cellular_modem_info_type type,
					 char *info, size_t size)
{
	int ret = 0;
	struct modem_cellular_data *data = (struct modem_cellular_data *)dev->data;

	switch (type) {
	case CELLULAR_MODEM_INFO_IMEI:
		strncpy(info, &data->imei[0], MIN(size, sizeof(data->imei)));
		break;
	case CELLULAR_MODEM_INFO_SIM_IMSI:
		strncpy(info, &data->imsi[0], MIN(size, sizeof(data->imsi)));
		break;
	case CELLULAR_MODEM_INFO_MANUFACTURER:
		strncpy(info, &data->manufacturer[0], MIN(size, sizeof(data->manufacturer)));
		break;
	case CELLULAR_MODEM_INFO_FW_VERSION:
		strncpy(info, &data->fw_version[0], MIN(size, sizeof(data->fw_version)));
		break;
	case CELLULAR_MODEM_INFO_MODEL_ID:
		strncpy(info, &data->model_id[0], MIN(size, sizeof(data->model_id)));
		break;
	case CELLULAR_MODEM_INFO_SIM_ICCID:
		strncpy(info, &data->iccid[0], MIN(size, sizeof(data->iccid)));
		break;
	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}
static int modem_cellular_get_registration_status(const struct device *dev,
						  enum cellular_access_technology tech,
						  enum cellular_registration_status *status)
{
	int ret = 0;
	struct modem_cellular_data *data = (struct modem_cellular_data *)dev->data;

	/* Techs explicitly not handled as N/A to CREG, CGREG, CEREG:
	 *   CELLULAR_ACCESS_TECHNOLOGY_NR_5G_CN
	 *   CELLULAR_ACCESS_TECHNOLOGY_NG_RAN
	 */
	switch (tech) {
	case CELLULAR_ACCESS_TECHNOLOGY_GSM:
	case CELLULAR_ACCESS_TECHNOLOGY_GSM_COMPACT:
		*status = data->registration_status_gsm;
		break;
	case CELLULAR_ACCESS_TECHNOLOGY_GSM_EGPRS:
	case CELLULAR_ACCESS_TECHNOLOGY_EC_GSM_IOT:
	case CELLULAR_ACCESS_TECHNOLOGY_UTRAN:
	case CELLULAR_ACCESS_TECHNOLOGY_UTRAN_HSDPA:
	case CELLULAR_ACCESS_TECHNOLOGY_UTRAN_HSUPA:
	case CELLULAR_ACCESS_TECHNOLOGY_UTRAN_HSDPA_HSUPA:
		*status = data->registration_status_gprs;
		break;
	case CELLULAR_ACCESS_TECHNOLOGY_E_UTRAN:
	case CELLULAR_ACCESS_TECHNOLOGY_E_UTRAN_NB_S1:
	case CELLULAR_ACCESS_TECHNOLOGY_E_UTRA_NR_DUAL:
	case CELLULAR_ACCESS_TECHNOLOGY_E_UTRAN_NB_S1_SAT:
	case CELLULAR_ACCESS_TECHNOLOGY_E_UTRAN_WB_S1_SAT:
	case CELLULAR_ACCESS_TECHNOLOGY_NG_RAN_SAT:
		*status = data->registration_status_lte;
		break;
	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}

static int modem_cellular_set_apn(const struct device *dev, const char *apn)
{
	struct modem_cellular_data *data = dev->data;
	int ret = 0;

	if ((apn == NULL) || (*apn == '\0')) {
		return -EINVAL;
	}

	if (strlen(apn) >= MODEM_CELLULAR_DATA_APN_LEN) {
		return -EINVAL;
	}

	k_mutex_lock(&data->api_lock, K_FOREVER);

	if (strcmp(apn, data->apn) == 0) {
		ret = -EALREADY;
		goto out;
	}

	if (!modem_cellular_apn_change_allowed(data->state)) {
		ret = -EBUSY;
		goto out;
	}

	strncpy(data->apn, apn, MODEM_CELLULAR_DATA_APN_LEN - 1);
	data->apn[MODEM_CELLULAR_DATA_APN_LEN - 1] = '\0';

	/* Wake the state-machine if it is parked in WAIT_FOR_APN */
	modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_APN_SET);

out:
	k_mutex_unlock(&data->api_lock);
	return ret;
}

static int modem_cellular_set_callback(const struct device *dev, cellular_event_mask_t mask,
				       cellular_event_cb_t cb, void *user_data)
{
	struct modem_cellular_data *data = dev->data;
	int ret = 0;

	k_mutex_lock(&data->api_lock, K_FOREVER);

	if (cb == NULL) {
		data->cb.fn = NULL;
		data->cb.mask = 0;
		data->cb.user_data = NULL;
	} else {
		data->cb.fn = cb;
		data->cb.mask = mask;
		data->cb.user_data = user_data;
	}

	k_mutex_unlock(&data->api_lock);
	return ret;
}

DEVICE_API(cellular, modem_cellular_api) = {
	.get_signal = modem_cellular_get_signal,
	.get_modem_info = modem_cellular_get_modem_info,
	.get_registration_status = modem_cellular_get_registration_status,
	.set_apn = modem_cellular_set_apn,
	.set_callback = modem_cellular_set_callback,
};

int modem_cellular_pm_action(const struct device *dev, enum pm_device_action action)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)dev->data;
	int ret;

	switch (action) {
	case PM_DEVICE_ACTION_RESUME:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_RESUME);
		ret = 0;
		break;

	case PM_DEVICE_ACTION_SUSPEND:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_SUSPEND);
		ret = k_sem_take(&data->suspended_sem, K_SECONDS(30));
		break;

	default:
		ret = -ENOTSUP;
		break;
	}

	return ret;
}

static void net_mgmt_event_handler(struct net_mgmt_event_callback *cb, uint64_t mgmt_event,
				   struct net_if *iface)
{
	struct modem_cellular_data *data =
		CONTAINER_OF(cb, struct modem_cellular_data, net_mgmt_event_callback);

	switch (mgmt_event) {
	case NET_EVENT_PPP_PHASE_DEAD:
		modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_PPP_DEAD);
		break;

	default:
		break;
	}
}

static void modem_cellular_ring_gpio_callback(const struct device *dev, struct gpio_callback *cb,
					      uint32_t pins)
{
	struct modem_cellular_data *data =
		CONTAINER_OF(cb, struct modem_cellular_data, ring_gpio_cb);

	modem_cellular_delegate_event(data, MODEM_CELLULAR_EVENT_RING);
}

static void modem_cellular_init_apn(struct modem_cellular_data *data)
{
#ifdef CONFIG_MODEM_CELLULAR_APN
	if (strlen(CONFIG_MODEM_CELLULAR_APN) > 0) {
		strncpy(data->apn, CONFIG_MODEM_CELLULAR_APN, sizeof(data->apn) - 1);
		data->apn[sizeof(data->apn) - 1] = '\0';
	}
#endif

	modem_chat_script_init(&data->apn_script);
	modem_chat_script_set_name(&data->apn_script, "modem_celullar_set_apn");
	modem_chat_script_set_abort_matches(&data->apn_script,
					    abort_matches,
					    ARRAY_SIZE(abort_matches));
	modem_chat_script_set_timeout(&data->apn_script, 1);
	modem_chat_script_set_callback(&data->apn_script,
				       modem_cellular_chat_callback_handler);
}

int modem_cellular_init(const struct device *dev)
{
	struct modem_cellular_data *data = (struct modem_cellular_data *)dev->data;
	struct modem_cellular_config *config = (struct modem_cellular_config *)dev->config;
	const struct gpio_dt_spec *dtr_gpio = NULL;

	data->dev = dev;

	__ASSERT_NO_MSG(config->scripts->init != NULL);
	__ASSERT_NO_MSG(config->scripts->dial != NULL);

	k_mutex_init(&data->api_lock);
	k_work_init_delayable(&data->timeout_work, modem_cellular_timeout_handler);
	k_work_init(&data->event_dispatch_work, modem_cellular_event_dispatch_handler);
	k_pipe_init(&data->event_pipe, data->event_buf, sizeof(data->event_buf));

	k_sem_init(&data->suspended_sem, 0, 1);

	if (modem_cellular_gpio_is_enabled(&config->wake_gpio)) {
		gpio_pin_configure_dt(&config->wake_gpio, GPIO_OUTPUT_INACTIVE);
	}

	if (modem_cellular_gpio_is_enabled(&config->power_gpio)) {
		gpio_pin_configure_dt(&config->power_gpio, GPIO_OUTPUT_INACTIVE);
	}

	if (modem_cellular_gpio_is_enabled(&config->reset_gpio)) {
		gpio_flags_t flags =
			(config->hold_reset_on_suspend) ? GPIO_OUTPUT_ACTIVE : GPIO_OUTPUT_INACTIVE;
		gpio_pin_configure_dt(&config->reset_gpio, flags);
	}

	if (modem_cellular_gpio_is_enabled(&config->ring_gpio)) {
		int ret;

		ret = gpio_pin_configure_dt(&config->ring_gpio, GPIO_INPUT);
		if (ret < 0) {
			LOG_ERR("Failed to configure ring GPIO (%d)", ret);
			return ret;
		}

		gpio_init_callback(&data->ring_gpio_cb, modem_cellular_ring_gpio_callback,
				   BIT(config->ring_gpio.pin));

		ret = gpio_add_callback(config->ring_gpio.port, &data->ring_gpio_cb);
		if (ret < 0) {
			LOG_ERR("Failed to add ring GPIO callback (%d)", ret);
			return ret;
		}

		ret = gpio_pin_interrupt_configure_dt(&config->ring_gpio, GPIO_INT_EDGE_TO_ACTIVE);
		if (ret < 0) {
			LOG_ERR("Failed to configure ring GPIO interrupt (%d)", ret);
			return ret;
		}

		LOG_DBG("Ring GPIO interrupt configured");
	}

	if (modem_cellular_gpio_is_enabled(&config->dtr_gpio)) {
		gpio_pin_configure_dt(&config->dtr_gpio, GPIO_OUTPUT_INACTIVE);
		dtr_gpio = &config->dtr_gpio;
	}

	{
		const struct modem_backend_uart_config uart_backend_config = {
			.uart = config->uart,
			.dtr_gpio = dtr_gpio,
			.receive_buf = data->uart_backend_receive_buf,
			.receive_buf_size = ARRAY_SIZE(data->uart_backend_receive_buf),
			.transmit_buf = data->uart_backend_transmit_buf,
			.transmit_buf_size = ARRAY_SIZE(data->uart_backend_transmit_buf),
		};

		data->uart_pipe = modem_backend_uart_init(&data->uart_backend,
							  &uart_backend_config);

		data->cmd_pipe = NULL;
	}

	{
		const struct modem_cmux_config cmux_config = {
			.callback = modem_cellular_cmux_handler,
			.user_data = data,
			.receive_buf = data->cmux_receive_buf,
			.receive_buf_size = ARRAY_SIZE(data->cmux_receive_buf),
			.transmit_buf = data->cmux_transmit_buf,
			.transmit_buf_size = ARRAY_SIZE(data->cmux_transmit_buf),
			.enable_runtime_power_management = config->cmux_enable_runtime_power_save,
			.close_pipe_on_power_save = config->cmux_close_pipe_on_power_save,
			.idle_timeout = config->cmux_idle_timeout,
		};

		modem_cmux_init(&data->cmux, &cmux_config);
	}

	{
		const struct modem_cmux_dlci_config dlci1_config = {
			.dlci_address = 1,
			.receive_buf = data->dlci1_receive_buf,
			.receive_buf_size = ARRAY_SIZE(data->dlci1_receive_buf),
		};

		data->dlci1_pipe = modem_cmux_dlci_init(&data->cmux, &data->dlci1,
							&dlci1_config);
	}

	{
		const struct modem_cmux_dlci_config dlci2_config = {
			.dlci_address = 2,
			.receive_buf = data->dlci2_receive_buf,
			.receive_buf_size = ARRAY_SIZE(data->dlci2_receive_buf),
		};

		data->dlci2_pipe = modem_cmux_dlci_init(&data->cmux, &data->dlci2,
							&dlci2_config);
	}

	for (uint8_t i = 0; i < config->user_pipes_size; i++) {
		struct modem_cellular_user_pipe *user_pipe = &config->user_pipes[i];
		const struct modem_cmux_dlci_config user_dlci_config = {
			.dlci_address = user_pipe->dlci_address,
			.receive_buf = user_pipe->dlci_receive_buf,
			.receive_buf_size = user_pipe->dlci_receive_buf_size,
		};

		user_pipe->pipe = modem_cmux_dlci_init(&data->cmux, &user_pipe->dlci,
						       &user_dlci_config);

		modem_pipelink_init(user_pipe->pipelink, user_pipe->pipe);
	}

	{
		const struct modem_chat_config chat_config = {
			.user_data = data,
			.receive_buf = data->chat_receive_buf,
			.receive_buf_size = ARRAY_SIZE(data->chat_receive_buf),
			.delimiter = data->chat_delimiter,
			.delimiter_size = strlen(data->chat_delimiter),
			.filter = data->chat_filter,
			.filter_size = data->chat_filter ? strlen(data->chat_filter) : 0,
			.argv = data->chat_argv,
			.argv_size = ARRAY_SIZE(data->chat_argv),
			.unsol_matches = config->unsol->matches,
			.unsol_matches_size = config->unsol->size,
		};

		modem_chat_init(&data->chat, &chat_config);
	}

	{
		net_mgmt_init_event_callback(&data->net_mgmt_event_callback, net_mgmt_event_handler,
					     NET_EVENT_PPP_PHASE_DEAD);
		net_mgmt_add_event_callback(&data->net_mgmt_event_callback);
	}

	modem_cellular_init_apn(data);

	return pm_device_driver_init(dev, modem_cellular_pm_action);
}