k_sem_take hangs if I enable CONFIG_PM* STM32U575

[zafersn]

I am working on the hl7800 modem with the stm32u575 mcu, I need to send at commands and nothing else so
I wanted to have a uart comms with the hl modem, nothing else, So basically, I eliminated almost everything except uart and related to it.
the issue is
Whenever I enable
CONFIG_PM=y
CONFIG_PM_DEVICE=y
CONFIG_PM_DEVICE_RUNTIME=y

ret = k_sem_take(&iface_ctx.hl7812_serial_awake, MDM_BOOT_TIME) hangs and no more process, I had the same issue with different configs, I tried to explain here #66002

can anyone shed some light on how to solve this issue?

here is the code I use to have uart comms with the modem.

Please, Can anyone explain how to debug on this platform? I am really struggling with debugging, for example, like this issue. what are your steps to find out the error?

/*
 * Copyright (c) 2020 Laird Connectivity
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#define DT_DRV_COMPAT swir_hl7812

#include <zephyr/logging/log.h>
#include <zephyr/logging/log_ctrl.h>
#define LOG_MODULE_NAME MODEM_HL7812_SERIAL
LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_MODEM_HL7812_SERIAL_CUSTOM_LOG_LEVEL);

#include <zephyr/types.h>
#include <stddef.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/sys/util.h>

#include <zephyr/devicetree.h>
#include <zephyr/sys/ring_buffer.h>
#include <zephyr/net/buf.h>

#include <custom/modem/hl7812_serial.h>
#include <string.h>
#include <stdio.h>

#define PREFIXED_SWITCH_CASE_RETURN_STRING(prefix, val)                        \
	case prefix##_##val: {                                                 \
		return #val;                                                   \
	}

/* Uncomment the #define below to enable a hexdump of all incoming
 * data from the modem receiver
 */
/* #define HL7812_ENABLE_VERBOSE_MODEM_RECV_HEXDUMP 1 */

#define HL7812_LOG_UNHANDLED_RX_MSGS 1

/* Uncomment the #define(s) below to enable extra debugging */
/* #define HL7812_RX_LOCK_LOG 1 */
/* #define HL7812_TX_LOCK_LOG 1 */
#define HL7812_IO_LOG 1

#define HL7812_RX_LOCK_DBG_LOG(fmt, ...)                                       \
	do {                                                                   \
		if (IS_ENABLED(HL7812_RX_LOCK_LOG)) {                          \
			LOG_DBG(fmt, ##__VA_ARGS__);                           \
		}                                                              \
	} while (false)

#define HL7812_TX_LOCK_DBG_LOG(fmt, ...)                                       \
	do {                                                                   \
		if (IS_ENABLED(HL7812_TX_LOCK_LOG)) {                          \
			LOG_DBG(fmt, ##__VA_ARGS__);                           \
		}                                                              \
	} while (false)

#define HL7812_IO_DBG_LOG(fmt, ...)                                            \
	do {                                                                   \
		if (IS_ENABLED(HL7812_IO_LOG)) {                               \
			LOG_DBG(fmt, ##__VA_ARGS__);                           \
		}                                                              \
	} while (false)

#if ((LOG_LEVEL == LOG_LEVEL_DBG))
#define PRINT_AWAKE_MSG LOG_WRN("awake")
#define PRINT_NOT_AWAKE_MSG LOG_WRN("NOT awake")
#else
#define PRINT_AWAKE_MSG
#define PRINT_NOT_AWAKE_MSG
#endif
enum hl7812_serial_startup_state {
	HL7812_STARTUP_STATE_READY = 0,
	HL7812_STARTUP_STATE_WAITING_FOR_ACCESS_CODE,
	HL7812_STARTUP_STATE_SIM_NOT_PRESENT,
	HL7812_STARTUP_STATE_SIMLOCK,
	HL7812_STARTUP_STATE_UNRECOVERABLE_ERROR,
	HL7812_STARTUP_STATE_UNKNOWN,
	HL7812_STARTUP_STATE_INACTIVE_SIM
};

/* pin settings */
enum hl7812_serial_control_pins {
	MDM_RESET = 0,
	MDM_WAKE,
	MDM_PWR_ON,
	MDM_FAST_SHUTD,
	MDM_VGPIO,
	MDM_UART_DSR,
	MDM_UART_CTS,
	MDM_GPIO6,
	MAX_MDM_CONTROL_PINS,
};

#define HL7812_MODEM_NODE DT_COMPAT_GET_ANY_STATUS_OKAY(swir_hl7812)
#define UART_NODE DT_BUS(HL7812_MODEM_NODE)

#define MDM_UART_DEV	DEVICE_DT_GET(UART_NODE)
#define MDM_DEFAULT_AT_CMD_RETRIES 3

#define MDM_MAX_DATA_LENGTH 1500
#define MDM_MAX_RESP_SIZE 128
#define MDM_HANDLER_MATCH_MAX_LEN 100
#define MDM_CMD_SEND_TIMEOUT K_SECONDS(6)

#define BUF_ALLOC_TIMEOUT K_SECONDS(1)

#define CMD_HANDLER(cmd_, cb_)                                                 \
	{                                                                      \
		.cmd = cmd_, .cmd_len = (uint16_t)sizeof(cmd_) - 1,            \
		.func = on_cmd_##cb_                                           \
	}

#define MDM_BOOT_TIME K_SECONDS(12)

#define MDM_RESET_LOW_TIME K_MSEC(50)
#define MDM_RESET_HIGH_TIME K_MSEC(10)
#define MAX_MDM_CTX 1

NET_BUF_POOL_DEFINE(hl7812_serial_recv_pool, CONFIG_MODEM_HL7812_CUSTOM_RECV_BUF_CNT,
		    CONFIG_MODEM_HL7812_CUSTOM_RECV_BUF_SIZE, 0, NULL);

static uint8_t hl7812_serial_recv_buf[MDM_MAX_DATA_LENGTH];

static K_SEM_DEFINE(hl7812_RX_lock_sem, 1, 1);
static K_SEM_DEFINE(hl7812_TX_lock_sem, 1, 1);
static K_SEM_DEFINE(cb_lock, 1, 1);

/* RX thread structures */

K_THREAD_STACK_DEFINE(hl7812_rx_stack_serial, CONFIG_MODEM_HL7812_CUSTOM_RX_STACK_SIZE);

struct k_thread hl7812_rx_thread_serial;
#define RX_THREAD_PRIORITY K_PRIO_COOP(7)

/* RX thread work queue */
K_THREAD_STACK_DEFINE(hl7812_workq_stack_serial,
		      CONFIG_MODEM_HL7812_CUSTOM_RX_WORKQ_STACK_SIZE);
static struct k_work_q hl7812_workq;
#define WORKQ_PRIORITY K_PRIO_COOP(7)
struct hl7812_serial_compound_event {
	uint8_t code;
	char *string;
};
struct hl_receiver_context {
	const struct device *uart_dev;
	/* rx data */
	struct ring_buf rx_rb;
	struct k_sem rx_sem;
};


#define NO_ID_RESP_CMD_MAX_LENGTH 32
struct cmd_handler {
	const char *cmd;
	uint16_t cmd_len;
	bool (*func)(struct net_buf **buf, uint16_t len);
};

struct cmd_buffer {
	char cmd[CONFIG_MODEM_HL7812_CUSTOM_RECV_BUF_CNT];
	uint16_t cmd_len;
};
struct hl7812_config {
	struct gpio_dt_spec gpio[MAX_MDM_CONTROL_PINS];
};
struct hl7812_iface_ctx {
	bool restarting;
	bool initialized;
	/* GPIO PORT devices */
	struct gpio_callback hl7812_serial_vgpio_cb;
	struct gpio_callback hl7812_serial_uart_dsr_cb;
	struct gpio_callback hl7812_serial_gpio6_cb;
	struct gpio_callback hl7812_serial_uart_cts_cb;
	int vgpio_state;
	int dsr_state;
	int gpio6_state;
	int cts_state;
	struct cmd_buffer latest_cmd;
	/* RX specific attributes */
	struct hl_receiver_context hl7812_serial_ctx;

	/* semaphores */
	struct k_sem response_sem;
	struct k_sem hl7812_serial_awake;

	/* work */
	struct k_work hl7812_serial_vgpio_work;
	struct k_work_delayable hl7812_serial_reset_work;
	struct k_work hl7812_serial_pwr_off_work;
	/* modem info */

	enum hl7812_serial_startup_state hl7812_serial_startup_state;
	bool hl7812_serial_echo_is_on;
	bool hl7812_serial_startup_reporting_on;
	/* modem state */
	bool uart_on;
	bool configured;
	bool off;
	void (*wake_up_callback)(int state);
	void (*gpio6_callback)(int state);
	void (*cts_callback)(int state);
};

const static struct hl7812_config hl7812_cfg = {
	.gpio = {
		GPIO_DT_SPEC_INST_GET(0, mdm_reset_gpios),
		GPIO_DT_SPEC_INST_GET(0, mdm_wake_gpios),
		GPIO_DT_SPEC_INST_GET(0, mdm_pwr_on_gpios),
		GPIO_DT_SPEC_INST_GET(0, mdm_fast_shutd_gpios),
		GPIO_DT_SPEC_INST_GET(0, mdm_vgpio_gpios),
		GPIO_DT_SPEC_INST_GET(0, mdm_uart_dsr_gpios),
		GPIO_DT_SPEC_INST_GET(0, mdm_uart_cts_gpios),
		GPIO_DT_SPEC_INST_GET(0, mdm_gpio6_gpios),
	},
};

struct hl7812_iface_ctx iface_ctx;

static struct hl_receiver_context *contexts[MAX_MDM_CTX];

static size_t hl7812_read_rx(struct net_buf **buf);
static void set_startup_state(enum hl7812_serial_startup_state state);
static int modem_boot_handler(char *reason);
static void hl7812_serial_serial_vgpio_work_cb(struct k_work *item);
static void hl7812_serial_reset_work_callback(struct k_work *item);
static void hl7812_serial_power_off_work_callback(struct k_work *item);

static int modem_reset_and_configure(void);

static int read_pin(int default_state, const struct gpio_dt_spec *spec)
{
	int state = gpio_pin_get_raw(spec->port, spec->pin);

	if (state < 0) {
		LOG_ERR("Unable to read port: %s pin: %d status: %d",
			spec->port->name, spec->pin, state);
		state = default_state;
	}

	return state;
}

static int hl7812_RX_lock(void)
{
	HL7812_RX_LOCK_DBG_LOG("Locking RX [%p]...", k_current_get());
	int rc = k_sem_take(&hl7812_RX_lock_sem, K_FOREVER);

	if (rc != 0) {
		LOG_ERR("Unable to lock hl7812 (%d)", rc);
	} else {
		HL7812_RX_LOCK_DBG_LOG("Locked RX [%p]", k_current_get());
	}

	return rc;
}

static void hl7812_RX_unlock(void)
{
	HL7812_RX_LOCK_DBG_LOG("UNLocking RX [%p]...", k_current_get());
	k_sem_give(&hl7812_RX_lock_sem);
	HL7812_RX_LOCK_DBG_LOG("UNLocked RX [%p]", k_current_get());
}

static bool hl7812_RX_locked(void)
{
	if (k_sem_count_get(&hl7812_RX_lock_sem) == 0) {
		return true;
	} else {
		return false;
	}
}

static int hl7812_TX_lock(void)
{
	HL7812_TX_LOCK_DBG_LOG("Locking TX [%p]...", k_current_get());
	int rc = k_sem_take(&hl7812_TX_lock_sem, K_FOREVER);

	if (rc != 0) {
		LOG_ERR("Unable to lock hl7812 (%d)", rc);
	} else {
		HL7812_TX_LOCK_DBG_LOG("Locked TX [%p]", k_current_get());
	}

	return rc;
}

static void hl7812_TX_unlock(void)
{
	HL7812_TX_LOCK_DBG_LOG("UNLocking TX [%p]...", k_current_get());
	k_sem_give(&hl7812_TX_lock_sem);
	HL7812_TX_LOCK_DBG_LOG("UNLocked TX [%p]", k_current_get());
}

static void hl7812_lock(void)
{
	hl7812_TX_lock();
	hl7812_RX_lock();
}

static void hl7812_unlock(void)
{
	hl7812_RX_unlock();
	hl7812_TX_unlock();
}

void hl7812_serial_serial_register_wake_test_point_callback(void (*func)(int state))
{
	iface_ctx.wake_up_callback = func;
}

void hl7812_serial_serial_register_gpio6_callback(void (*func)(int state))
{
	
	iface_ctx.gpio6_callback = func;
}

void hl7812_serial_serial_register_cts_callback(void (*func)(int state))
{
	
	iface_ctx.cts_callback = func;
}

static void modem_assert_wake(bool assert)
{
	int state;
	if (assert) {
		HL7812_IO_DBG_LOG("MDM_WAKE_PIN -> ASSERTED");
		state = 1;
	} else {
		HL7812_IO_DBG_LOG("MDM_WAKE_PIN -> NOT_ASSERTED");
		state = 0;
	}

	gpio_pin_set_dt(&hl7812_cfg.gpio[MDM_WAKE], state);

	if (iface_ctx.wake_up_callback != NULL) {
		iface_ctx.wake_up_callback(state);
	}
}

static void modem_assert_pwr_on(bool assert)
{
	if (assert) {
		HL7812_IO_DBG_LOG("MDM_PWR_ON -> ASSERTED");
		gpio_pin_set_dt(&hl7812_cfg.gpio[MDM_PWR_ON], 1);
	} else {
		HL7812_IO_DBG_LOG("MDM_PWR_ON -> NOT_ASSERTED");
		gpio_pin_set_dt(&hl7812_cfg.gpio[MDM_PWR_ON], 0);
	}
}

static void modem_assert_fast_shutd(bool assert)
{
	if (assert) {
		HL7812_IO_DBG_LOG("MDM_FAST_SHUTD -> ASSERTED");
		gpio_pin_set_dt(&hl7812_cfg.gpio[MDM_FAST_SHUTD], 1);
	} else {
		HL7812_IO_DBG_LOG("MDM_FAST_SHUTD -> NOT_ASSERTED");
		gpio_pin_set_dt(&hl7812_cfg.gpio[MDM_FAST_SHUTD], 0);
	}
}

static int hl7812_serial_receiver_send(struct hl_receiver_context *ctx,
		      const uint8_t *buf, size_t size)
{
	if (!ctx) {
		return -EINVAL;
	}

	if (size == 0) {
		return 0;
	}

	do {
		uart_poll_out(ctx->uart_dev, *buf++);
	} while (--size);

	return 0;
}
/* Send an AT command with a series of response handlers */
static int send_at_cmd(const uint8_t *data,
		       k_timeout_t timeout, int retries, bool no_id_resp)
{
	int ret = 0;
	do {
		k_sem_reset(&iface_ctx.response_sem);
		LOG_DBG("OUT: [%s]", (char *)data);
		size_t sizedata = strlen(data);
		strcpy(iface_ctx.latest_cmd.cmd, data);
		iface_ctx.latest_cmd.cmd_len = sizedata;
		hl7812_serial_receiver_send(&iface_ctx.hl7812_serial_ctx, data, sizedata);
		hl7812_serial_receiver_send(&iface_ctx.hl7812_serial_ctx, "\r", 1);

		if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
			LOG_ERR("timeout!..");
			goto done;
		}

		ret = k_sem_take(&iface_ctx.response_sem, timeout);
		
		if (ret == 0) {
		
		} else if (ret == -EAGAIN) {
			ret = -ETIMEDOUT;
		}

		retries--;
		if (retries < 0) {
			retries = 0;
		}
	} while (ret != 0 && retries > 0);
done:
	return ret;
}

int hl7812_serial_send_at_cmd(const uint8_t *data)
{
	int ret;
	if (!data) {
		return -EINVAL;
	}

	hl7812_lock();

	ret = send_at_cmd(data, MDM_CMD_SEND_TIMEOUT, 0, false);

	hl7812_unlock();
	return ret;
}

uint32_t hl7812_serial_log_filter_set_serial(uint32_t level)
{
	uint32_t new_log_level = 0;

#ifdef CONFIG_LOG_RUNTIME_FILTERING
	new_log_level =
		log_filter_set(NULL, Z_LOG_LOCAL_DOMAIN_ID,
			       log_source_id_get(STRINGIFY(LOG_MODULE_NAME)),
			       level);
#endif

	return new_log_level;
}


/* Make sure all IO voltages are removed for proper reset. */
static void prepare_io_for_reset(void)
{
	HL7812_IO_DBG_LOG("Preparing IO for reset/sleep");
	modem_assert_wake(false);
	modem_assert_pwr_on(false);
	modem_assert_fast_shutd(false);
}
void prepend_serial(char* s, const char* t);

static void hl7812_serial_reset_work_callback(struct k_work *item)
{
	ARG_UNUSED(item);

	hl7812_serial_reset();
}
static void hl7812_serial_power_off_work_callback(struct k_work *item)
{
	ARG_UNUSED(item);
	int ret;

	hl7812_lock();

	ret = send_at_cmd("AT+CPOF", MDM_CMD_SEND_TIMEOUT, 1, false);
	if (ret) {
		LOG_ERR("AT+CPOF ret:%d", ret);
		return;
	}
	prepare_io_for_reset();
	iface_ctx.configured = false;
	iface_ctx.off = true;
	LOG_DBG("Modem powered off");
	hl7812_unlock();
}
int schedule_modem_restart(void)
{
	return k_work_reschedule_for_queue(&hl7812_workq, &iface_ctx.hl7812_serial_reset_work, K_NO_WAIT);
}
int32_t hl7812_serial_reset(void)
{
	int ret;

	hl7812_lock();

	ret = modem_reset_and_configure();

	hl7812_unlock();

	return ret;
}
static int hl7812_power_off(void)
{
	int ret = 0;
	LOG_DBG("Powering off modem");
	ret = k_work_cancel_delayable(&iface_ctx.hl7812_serial_reset_work);
	(void)k_work_submit_to_queue(&hl7812_workq, &iface_ctx.hl7812_serial_pwr_off_work);
	return ret;
}

int hl7812_serial_power_off(void)
{
	int rc;

	hl7812_lock();
	rc = hl7812_power_off();
	hl7812_unlock();

	return rc;
}
/* Prepends t into s. Assumes s has enough space allocated
** for the combined string.
*/
void prepend_serial(char* s, const char* t)
{
    size_t len = strlen(t);
    memmove(s + len, s, strlen(s) + 1);
    memcpy(s, t, len);
}

void format_at_serial(const char *prefix, struct net_buf *buf, uint16_t len, char *msg)
{
	memcpy(msg, buf->data, len);
	prepend_serial(msg, prefix);
	msg[len+(sizeof(prefix)*2)]= '\0';
	//printk("***SIZE OF PREFIX = %i***\n", sizeof(prefix)*2);
}

int find_null_serial(uint8_t *data, size_t send_len)
{
	int null_pos = 0;
	for (int i = 0; i < send_len; i++)
	{
		if (data == NULL && (i != (send_len-1)))
		{
			null_pos = i;
			//printk("null at %i\n",i);
		};
	}
	return null_pos;
}

#define MAX_TOPIC_SIZE 64
#define MAX_PAYLOAD_SIZE 256

int get_string_start_serial(uint8_t *data, uint16_t length)
{
	for (int i = 0; i < length; i++)
	{
		if(isalnum(data[i]))
		{
			return i;
		}
	}
	return -1;
}

/*** NET_BUF HELPERS ***/

static bool is_crlf(uint8_t c)
{
	if (c == '\n' || c == '\r') {
		return true;
	} else {
		return false;
	}
}

/* Handler: +KSUP: # */
static bool on_cmd_startup_report(struct net_buf **buf, uint16_t len)
{
	size_t out_len;
	char value[MDM_MAX_RESP_SIZE];

	memset(value, 0, sizeof(value));
	out_len = net_buf_linearize(value, sizeof(value), *buf, 0, len);
	if (out_len > 0) {
		set_startup_state(strtol(value, NULL, 10));
	} else {
		set_startup_state(HL7812_STARTUP_STATE_UNKNOWN);
	}

	{
		PRINT_AWAKE_MSG;
		iface_ctx.hl7812_serial_startup_reporting_on = true;
		k_sem_give(&iface_ctx.hl7812_serial_awake);
	}

	return true;
}
static void net_buf_skipcrlf(struct net_buf **buf)
{
	/* chop off any /n or /r */
	while (*buf && is_crlf(*(*buf)->data)) {
		net_buf_pull_u8(*buf);
		if (!(*buf)->len) {
			*buf = net_buf_frag_del(NULL, *buf);
		}
	}
}

static uint16_t net_buf_findcrlf(struct net_buf *buf, struct net_buf **frag)
{
	uint16_t len = 0U, pos = 0U;

	while (buf && !is_crlf(*(buf->data + pos))) {
		if (pos + 1 >= buf->len) {
			len += buf->len;
			buf = buf->frags;
			pos = 0U;
		} else {
			pos++;
		}
	}

	if (buf && is_crlf(*(buf->data + pos))) {
		len += pos;
		*frag = buf;
		return len;
	}

	return 0;
}

static uint32_t net_buf_remove(struct net_buf **buf, uint32_t len)
{
	uint32_t to_remove;
	uint32_t removed = 0;

	while (*buf && len > 0) {
		to_remove = (*buf)->len;
		if (to_remove > len) {
			to_remove = len;
		}
		net_buf_pull(*buf, to_remove);
		removed += to_remove;
		len -= to_remove;
		if (!(*buf)->len) {
			*buf = net_buf_frag_del(NULL, *buf);
		}
	}
	return removed;
}

static void set_startup_state(enum hl7812_serial_startup_state state)
{
	iface_ctx.hl7812_serial_startup_state = state;
}

#define MQTT_MAX_SIZE_RX 256

static inline struct net_buf *read_rx_allocator(k_timeout_t timeout,
						void *user_data)
{
	return net_buf_alloc((struct net_buf_pool *)user_data, timeout);
}
static int hl7812_serial_receiver_recv(struct hl_receiver_context *ctx,
		      uint8_t *buf, size_t size, size_t *bytes_read)
{
	if (!ctx) {
		return -EINVAL;
	}

	if (size == 0) {
		*bytes_read = 0;
		return 0;
	}

	*bytes_read = ring_buf_get(&ctx->rx_rb, buf, size);
	return 0;
}
static size_t hl7812_read_rx(struct net_buf **buf)
{
	uint8_t uart_buffer[CONFIG_MODEM_HL7812_CUSTOM_RECV_BUF_SIZE];
	size_t bytes_read, total_read;
	int ret;
	uint16_t rx_len;

	bytes_read = 0, total_read = 0;

	/* read all of the data from hl7812_serial_receiver */
	while (true) {
		ret = hl7812_serial_receiver_recv(&iface_ctx.hl7812_serial_ctx, uart_buffer,
					sizeof(uart_buffer), &bytes_read);
		if (ret < 0 || bytes_read == 0) {
			/* hl7812_serial_receiver buffer is empty */
			break;
		}

		if (IS_ENABLED(HL7812_ENABLE_VERBOSE_MODEM_RECV_HEXDUMP)) {
			LOG_HEXDUMP_DBG((const uint8_t *)&uart_buffer,
					bytes_read, "HL7812 RX");
		}
		/* make sure we have storage */
		if (!*buf) {
			*buf = net_buf_alloc(&hl7812_serial_recv_pool, BUF_ALLOC_TIMEOUT);
			if (!*buf) {
				LOG_ERR("Can't allocate RX data! "
					"Skipping data!");
				break;
			}
		}

		rx_len =
			net_buf_append_bytes(*buf, bytes_read, uart_buffer,
					     BUF_ALLOC_TIMEOUT,
					     read_rx_allocator, &hl7812_serial_recv_pool);
		if (rx_len < bytes_read) {
			LOG_ERR("Data was lost! read %u of %zu!", rx_len,
				bytes_read);
		}
		total_read += bytes_read;
	}

	return total_read;
}

/* Handle the "OK" response from an AT command or a socket call */
static bool on_cmd_sockok(struct net_buf **buf, uint16_t len)
{
	k_sem_give(&iface_ctx.response_sem);

	return true;
}

/* Handler: ERROR */
static bool on_cmd_sockerror(struct net_buf **buf, uint16_t len)
{
	char string[MDM_MAX_RESP_SIZE];

	if (len > 0) {
		memset(string, 0, sizeof(string));
		net_buf_linearize(string, sizeof(string), *buf, 0, len);
		LOG_ERR("'%s'", string);
	}

	
	k_sem_give(&iface_ctx.response_sem);

	return true;
}

/* Handler: CME/CMS Error */
static bool on_cmd_sock_error_code(struct net_buf **buf, uint16_t len)
{
	char value[MDM_MAX_RESP_SIZE];
	size_t out_len;

	out_len = net_buf_linearize(value, sizeof(value), *buf, 0, len);
	value[out_len] = 0;

	LOG_ERR("Error code: %s", value);

	
	k_sem_give(&iface_ctx.response_sem);

	return true;
}
/* RX thread */
static void hl7812_rx(void)
{
	struct net_buf *rx_buf = NULL;
	struct net_buf *frag = NULL;
	int i, cmp_res;
	uint16_t len;
	size_t out_len;
	bool cmd_handled = false;
	static char rx_msg[MDM_HANDLER_MATCH_MAX_LEN];
	bool unlock = false;
	bool remove_line_from_buf = true;
#ifdef HL7812_LOG_UNHANDLED_RX_MSGS
	char msg[MDM_MAX_RESP_SIZE];
#endif
	static const struct cmd_handler handlers[] = {
				/* UNSOLICITED modem information */
			/* mobile startup report */
			CMD_HANDLER("+KSUP: ", startup_report),
			/* SOLICITED CMD AND SOCKET RESPONSES */
			CMD_HANDLER("OK", sockok),
			CMD_HANDLER("ERROR", sockerror),

			/* SOLICITED SOCKET RESPONSES */
			CMD_HANDLER("+CME ERROR: ", sock_error_code),
			CMD_HANDLER("+CMS ERROR: ", sock_error_code),
			CMD_HANDLER("+CEER: ", sockerror),
	};

	while (true) {
		/* wait for incoming data */
		(void)k_sem_take(&iface_ctx.hl7812_serial_ctx.rx_sem, K_FOREVER);

		hl7812_read_rx(&rx_buf);
		/* If an external module hasn't locked the command processor,
		 * then do so now.
		 */
		if (!hl7812_RX_locked()) {
			hl7812_RX_lock();
			unlock = true;
		} else {
			unlock = false;
		}

		while (rx_buf) {
			remove_line_from_buf = true;
			cmd_handled = false;

			net_buf_skipcrlf(&rx_buf);
			if (!rx_buf) {
				break;
			}

			frag = NULL;
			len = net_buf_findcrlf(rx_buf, &frag);
			if (!frag) {
				break;
			}

			out_len = net_buf_linearize(rx_msg, sizeof(rx_msg),
						    rx_buf, 0, len);

			/* look for matching data handlers */
			i = -1;
			for (i = 0; i < ARRAY_SIZE(handlers); i++) {
				{
					cmp_res =
						strncmp(rx_msg, handlers[i].cmd,
							handlers[i].cmd_len);
				}

				if (cmp_res == 0) {
					/* found a matching handler */
					/* locate next cr/lf */
					frag = NULL;
					len = net_buf_findcrlf(rx_buf, &frag);
					if (!frag) {
						break;
					}

					LOG_DBG("HANDLE %s (len:%u)",
						handlers[i].cmd, len);
					// printk("old 11 %s %d, %d\n", iface_ctx.latest_cmd.cmd, strlen(iface_ctx.latest_cmd.cmd), iface_ctx.latest_cmd.cmd_len);
					if(strncmp(iface_ctx.latest_cmd.cmd,"AT+CEREG=0", 10) 
						&& strncmp(iface_ctx.latest_cmd.cmd,"AT&W", 4)
						&& strncmp(iface_ctx.latest_cmd.cmd,"ATE0", 4)
						&& strncmp(handlers[i].cmd,"+KSUP", 5))
					// hl7812_rx_callback(handlers[i].cmd, len);
					/* call handler */
					if (handlers[i].func) {
						remove_line_from_buf =
							handlers[i].func(
								&rx_buf, len);
					}
					cmd_handled = true;
					frag = NULL;
					/* make sure buf still has data */
					if (!rx_buf) {
						break;
					}

					/* We've handled the current line
					 * and need to exit the "search for
					 * handler loop".  Let's skip any
					 * "extra" data and look for the next
					 * CR/LF, leaving us ready for the
					 * next handler search.
					 */
					len = net_buf_findcrlf(rx_buf, &frag);
					break;
				}
			}
			/* Handle unhandled commands */
			if (IS_ENABLED(HL7812_LOG_UNHANDLED_RX_MSGS) &&
			    !cmd_handled && frag && len > 1) {
				out_len = net_buf_linearize(msg, sizeof(msg),
							    rx_buf, 0, len);
				msg[out_len] = 0;
				LOG_DBG("%s", msg);
				// LOG_HEXDUMP_DBG((const uint8_t *)&msg, len,
				// 		"UNHANDLED RX");
				// printk("old 22 %s %d, %d\n", iface_ctx.latest_cmd.cmd, strlen(iface_ctx.latest_cmd.cmd), iface_ctx.latest_cmd.cmd_len);
				if(/* strncmp(iface_ctx.latest_cmd.cmd,"AT+CEREG=0", 10) 
				&&  */strncmp(iface_ctx.latest_cmd.cmd,"AT&V", 4)
				/* && strncmp(iface_ctx.latest_cmd.cmd,"AT&W", 4) */)
				// hl7812_rx_callback(msg, len);
				printk("%s\n",msg);
			}
			if (remove_line_from_buf && frag && rx_buf) {
				/* clear out processed line (buffers) */
				net_buf_remove(&rx_buf, len);
			}
		}

		if (unlock) {
			hl7812_RX_unlock();
		}

		/* give up time if we have a solid stream of data */
		k_yield();
	}
}


static void hl7812_serial_serial_vgpio_work_cb(struct k_work *item)
{
	ARG_UNUSED(item);

	hl7812_lock();
	if (!iface_ctx.vgpio_state) {
	
	}
	hl7812_unlock();
}

void hl7812_serial_serial_vgpio_callback_isr(const struct device *port, struct gpio_callback *cb,
			    uint32_t pins)
{
	iface_ctx.vgpio_state = read_pin(1, &hl7812_cfg.gpio[MDM_VGPIO]);
	HL7812_IO_DBG_LOG("VGPIO:%d", iface_ctx.vgpio_state);
	if (!iface_ctx.vgpio_state) {
		prepare_io_for_reset();
		if (!iface_ctx.restarting && iface_ctx.initialized) {

		}
	} else {
		if (iface_ctx.off) {
			return;
		}
		/* The peripheral must be enabled in ISR context
		 * because the driver may be
		 * waiting for +KSUP or waiting to send commands.
		 * This can occur, for example, during a modem reset.
		 */
	}

	/* When the network state changes a semaphore must be taken.
	 * This can't be done in interrupt context because the wait time != 0.
	 */
	k_work_submit_to_queue(&hl7812_workq, &iface_ctx.hl7812_serial_vgpio_work);
}

void hl7812_serial_serial_uart_dsr_callback_isr(const struct device *port,
			       struct gpio_callback *cb, uint32_t pins)
{
	iface_ctx.dsr_state = read_pin(1, &hl7812_cfg.gpio[MDM_UART_DSR]);
	HL7812_IO_DBG_LOG("MDM_UART_DSR:%d", iface_ctx.dsr_state);
}

void hl7812_serial_serial_gpio6_callback_isr(const struct device *port, struct gpio_callback *cb,
			    uint32_t pins)
{
	HL7812_IO_DBG_LOG("Spurious gpio6 interrupt from the modem");
}

/**
 * @brief Short spikes in CTS can be removed in the signal used by the application
 */
static int glitch_filter(int default_state, const struct gpio_dt_spec *spec,
			 uint32_t usec_to_wait, uint32_t max_iterations)
{
	int i = 0;
	int state1;
	int state2;

	do {
		state1 = read_pin(-1, spec);
		k_busy_wait(usec_to_wait);
		state2 = read_pin(-1, spec);
		i += 1;
	} while (((state1 != state2) || (state1 < 0) || (state2 < 0)) && (i < max_iterations));

	if (i >= max_iterations) {
		LOG_WRN("glitch filter max iterations exceeded %d", i);
		if (state1 < 0) {
			if (state2 < 0) {
				state1 = read_pin(default_state, spec);
			} else {
				state1 = state2;
			}
		}
	}

	return state1;
}
void hl7812_serial_serial_uart_cts_callback(const struct device *port, struct gpio_callback *cb, uint32_t pins)
{
	ARG_UNUSED(port);
	ARG_UNUSED(cb);
	ARG_UNUSED(pins);

	iface_ctx.cts_state =
		glitch_filter(0, &hl7812_cfg.gpio[MDM_UART_CTS],
			      CONFIG_MODEM_HL7812_CUSTOM_CTS_FILTER_US,
			      CONFIG_MODEM_HL7812_CUSTOM_CTS_FILTER_MAX_ITERATIONS);

	/* CTS toggles A LOT,
	 * comment out the debug print unless we really need it.
	 */
	/* HL7812_IO_DBG_LOG("MDM_UART_CTS:%d", iface_ctx.cts_state); */

	if ((iface_ctx.cts_callback != NULL)) {
		iface_ctx.cts_callback(iface_ctx.cts_state);
	}
}

static void modem_reset(void)
{
	prepare_io_for_reset();

	LOG_DBG("Modem Reset");
	/* Hard reset the modem */
	gpio_pin_set_dt(&hl7812_cfg.gpio[MDM_RESET], 1);
	/* >20 milliseconds required for reset low */
	k_sleep(MDM_RESET_LOW_TIME);

	iface_ctx.hl7812_serial_startup_reporting_on = false;
	set_startup_state(HL7812_STARTUP_STATE_UNKNOWN);
	k_sem_reset(&iface_ctx.hl7812_serial_awake);
	iface_ctx.off = true;
}

static void modem_run(void)
{
	LOG_DBG("Modem Run");
	gpio_pin_set_dt(&hl7812_cfg.gpio[MDM_RESET], 0);
	k_sleep(MDM_RESET_HIGH_TIME);
	iface_ctx.off = false;
}

static int modem_boot_handler(char *reason)
{
	int ret = 0;

	LOG_DBG("Boot reason: %s", reason);
	ret = k_sem_take(&iface_ctx.hl7812_serial_awake, MDM_BOOT_TIME);

	if (ret) {
		LOG_ERR("Err waiting for boot: %d, DSR: %u", ret,
			iface_ctx.dsr_state);
		return -1;
	} else {
		LOG_DBG("Modem booted! AT Client is ready!");
	}
	/* Turn OFF EPS network registration status reporting because
	 * it isn't needed until after initialization is complete.
	 */
	send_at_cmd("AT+CEREG=0", MDM_CMD_SEND_TIMEOUT, MDM_DEFAULT_AT_CMD_RETRIES, false);

	/* Determine if echo is on/off by reading the profile
	 * note: It wasn't clear how to read the
	 * active profile so all 3 are read.
	 */
	iface_ctx.hl7812_serial_echo_is_on = true;
	send_at_cmd("AT&V", MDM_CMD_SEND_TIMEOUT, MDM_DEFAULT_AT_CMD_RETRIES, false);

	if (iface_ctx.hl7812_serial_echo_is_on) {
		/* Turn OFF echo (after boot/reset) because a profile
		 * hasn't been saved yet
		 */
		send_at_cmd("ATE0", MDM_CMD_SEND_TIMEOUT, MDM_DEFAULT_AT_CMD_RETRIES, false);

		/* Save profile 0 */
		send_at_cmd("AT&W", MDM_CMD_SEND_TIMEOUT, MDM_DEFAULT_AT_CMD_RETRIES, false);
	}
	return ret;
}

static int modem_reset_and_configure(void)
{
	int ret = 0;

	iface_ctx.restarting = true;
	modem_reset();
	modem_run();
	ret = modem_boot_handler("Initialization");
	if (ret < 0) {
		goto error;
	}
	/* The modem has been initialized and now the network interface can be
	 * started in the CEREG message handler.
	 */
	LOG_DBG("Modem ready!");
	iface_ctx.restarting = false;
	iface_ctx.configured = true;
	return 0;

error:
	LOG_ERR("Unable to configure modem");
	iface_ctx.configured = false;
	/* Kernel will fault with non-zero return value.
	 * Allow other parts of application to run when modem cannot be configured.
	 */
	return 0;
}

/**
 * @brief  Finds receiver context which manages provided device.
 *
 * @param  dev: device used by the receiver context.
 *
 * @retval Receiver context or NULL.
 */
static struct hl_receiver_context *context_from_dev(const struct device *dev)
{
	int i;

	for (i = 0; i < MAX_MDM_CTX; i++) {
		if (contexts[i] && contexts[i]->uart_dev == dev) {
			return contexts[i];
		}
	}

	return NULL;
}

/**
 * @brief  Persists receiver context if there is a free place.
 *
 * @note   Amount of stored receiver contexts is determined by
 *         MAX_MDM_CTX.
 *
 * @param  ctx: receiver context to persist.
 *
 * @retval 0 if ok, < 0 if error.
 */
static int hl7812_serial_receiver_get(struct hl_receiver_context *ctx)
{
	int i;

	for (i = 0; i < MAX_MDM_CTX; i++) {
		if (!contexts[i]) {
			contexts[i] = ctx;
			return 0;
		}
	}

	return -ENOMEM;
}
/**
 * @brief  Drains UART.
 *
 * @note   Discards remaining data.
 *
 * @param  ctx: receiver context.
 *
 * @retval None.
 */
static void hl7812_serial_receiver_flush(struct hl_receiver_context *ctx)
{
	uint8_t c;

	__ASSERT(ctx, "invalid ctx");
	__ASSERT(ctx->uart_dev, "invalid ctx device");

	while (uart_fifo_read(ctx->uart_dev, &c, 1) > 0) {
		continue;
	}
}
/**
 * @brief  Receiver UART interrupt handler.
 *
 * @note   Fills contexts ring buffer with received data.
 *         When ring buffer is full the data is discarded.
 *
 * @param  uart_dev: uart device.
 *
 * @retval None.
 */
#define MAX_READ_SIZE 128
static void hl7812_serial_receiver_isr(const struct device *uart_dev, void *user_data)
{
	struct hl_receiver_context *ctx;
	int rx, ret;
	static uint8_t read_buf[MAX_READ_SIZE];

	ARG_UNUSED(user_data);

	/* lookup the device */
	ctx = context_from_dev(uart_dev);
	if (!ctx) {
		return;
	}

	/* get all of the data off UART as fast as we can */
	while (uart_irq_update(ctx->uart_dev) &&
	       uart_irq_rx_ready(ctx->uart_dev)) {
		rx = uart_fifo_read(ctx->uart_dev, read_buf, sizeof(read_buf));
		if (rx > 0) {
			ret = ring_buf_put(&ctx->rx_rb, read_buf, rx);
			if (ret != rx) {
				LOG_ERR("Rx buffer doesn't have enough space. "
						"Bytes pending: %d, written: %d",
						rx, ret);
				hl7812_serial_receiver_flush(ctx);
				k_sem_give(&ctx->rx_sem);
				break;
			}
			k_sem_give(&ctx->rx_sem);
		}
	}
}

static int uart_receiver_setup(struct hl_receiver_context *ctx, const struct device *uart_dev, uint8_t *buf, size_t size)
{
	int ret;

	if ((size == 0)) {
		return -EINVAL;
	}

	if (!device_is_ready(uart_dev)) {
		LOG_ERR("Device is not ready: %s",
			uart_dev ? uart_dev->name : "<null>");
		return -ENODEV;
	}

	ctx->uart_dev = uart_dev;
	ring_buf_init(&ctx->rx_rb, size, buf);
	k_sem_init(&ctx->rx_sem, 0, 1);

	ret = hl7812_serial_receiver_get(ctx);
	if (ret < 0) {
		return ret;
	}

	__ASSERT(ctx, "invalid ctx");

	uart_irq_rx_disable(ctx->uart_dev);
	uart_irq_tx_disable(ctx->uart_dev);
	hl7812_serial_receiver_flush(ctx);
	uart_irq_callback_set(ctx->uart_dev, hl7812_serial_receiver_isr);
	uart_irq_rx_enable(ctx->uart_dev);

	return 0;
}
static int hl7812_serial_init(void)
// int hl7812_init(void)
{
	int i, ret = 0;
	struct k_work_queue_config cfg = {
		.name = "hl7812_workq",
	};
	// LOG_INF("AT Client is getting ready...");
	printk("AT Client is getting ready...\n");
	/* Prevent the network interface from starting until
	 * the modem has been initialized
	 * because the modem may not have a valid SIM card.
	 */
	k_sem_init(&iface_ctx.response_sem, 0, 1);
	k_sem_init(&iface_ctx.hl7812_serial_awake, 0, 1);

	/* initialize the work queue */
	k_work_queue_start(&hl7812_workq, hl7812_workq_stack_serial,
			   K_THREAD_STACK_SIZEOF(hl7812_workq_stack_serial),
			   WORKQ_PRIORITY, &cfg);
	/* init work tasks */
	k_work_init(&iface_ctx.hl7812_serial_vgpio_work, hl7812_serial_serial_vgpio_work_cb);
	k_work_init_delayable(&iface_ctx.hl7812_serial_reset_work, hl7812_serial_reset_work_callback);
	k_work_init(&iface_ctx.hl7812_serial_pwr_off_work, hl7812_serial_power_off_work_callback);

	/* setup port devices and pin directions */
	for (i = 0; i < MAX_MDM_CONTROL_PINS; i++) {
		if (!gpio_is_ready_dt(&hl7812_cfg.gpio[i])) {
			LOG_ERR("gpio port (%s) not ready!",
				hl7812_cfg.gpio[i].port->name);
			return -ENODEV;
		}
	}
	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_RESET], GPIO_OUTPUT);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_RESET %d err: %d!",
			hl7812_cfg.gpio[MDM_RESET].pin, ret);
		return ret;
	}

	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_WAKE], GPIO_OUTPUT_ACTIVE);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_WAKE %d err: %d!",
			hl7812_cfg.gpio[MDM_WAKE].pin, ret);
		return ret;
	}

	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_PWR_ON], GPIO_OUTPUT);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_PWR_ON %d err: %d!",
			hl7812_cfg.gpio[MDM_PWR_ON].pin, ret);
		return ret;
	}

	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_FAST_SHUTD], GPIO_OUTPUT);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_FAST_SHUTD %d err: %d!",
			hl7812_cfg.gpio[MDM_FAST_SHUTD].pin, ret);
		return ret;
	}

	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_VGPIO], GPIO_INPUT);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_VGPIO %d err: %d!",
			hl7812_cfg.gpio[MDM_VGPIO].pin, ret);
		return ret;
	}

	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_UART_DSR], GPIO_INPUT);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_UART_DSR %d err: %d!",
			hl7812_cfg.gpio[MDM_UART_DSR].pin, ret);
		return ret;
	}

	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_UART_CTS], GPIO_INPUT);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_UART_CTS %d err: %d!",
			hl7812_cfg.gpio[MDM_UART_CTS].pin, ret);
		return ret;
	}

	ret = gpio_pin_configure_dt(&hl7812_cfg.gpio[MDM_GPIO6], GPIO_INPUT);
	if (ret) {
		LOG_ERR("Error configuring IO MDM_GPIO6 %d err: %d!",
			hl7812_cfg.gpio[MDM_GPIO6].pin, ret);
		return ret;
	}

	/* when this driver starts, the UART peripheral is already enabled */
	iface_ctx.uart_on = true;

	modem_assert_wake(false);
	modem_assert_pwr_on(false);
	modem_assert_fast_shutd(false);

	/* Allow modem to run so we are in a known state.
	 * This allows HL7812 VGPIO to be high, which is good because the UART
	 * IO are already configured.
	 */
	modem_run();
	/* setup input pin callbacks */
	/* VGPIO */
	gpio_init_callback(&iface_ctx.hl7812_serial_vgpio_cb, hl7812_serial_serial_vgpio_callback_isr,
			   BIT(hl7812_cfg.gpio[MDM_VGPIO].pin));
	ret = gpio_add_callback(hl7812_cfg.gpio[MDM_VGPIO].port,
				&iface_ctx.hl7812_serial_vgpio_cb);
	if (ret) {
		LOG_ERR("Cannot setup vgpio callback! (%d)", ret);
		return ret;
	}
	ret = gpio_pin_interrupt_configure_dt(&hl7812_cfg.gpio[MDM_VGPIO], GPIO_INT_EDGE_BOTH);
	if (ret) {
		LOG_ERR("Error config vgpio interrupt! (%d)", ret);
		return ret;
	}

	/* UART DSR */
	gpio_init_callback(&iface_ctx.hl7812_serial_uart_dsr_cb, hl7812_serial_serial_uart_dsr_callback_isr,
			   BIT(hl7812_cfg.gpio[MDM_UART_DSR].pin));
	ret = gpio_add_callback(hl7812_cfg.gpio[MDM_UART_DSR].port,
				&iface_ctx.hl7812_serial_uart_dsr_cb);
	if (ret) {
		LOG_ERR("Cannot setup uart dsr callback! (%d)", ret);
		return ret;
	}
	ret = gpio_pin_interrupt_configure_dt(&hl7812_cfg.gpio[MDM_UART_DSR], GPIO_INT_EDGE_BOTH);
	if (ret) {
		LOG_ERR("Error config uart dsr interrupt! (%d)", ret);
		return ret;
	}

	/* GPIO6 */
	gpio_init_callback(&iface_ctx.hl7812_serial_gpio6_cb, hl7812_serial_serial_gpio6_callback_isr,
			   BIT(hl7812_cfg.gpio[MDM_GPIO6].pin));
	ret = gpio_add_callback(hl7812_cfg.gpio[MDM_GPIO6].port,
				&iface_ctx.hl7812_serial_gpio6_cb);
	if (ret) {
		LOG_ERR("Cannot setup gpio6 callback! (%d)", ret);
		return ret;
	}
	ret = gpio_pin_interrupt_configure_dt(&hl7812_cfg.gpio[MDM_GPIO6], GPIO_INT_EDGE_BOTH);
	if (ret) {
		LOG_ERR("Error config gpio6 interrupt! (%d)", ret);
		return ret;
	}

	/* UART CTS */
	gpio_init_callback(&iface_ctx.hl7812_serial_uart_cts_cb, hl7812_serial_serial_uart_cts_callback,
			   BIT(hl7812_cfg.gpio[MDM_UART_CTS].pin));
	ret = gpio_add_callback(hl7812_cfg.gpio[MDM_UART_CTS].port,
				&iface_ctx.hl7812_serial_uart_cts_cb);
	if (ret) {
		LOG_ERR("Cannot setup uart cts callback! (%d)", ret);
		return ret;
	}
	ret = gpio_pin_interrupt_configure_dt(&hl7812_cfg.gpio[MDM_UART_CTS], GPIO_INT_EDGE_BOTH);
	if (ret) {
		LOG_ERR("Error config uart cts interrupt! (%d)", ret);
		return ret;
	}
	ret = uart_receiver_setup(&iface_ctx.hl7812_serial_ctx, MDM_UART_DEV,
				    hl7812_serial_recv_buf, sizeof(hl7812_serial_recv_buf));
	if (ret < 0) {
		LOG_ERR("Error registering modem receiver (%d)!", ret);
		return ret;
	}

	/* start RX thread */
	k_thread_name_set(
		k_thread_create(&hl7812_rx_thread_serial, hl7812_rx_stack_serial,
				K_THREAD_STACK_SIZEOF(hl7812_rx_stack_serial),
				(k_thread_entry_t)hl7812_rx, NULL, NULL, NULL,
				RX_THREAD_PRIORITY, 0, K_NO_WAIT),
		"hl7812 rx");

	LOG_DBG("MODE-RESTARTING & CONFIGURING...");
	ret = modem_reset_and_configure();

	return ret;
}

SYS_INIT(hl7812_serial_init, APPLICATION, 0);

[zafersn]

update-------------

I just tested this issue with up to date hl7800 modem driver here and still have the same issue,

just enabling these configs:

CONFIG_PM=y
CONFIG_PM_DEVICE=y
CONFIG_PM_DEVICE_RUNTIME=y

strangely, I have different behaviour depending on having printk or not.
I just put some printk to see where i was stuck and the app worked till the second time came in the same func.

if i dont put any printk the app is stuck here in the modem_run func at first hit.
modem_run();

[00:00:00.000,000] <dbg> modem_hl7800: hl7800_init: HL7800 Init
[00:00:00.000,000] <inf> modem_hl7800: Modem Run

If I put printk the app is stuck here: in modem_run

[00:00:00.000,000] <dbg> modem_hl7800: hl7800_init: HL7800 Init
1----111
[00:00:00.000,000] <inf> modem_hl7800: Modem Run
11111111
222222
3333333
44444444
2------222222
3------3333
[00:00:00.010,000] <inf> modem_hl7800: Modem Reset
[00:00:00.060,000] <inf> modem_hl7800: Sleep State: UNINITIALIZED
[00:00:00.060,000] <inf> modem_hl7800: Network State: 0 NOT_REGISTERED
[00:00:00.060,000] <inf> modem_hl7800: Startup State: UNKNOWN
[00:00:00.060,000] <inf> modem_hl7800: FOTA state: IDLE->IDLE
4-----4444
[00:00:00.060,000] <inf> modem_hl7800: Modem Run
11111111
222222
3333333

static void modem_run(void)
{
	LOG_INF("Modem Run");
	iface_ctx.off = false;
	printk("11111111\n");
	modem_assert_reset(false);
	printk("222222\n");
	allow_sleep(false);
	printk("3333333\n");
	k_sleep(MDM_RESET_HIGH_TIME);
	printk("44444444\n");
}

reboot:
	printk("3------3333\n");
	modem_reset();
	printk("4-----4444\n");
	modem_run();
	printk("5--------55555\n");
	ret = modem_boot_handler("Initialization");
	printk("6-----66666666\n");

[GeorgeCGV]

@zafersn I am not familiar with PM sub-system.

However, did you try to run with enabled asserts in the system?

CONFIG_ASSERT=y
CONFIG_USE_STM32_ASSERT=y

[zafersn]

there is no error output or any assertion failure, it is just stuck, which makes debugging harder for me. Were you able to see my latest comment for Nordicjm? #66357 (reply in thread)
even when I enable pm, it is stuck in delays, so I suspect a conflict between timers and pm.

[erwango]

Did you enable LPTIM node in board device tree ?

[zafersn]

It was not enabled, i just tried to enable it by adding this:

stm32_lp_tick_source: &lptim1 {
	status = "okay";
};

but had this error: multiple definitions of sys_clock_set_timeout'; `

FAILED: zephyr/zephyr_pre0.elf zephyr/zephyr_pre0.map C:/customproject/wsc/hl7812/build/zephyr/zephyr_pre0.map 
cmd.exe /C "cd . && C:\customproject\zephyr-sdk-0.16.3\arm-zephyr-eabi\bin\arm-zephyr-eabi-gcc.exe  -gdwarf-4 @CMakeFiles\zephyr_pre0.rsp -o zephyr\zephyr_pre0.elf  && cmd.exe /C "cd /D C:\customproject\wsc\hl7812\build\zephyr && "C:\Program Files\CMake\bin\cmake.exe" -E true""
c:/customproject/zephyr-sdk-0.16.3/arm-zephyr-eabi/bin/../lib/gcc/arm-zephyr-eabi/12.2.0/../../../../arm-zephyr-eabi/bin/ld.bfd.exe: zephyr/drivers/timer/libdrivers__timer.a(stm32_lptim_timer.c.obj): in function `sys_clock_set_timeout':
C:/customproject/zephyr/drivers/timer/stm32_lptim_timer.c:179: multiple definition of `sys_clock_set_timeout'; zephyr/drivers/timer/libdrivers__timer.a(cortex_m_systick.c.obj):C:/customproject/zephyr/drivers/timer/cortex_m_systick.c:186: first defined here
c:/customproject/zephyr-sdk-0.16.3/arm-zephyr-eabi/bin/../lib/gcc/arm-zephyr-eabi/12.2.0/../../../../arm-zephyr-eabi/bin/ld.bfd.exe: zephyr/drivers/timer/libdrivers__timer.a(stm32_lptim_timer.c.obj): in function `sys_clock_elapsed':
C:/customproject/zephyr/drivers/timer/stm32_lptim_timer.c:280: multiple definition of `sys_clock_elapsed'; zephyr/drivers/timer/libdrivers__timer.a(cortex_m_systick.c.obj):C:/customproject/zephyr/drivers/timer/cortex_m_systick.c:267: first defined here
c:/customproject/zephyr-sdk-0.16.3/arm-zephyr-eabi/bin/../lib/gcc/arm-zephyr-eabi/12.2.0/../../../../arm-zephyr-eabi/bin/ld.bfd.exe: zephyr/drivers/timer/libdrivers__timer.a(stm32_lptim_timer.c.obj): in function `sys_clock_cycle_get_32':

C:/customproject/zephyr/drivers/timer/stm32_lptim_timer.c:300: multiple definition of `sys_clock_cycle_get_32'; zephyr/drivers/timer/libdrivers__timer.a(cortex_m_systick.c.obj):C:/customproject/zephyr/drivers/timer/cortex_m_systick.c:281: first defined here

[erwango]

This is happens because you're also compiling cortex systick driver.
This is odd because when lptim and PM are enabled th cortex_systick should not be compiled in current state of the tree.
See https://github.com/zephyrproject-rtos/zephyr/blob/main/soc/arm/st_stm32/common/Kconfig.defconfig.series#L10
It's strange that you're facing such issue.

[zafersn]

@erwango thank you so much. That's it, sir, it solved my problem,

[nordicjm]

That driver uses edge interrupts, have you checked to ensure that your MCU supports this type of interrupt?

[zafersn]

Hi @nordicjm, thanks for your reply, I don't think the problem is because of that Sir. because the modem driver works well if I dont enable config_pms*

I recently added my project regulator enable/disable even before ret = k_sem_take(&iface_ctx.hl7800_serial_awake, MDM_BOOT_TIME); at the beginning of the driver initialisation before enabling config_pm* again. now to share some log outputs with you, I enabled PMs and noticed now i am getting the error in the regulator enable here too for k_sleep. the app is stuck in the k_sleep

print outputs:

WEST_TOPDIR/zephyr/drivers/regulator/regulator_fixed.c 38
WEST_TOPDIR/zephyr/drivers/regulator/regulator_fixed.c 43
WEST_TOPDIR/zephyr/drivers/regulator/regulator_fixed.c 45

it seems there is a conflict between timers and PMs, what do you think?