modem: optional dedicated workqueue

JordanYates · JordanYates · commit de3ae8033465 · 2025-10-05T18:23:45.000+10:00
Add the option to use a dedicated workqueue for the modem backend
instead of the system workqueue.

Signed-off-by: Jordan Yates &lt;jordan@embeint.com&gt;
diff --git a/doc/releases/release-notes-4.3.rst b/doc/releases/release-notes-4.3.rst
@@ -183,6 +183,10 @@ New APIs and options
 
     * :kconfig:option:`CONFIG_HAWKBIT_REBOOT_NONE`
 
+* Modem
+
+  * :kconfig:option:`CONFIG_MODEM_DEDICATED_WORKQUEUE`
+
 * Networking
 
   * Sockets
diff --git a/subsys/modem/CMakeLists.txt b/subsys/modem/CMakeLists.txt
@@ -5,6 +5,7 @@ if(CONFIG_MODEM_MODULES)
 
 zephyr_library()
 
+zephyr_library_sources_ifdef(CONFIG_MODEM_DEDICATED_WORKQUEUE modem_workqueue.c)
 zephyr_library_sources_ifdef(CONFIG_MODEM_CHAT modem_chat.c)
 zephyr_library_sources_ifdef(CONFIG_MODEM_CMUX modem_cmux.c)
 zephyr_library_sources_ifdef(CONFIG_MODEM_PIPE modem_pipe.c)
diff --git a/subsys/modem/Kconfig b/subsys/modem/Kconfig
@@ -6,6 +6,21 @@ menuconfig MODEM_MODULES
 
 if MODEM_MODULES
 
+config MODEM_DEDICATED_WORKQUEUE
+	bool "Use a dedicated workqueue for modem operations"
+
+if MODEM_DEDICATED_WORKQUEUE
+
+config MODEM_DEDICATED_WORKQUEUE_STACK_SIZE
+	int "Modem dedicated workqueue stack size"
+	default 1024
+
+config MODEM_DEDICATED_WORKQUEUE_PRIORITY
+	int "Modem dedicated workqueue priority"
+	default SYSTEM_WORKQUEUE_PRIORITY
+
+endif # MODEM_DEDICATED_WORKQUEUE
+
 config MODEM_CHAT
 	bool "Modem chat module"
 	select RING_BUFFER
diff --git a/subsys/modem/backends/modem_backend_uart_async.c b/subsys/modem/backends/modem_backend_uart_async.c
@@ -5,6 +5,7 @@
  */
 
 #include "modem_backend_uart_async.h"
+#include "../modem_workqueue.h"
 
 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(modem_backend_uart_async, CONFIG_MODEM_MODULES_LOG_LEVEL);
@@ -58,7 +59,7 @@ static void modem_backend_uart_async_event_handler(const struct device *dev,
 	case UART_TX_DONE:
 		atomic_clear_bit(&backend->async.common.state,
 				 MODEM_BACKEND_UART_ASYNC_STATE_TRANSMITTING_BIT);
-		k_work_submit(&backend->transmit_idle_work);
+		modem_work_submit(&backend->transmit_idle_work);
 		break;
 
 	case UART_TX_ABORTED:
@@ -67,7 +68,7 @@ static void modem_backend_uart_async_event_handler(const struct device *dev,
 		}
 		atomic_clear_bit(&backend->async.common.state,
 				 MODEM_BACKEND_UART_ASYNC_STATE_TRANSMITTING_BIT);
-		k_work_submit(&backend->transmit_idle_work);
+		modem_work_submit(&backend->transmit_idle_work);
 
 		break;
 
@@ -127,7 +128,7 @@ static void modem_backend_uart_async_event_handler(const struct device *dev,
 		}
 
 		k_spin_unlock(&backend->async.receive_rb_lock, key);
-		k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
+		modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
 		break;
 
 	case UART_RX_DISABLED:
@@ -144,7 +145,7 @@ static void modem_backend_uart_async_event_handler(const struct device *dev,
 	}
 
 	if (modem_backend_uart_async_is_uart_stopped(backend)) {
-		k_work_submit(&backend->async.common.rx_disabled_work);
+		modem_work_submit(&backend->async.common.rx_disabled_work);
 	}
 }
 
@@ -254,7 +255,7 @@ static int modem_backend_uart_async_receive(void *data, uint8_t *buf, size_t siz
 	k_spin_unlock(&backend->async.receive_rb_lock, key);
 
 	if (!empty) {
-		k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
+		modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
 	}
 
 	return (int)received;
diff --git a/subsys/modem/backends/modem_backend_uart_async_hwfc.c b/subsys/modem/backends/modem_backend_uart_async_hwfc.c
@@ -5,6 +5,7 @@
  */
 
 #include "modem_backend_uart_async.h"
+#include "../modem_workqueue.h"
 
 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(modem_backend_uart_async_hwfc, CONFIG_MODEM_MODULES_LOG_LEVEL);
@@ -136,7 +137,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev
 	case UART_TX_DONE:
 		atomic_clear_bit(&backend->async.common.state,
 				 MODEM_BACKEND_UART_ASYNC_STATE_TRANSMIT_BIT);
-		k_work_submit(&backend->transmit_idle_work);
+		modem_work_submit(&backend->transmit_idle_work);
 		break;
 
 	case UART_TX_ABORTED:
@@ -145,7 +146,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev
 		}
 		atomic_clear_bit(&backend->async.common.state,
 				 MODEM_BACKEND_UART_ASYNC_STATE_TRANSMIT_BIT);
-		k_work_submit(&backend->transmit_idle_work);
+		modem_work_submit(&backend->transmit_idle_work);
 
 		break;
 
@@ -182,7 +183,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev
 				rx_buf_unref(&backend->async, evt->data.rx.buf);
 				break;
 			}
-			k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
+			modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
 		}
 		break;
 
@@ -191,7 +192,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev
 				    MODEM_BACKEND_UART_ASYNC_STATE_OPEN_BIT)) {
 			if (!atomic_test_and_set_bit(&backend->async.common.state,
 						     MODEM_BACKEND_UART_ASYNC_STATE_RECOVERY_BIT)) {
-				k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
+				modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
 				LOG_DBG("RX recovery started");
 			}
 		}
@@ -206,7 +207,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev
 	}
 
 	if (modem_backend_uart_async_hwfc_is_uart_stopped(backend)) {
-		k_work_submit(&backend->async.common.rx_disabled_work);
+		modem_work_submit(&backend->async.common.rx_disabled_work);
 	}
 }
 
@@ -335,7 +336,7 @@ static int modem_backend_uart_async_hwfc_receive(void *data, uint8_t *buf, size_
 
 	if (backend->async.rx_event.len != 0 ||
 	    k_msgq_num_used_get(&backend->async.rx_queue) != 0) {
-		k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
+		modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);
 	}
 
 	modem_backend_uart_async_hwfc_rx_recovery(backend);
diff --git a/subsys/modem/backends/modem_backend_uart_isr.c b/subsys/modem/backends/modem_backend_uart_isr.c
@@ -5,6 +5,7 @@
  */
 
 #include "modem_backend_uart_isr.h"
+#include "../modem_workqueue.h"
 
 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(modem_backend_uart_isr, CONFIG_MODEM_MODULES_LOG_LEVEL);
@@ -54,11 +55,11 @@ static void modem_backend_uart_isr_irq_handler_receive_ready(struct modem_backen
 		 * It temporarily disables the UART RX IRQ when swapping buffers
 		 * which can cause byte loss at higher baud rates.
 		 */
-		k_work_schedule(&backend->receive_ready_work,
-			K_MSEC(CONFIG_MODEM_BACKEND_UART_ISR_RECEIVE_IDLE_TIMEOUT_MS));
+		modem_work_schedule(&backend->receive_ready_work,
+				    K_MSEC(CONFIG_MODEM_BACKEND_UART_ISR_RECEIVE_IDLE_TIMEOUT_MS));
 	} else {
 		/* The buffer is getting full. Run the work item immediately to free up space. */
-		k_work_reschedule(&backend->receive_ready_work, K_NO_WAIT);
+		modem_work_reschedule(&backend->receive_ready_work, K_NO_WAIT);
 	}
 }
 
@@ -70,7 +71,7 @@ static void modem_backend_uart_isr_irq_handler_transmit_ready(struct modem_backe
 
 	if (ring_buf_is_empty(&backend->isr.transmit_rb) == true) {
 		uart_irq_tx_disable(backend->uart);
-		k_work_submit(&backend->transmit_idle_work);
+		modem_work_submit(&backend->transmit_idle_work);
 		return;
 	}
 
diff --git a/subsys/modem/modem_chat.c b/subsys/modem/modem_chat.c
@@ -15,6 +15,8 @@ LOG_MODULE_REGISTER(modem_chat, CONFIG_MODEM_MODULES_LOG_LEVEL);
 
 #include <zephyr/modem/chat.h>
 
+#include "modem_workqueue.h"
+
 const struct modem_chat_match modem_chat_any_match = MODEM_CHAT_MATCH("", "", NULL);
 const struct modem_chat_match modem_chat_empty_matches[0];
 const struct modem_chat_script_chat modem_chat_empty_script_chats[0];
@@ -127,7 +129,7 @@ static void modem_chat_set_script_send_state(struct modem_chat *chat,
 static void modem_chat_script_send(struct modem_chat *chat)
 {
 	modem_chat_set_script_send_state(chat, MODEM_CHAT_SCRIPT_SEND_STATE_REQUEST);
-	k_work_submit(&chat->script_send_work);
+	modem_work_submit(&chat->script_send_work);
 }
 
 static void modem_chat_script_set_response_matches(struct modem_chat *chat)
@@ -178,7 +180,7 @@ static void modem_chat_script_chat_schedule_send_timeout(struct modem_chat *chat
 {
 	uint16_t timeout = modem_chat_script_chat_get_send_timeout(chat);
 
-	k_work_schedule(&chat->script_send_timeout_work, K_MSEC(timeout));
+	modem_work_schedule(&chat->script_send_timeout_work, K_MSEC(timeout));
 }
 
 static void modem_chat_script_next(struct modem_chat *chat, bool initial)
@@ -233,7 +235,7 @@ static void modem_chat_script_start(struct modem_chat *chat, const struct modem_
 
 	/* Start timeout work if script started */
 	if (chat->script != NULL) {
-		k_work_schedule(&chat->script_timeout_work, K_SECONDS(chat->script->timeout));
+		modem_work_schedule(&chat->script_timeout_work, K_SECONDS(chat->script->timeout));
 	}
 }
 
@@ -742,7 +744,7 @@ static void modem_chat_process_handler(struct k_work *item)
 
 	/* Process data */
 	modem_chat_process_bytes(chat);
-	k_work_submit(&chat->receive_work);
+	modem_work_submit(&chat->receive_work);
 }
 
 static void modem_chat_pipe_callback(struct modem_pipe *pipe, enum modem_pipe_event event,
@@ -752,11 +754,11 @@ static void modem_chat_pipe_callback(struct modem_pipe *pipe, enum modem_pipe_ev
 
 	switch (event) {
 	case MODEM_PIPE_EVENT_RECEIVE_READY:
-		k_work_submit(&chat->receive_work);
+		modem_work_submit(&chat->receive_work);
 		break;
 
 	case MODEM_PIPE_EVENT_TRANSMIT_IDLE:
-		k_work_submit(&chat->script_send_work);
+		modem_work_submit(&chat->script_send_work);
 		break;
 
 	default:
@@ -880,7 +882,7 @@ int modem_chat_run_script_async(struct modem_chat *chat, const struct modem_chat
 	k_sem_reset(&chat->script_stopped_sem);
 
 	chat->pending_script = script;
-	k_work_submit(&chat->script_run_work);
+	modem_work_submit(&chat->script_run_work);
 	return 0;
 }
 
@@ -903,7 +905,7 @@ int modem_chat_run_script(struct modem_chat *chat, const struct modem_chat_scrip
 
 void modem_chat_script_abort(struct modem_chat *chat)
 {
-	k_work_submit(&chat->script_abort_work);
+	modem_work_submit(&chat->script_abort_work);
 }
 
 void modem_chat_release(struct modem_chat *chat)
diff --git a/subsys/modem/modem_cmux.c b/subsys/modem/modem_cmux.c
@@ -13,6 +13,8 @@ LOG_MODULE_REGISTER(modem_cmux, CONFIG_MODEM_CMUX_LOG_LEVEL);
 
 #include <string.h>
 
+#include "modem_workqueue.h"
+
 #define MODEM_CMUX_SOF				(0xF9)
 #define MODEM_CMUX_FCS_POLYNOMIAL		(0xE0)
 #define MODEM_CMUX_FCS_INIT_VALUE		(0xFF)
@@ -257,11 +259,11 @@ static void modem_cmux_bus_callback(struct modem_pipe *pipe, enum modem_pipe_eve
 
 	switch (event) {
 	case MODEM_PIPE_EVENT_RECEIVE_READY:
-		k_work_schedule(&cmux->receive_work, K_NO_WAIT);
+		modem_work_schedule(&cmux->receive_work, K_NO_WAIT);
 		break;
 
 	case MODEM_PIPE_EVENT_TRANSMIT_IDLE:
-		k_work_schedule(&cmux->transmit_work, K_NO_WAIT);
+		modem_work_schedule(&cmux->transmit_work, K_NO_WAIT);
 		break;
 
 	default:
@@ -321,7 +323,7 @@ static uint16_t modem_cmux_transmit_frame(struct modem_cmux *cmux,
 	buf[0] = fcs;
 	buf[1] = MODEM_CMUX_SOF;
 	ring_buf_put(&cmux->transmit_rb, buf, 2);
-	k_work_schedule(&cmux->transmit_work, K_NO_WAIT);
+	modem_work_schedule(&cmux->transmit_work, K_NO_WAIT);
 	return data_len;
 }
 
@@ -940,7 +942,7 @@ static void modem_cmux_receive_handler(struct k_work *item)
 	}
 
 	/* Reschedule received work */
-	k_work_schedule(&cmux->receive_work, K_NO_WAIT);
+	modem_work_schedule(&cmux->receive_work, K_NO_WAIT);
 }
 
 static void modem_cmux_dlci_notify_transmit_idle(struct modem_cmux *cmux)
@@ -1027,7 +1029,7 @@ static void modem_cmux_connect_handler(struct k_work *item)
 	};
 
 	modem_cmux_transmit_cmd_frame(cmux, &frame);
-	k_work_schedule(&cmux->connect_work, MODEM_CMUX_T1_TIMEOUT);
+	modem_work_schedule(&cmux->connect_work, MODEM_CMUX_T1_TIMEOUT);
 }
 
 static void modem_cmux_disconnect_handler(struct k_work *item)
@@ -1057,7 +1059,7 @@ static void modem_cmux_disconnect_handler(struct k_work *item)
 
 	/* Transmit close down command */
 	modem_cmux_transmit_cmd_frame(cmux, &frame);
-	k_work_schedule(&cmux->disconnect_work, MODEM_CMUX_T1_TIMEOUT);
+	modem_work_schedule(&cmux->disconnect_work, MODEM_CMUX_T1_TIMEOUT);
 }
 
 #if CONFIG_MODEM_STATS
@@ -1107,7 +1109,7 @@ static int modem_cmux_dlci_pipe_api_open(void *data)
 			K_SPINLOCK_BREAK;
 		}
 
-		k_work_schedule(&dlci->open_work, K_NO_WAIT);
+		modem_work_schedule(&dlci->open_work, K_NO_WAIT);
 	}
 
 	return ret;
@@ -1173,7 +1175,7 @@ static int modem_cmux_dlci_pipe_api_close(void *data)
 			K_SPINLOCK_BREAK;
 		}
 
-		k_work_schedule(&dlci->close_work, K_NO_WAIT);
+		modem_work_schedule(&dlci->close_work, K_NO_WAIT);
 	}
 
 	return ret;
@@ -1210,7 +1212,7 @@ static void modem_cmux_dlci_open_handler(struct k_work *item)
 	};
 
 	modem_cmux_transmit_cmd_frame(dlci->cmux, &frame);
-	k_work_schedule(&dlci->open_work, MODEM_CMUX_T1_TIMEOUT);
+	modem_work_schedule(&dlci->open_work, MODEM_CMUX_T1_TIMEOUT);
 }
 
 static void modem_cmux_dlci_close_handler(struct k_work *item)
@@ -1239,7 +1241,7 @@ static void modem_cmux_dlci_close_handler(struct k_work *item)
 	};
 
 	modem_cmux_transmit_cmd_frame(cmux, &frame);
-	k_work_schedule(&dlci->close_work, MODEM_CMUX_T1_TIMEOUT);
+	modem_work_schedule(&dlci->close_work, MODEM_CMUX_T1_TIMEOUT);
 }
 
 static void modem_cmux_dlci_pipes_release(struct modem_cmux *cmux)
@@ -1367,7 +1369,7 @@ int modem_cmux_connect_async(struct modem_cmux *cmux)
 		}
 
 		if (k_work_delayable_is_pending(&cmux->connect_work) == false) {
-			k_work_schedule(&cmux->connect_work, K_NO_WAIT);
+			modem_work_schedule(&cmux->connect_work, K_NO_WAIT);
 		}
 	}
 
@@ -1406,7 +1408,7 @@ int modem_cmux_disconnect_async(struct modem_cmux *cmux)
 		}
 
 		if (k_work_delayable_is_pending(&cmux->disconnect_work) == false) {
-			k_work_schedule(&cmux->disconnect_work, K_NO_WAIT);
+			modem_work_schedule(&cmux->disconnect_work, K_NO_WAIT);
 		}
 	}
 
diff --git a/subsys/modem/modem_ppp.c b/subsys/modem/modem_ppp.c
diff --git a/subsys/modem/modem_ubx.c b/subsys/modem/modem_ubx.c
diff --git a/subsys/modem/modem_workqueue.c b/subsys/modem/modem_workqueue.c
diff --git a/subsys/modem/modem_workqueue.h b/subsys/modem/modem_workqueue.h

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`*/`
`6`	`6`
`7`	`7`	`#include "modem_backend_uart_async.h"`
	`8`	`+#include "../modem_workqueue.h"`
`8`	`9`
`9`	`10`	`#include <zephyr/logging/log.h>`
`10`	`11`	`LOG_MODULE_REGISTER(modem_backend_uart_async_hwfc, CONFIG_MODEM_MODULES_LOG_LEVEL);`
`@@ -136,7 +137,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev`
`136`	`137`	`case UART_TX_DONE:`
`137`	`138`	`atomic_clear_bit(&backend->async.common.state,`
`138`	`139`	`MODEM_BACKEND_UART_ASYNC_STATE_TRANSMIT_BIT);`
`139`		`- k_work_submit(&backend->transmit_idle_work);`
	`140`	`+ modem_work_submit(&backend->transmit_idle_work);`
`140`	`141`	`break;`
`141`	`142`
`142`	`143`	`case UART_TX_ABORTED:`
`@@ -145,7 +146,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev`
`145`	`146`	`}`
`146`	`147`	`atomic_clear_bit(&backend->async.common.state,`
`147`	`148`	`MODEM_BACKEND_UART_ASYNC_STATE_TRANSMIT_BIT);`
`148`		`- k_work_submit(&backend->transmit_idle_work);`
	`149`	`+ modem_work_submit(&backend->transmit_idle_work);`
`149`	`150`
`150`	`151`	`break;`
`151`	`152`
`@@ -182,7 +183,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev`
`182`	`183`	`rx_buf_unref(&backend->async, evt->data.rx.buf);`
`183`	`184`	`break;`
`184`	`185`	`}`
`185`		`- k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);`
	`186`	`+ modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);`
`186`	`187`	`}`
`187`	`188`	`break;`
`188`	`189`
`@@ -191,7 +192,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev`
`191`	`192`	`MODEM_BACKEND_UART_ASYNC_STATE_OPEN_BIT)) {`
`192`	`193`	`if (!atomic_test_and_set_bit(&backend->async.common.state,`
`193`	`194`	`MODEM_BACKEND_UART_ASYNC_STATE_RECOVERY_BIT)) {`
`194`		`- k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);`
	`195`	`+ modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);`
`195`	`196`	`LOG_DBG("RX recovery started");`
`196`	`197`	`}`
`197`	`198`	`}`
`@@ -206,7 +207,7 @@ static void modem_backend_uart_async_hwfc_event_handler(const struct device *dev`
`206`	`207`	`}`
`207`	`208`
`208`	`209`	`if (modem_backend_uart_async_hwfc_is_uart_stopped(backend)) {`
`209`		`- k_work_submit(&backend->async.common.rx_disabled_work);`
	`210`	`+ modem_work_submit(&backend->async.common.rx_disabled_work);`
`210`	`211`	`}`
`211`	`212`	`}`
`212`	`213`
`@@ -335,7 +336,7 @@ static int modem_backend_uart_async_hwfc_receive(void data, uint8_t buf, size_`
`335`	`336`
`336`	`337`	`if (backend->async.rx_event.len != 0 \|\|`
`337`	`338`	`k_msgq_num_used_get(&backend->async.rx_queue) != 0) {`
`338`		`- k_work_schedule(&backend->receive_ready_work, K_NO_WAIT);`
	`339`	`+ modem_work_schedule(&backend->receive_ready_work, K_NO_WAIT);`
`339`	`340`	`}`
`340`	`341`
`341`	`342`	`modem_backend_uart_async_hwfc_rx_recovery(backend);`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,8 @@ LOG_MODULE_REGISTER(modem_chat, CONFIG_MODEM_MODULES_LOG_LEVEL);`
`15`	`15`
`16`	`16`	`#include <zephyr/modem/chat.h>`
`17`	`17`
	`18`	`+#include "modem_workqueue.h"`
	`19`	`+`
`18`	`20`	`const struct modem_chat_match modem_chat_any_match = MODEM_CHAT_MATCH("", "", NULL);`
`19`	`21`	`const struct modem_chat_match modem_chat_empty_matches[0];`
`20`	`22`	`const struct modem_chat_script_chat modem_chat_empty_script_chats[0];`
`@@ -127,7 +129,7 @@ static void modem_chat_set_script_send_state(struct modem_chat *chat,`
`127`	`129`	`static void modem_chat_script_send(struct modem_chat *chat)`
`128`	`130`	`{`
`129`	`131`	`modem_chat_set_script_send_state(chat, MODEM_CHAT_SCRIPT_SEND_STATE_REQUEST);`
`130`		`- k_work_submit(&chat->script_send_work);`
	`132`	`+ modem_work_submit(&chat->script_send_work);`
`131`	`133`	`}`
`132`	`134`
`133`	`135`	`static void modem_chat_script_set_response_matches(struct modem_chat *chat)`
`@@ -178,7 +180,7 @@ static void modem_chat_script_chat_schedule_send_timeout(struct modem_chat *chat`
`178`	`180`	`{`
`179`	`181`	`uint16_t timeout = modem_chat_script_chat_get_send_timeout(chat);`
`180`	`182`
`181`		`- k_work_schedule(&chat->script_send_timeout_work, K_MSEC(timeout));`
	`183`	`+ modem_work_schedule(&chat->script_send_timeout_work, K_MSEC(timeout));`
`182`	`184`	`}`
`183`	`185`
`184`	`186`	`static void modem_chat_script_next(struct modem_chat *chat, bool initial)`
`@@ -233,7 +235,7 @@ static void modem_chat_script_start(struct modem_chat *chat, const struct modem_`
`233`	`235`
`234`	`236`	`/* Start timeout work if script started */`
`235`	`237`	`if (chat->script != NULL) {`
`236`		`- k_work_schedule(&chat->script_timeout_work, K_SECONDS(chat->script->timeout));`
	`238`	`+ modem_work_schedule(&chat->script_timeout_work, K_SECONDS(chat->script->timeout));`
`237`	`239`	`}`
`238`	`240`	`}`
`239`	`241`
`@@ -742,7 +744,7 @@ static void modem_chat_process_handler(struct k_work *item)`
`742`	`744`
`743`	`745`	`/* Process data */`
`744`	`746`	`modem_chat_process_bytes(chat);`
`745`		`- k_work_submit(&chat->receive_work);`
	`747`	`+ modem_work_submit(&chat->receive_work);`
`746`	`748`	`}`
`747`	`749`
`748`	`750`	`static void modem_chat_pipe_callback(struct modem_pipe *pipe, enum modem_pipe_event event,`
`@@ -752,11 +754,11 @@ static void modem_chat_pipe_callback(struct modem_pipe *pipe, enum modem_pipe_ev`
`752`	`754`
`753`	`755`	`switch (event) {`
`754`	`756`	`case MODEM_PIPE_EVENT_RECEIVE_READY:`
`755`		`- k_work_submit(&chat->receive_work);`
	`757`	`+ modem_work_submit(&chat->receive_work);`
`756`	`758`	`break;`
`757`	`759`
`758`	`760`	`case MODEM_PIPE_EVENT_TRANSMIT_IDLE:`
`759`		`- k_work_submit(&chat->script_send_work);`
	`761`	`+ modem_work_submit(&chat->script_send_work);`
`760`	`762`	`break;`
`761`	`763`
`762`	`764`	`default:`
`@@ -880,7 +882,7 @@ int modem_chat_run_script_async(struct modem_chat *chat, const struct modem_chat`
`880`	`882`	`k_sem_reset(&chat->script_stopped_sem);`
`881`	`883`
`882`	`884`	`chat->pending_script = script;`
`883`		`- k_work_submit(&chat->script_run_work);`
	`885`	`+ modem_work_submit(&chat->script_run_work);`
`884`	`886`	`return 0;`
`885`	`887`	`}`
`886`	`888`
`@@ -903,7 +905,7 @@ int modem_chat_run_script(struct modem_chat *chat, const struct modem_chat_scrip`
`903`	`905`
`904`	`906`	`void modem_chat_script_abort(struct modem_chat *chat)`
`905`	`907`	`{`
`906`		`- k_work_submit(&chat->script_abort_work);`
	`908`	`+ modem_work_submit(&chat->script_abort_work);`
`907`	`909`	`}`
`908`	`910`
`909`	`911`	`void modem_chat_release(struct modem_chat *chat)`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,8 @@ LOG_MODULE_REGISTER(modem_cmux, CONFIG_MODEM_CMUX_LOG_LEVEL);`
`13`	`13`
`14`	`14`	`#include <string.h>`
`15`	`15`
	`16`	`+#include "modem_workqueue.h"`
	`17`	`+`
`16`	`18`	`#define MODEM_CMUX_SOF (0xF9)`
`17`	`19`	`#define MODEM_CMUX_FCS_POLYNOMIAL (0xE0)`
`18`	`20`	`#define MODEM_CMUX_FCS_INIT_VALUE (0xFF)`
`@@ -257,11 +259,11 @@ static void modem_cmux_bus_callback(struct modem_pipe *pipe, enum modem_pipe_eve`
`257`	`259`
`258`	`260`	`switch (event) {`
`259`	`261`	`case MODEM_PIPE_EVENT_RECEIVE_READY:`
`260`		`- k_work_schedule(&cmux->receive_work, K_NO_WAIT);`
	`262`	`+ modem_work_schedule(&cmux->receive_work, K_NO_WAIT);`
`261`	`263`	`break;`
`262`	`264`
`263`	`265`	`case MODEM_PIPE_EVENT_TRANSMIT_IDLE:`
`264`		`- k_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
	`266`	`+ modem_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
`265`	`267`	`break;`
`266`	`268`
`267`	`269`	`default:`
`@@ -321,7 +323,7 @@ static uint16_t modem_cmux_transmit_frame(struct modem_cmux *cmux,`
`321`	`323`	`buf[0] = fcs;`
`322`	`324`	`buf[1] = MODEM_CMUX_SOF;`
`323`	`325`	`ring_buf_put(&cmux->transmit_rb, buf, 2);`
`324`		`- k_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
	`326`	`+ modem_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
`325`	`327`	`return data_len;`
`326`	`328`	`}`
`327`	`329`
`@@ -940,7 +942,7 @@ static void modem_cmux_receive_handler(struct k_work *item)`
`940`	`942`	`}`
`941`	`943`
`942`	`944`	`/* Reschedule received work */`
`943`		`- k_work_schedule(&cmux->receive_work, K_NO_WAIT);`
	`945`	`+ modem_work_schedule(&cmux->receive_work, K_NO_WAIT);`
`944`	`946`	`}`
`945`	`947`
`946`	`948`	`static void modem_cmux_dlci_notify_transmit_idle(struct modem_cmux *cmux)`
`@@ -1027,7 +1029,7 @@ static void modem_cmux_connect_handler(struct k_work *item)`
`1027`	`1029`	`};`
`1028`	`1030`
`1029`	`1031`	`modem_cmux_transmit_cmd_frame(cmux, &frame);`
`1030`		`- k_work_schedule(&cmux->connect_work, MODEM_CMUX_T1_TIMEOUT);`
	`1032`	`+ modem_work_schedule(&cmux->connect_work, MODEM_CMUX_T1_TIMEOUT);`
`1031`	`1033`	`}`
`1032`	`1034`
`1033`	`1035`	`static void modem_cmux_disconnect_handler(struct k_work *item)`
`@@ -1057,7 +1059,7 @@ static void modem_cmux_disconnect_handler(struct k_work *item)`
`1057`	`1059`
`1058`	`1060`	`/* Transmit close down command */`
`1059`	`1061`	`modem_cmux_transmit_cmd_frame(cmux, &frame);`
`1060`		`- k_work_schedule(&cmux->disconnect_work, MODEM_CMUX_T1_TIMEOUT);`
	`1062`	`+ modem_work_schedule(&cmux->disconnect_work, MODEM_CMUX_T1_TIMEOUT);`
`1061`	`1063`	`}`
`1062`	`1064`
`1063`	`1065`	`#if CONFIG_MODEM_STATS`
`@@ -1107,7 +1109,7 @@ static int modem_cmux_dlci_pipe_api_open(void *data)`
`1107`	`1109`	`K_SPINLOCK_BREAK;`
`1108`	`1110`	`}`
`1109`	`1111`
`1110`		`- k_work_schedule(&dlci->open_work, K_NO_WAIT);`
	`1112`	`+ modem_work_schedule(&dlci->open_work, K_NO_WAIT);`
`1111`	`1113`	`}`
`1112`	`1114`
`1113`	`1115`	`return ret;`
`@@ -1173,7 +1175,7 @@ static int modem_cmux_dlci_pipe_api_close(void *data)`
`1173`	`1175`	`K_SPINLOCK_BREAK;`
`1174`	`1176`	`}`
`1175`	`1177`
`1176`		`- k_work_schedule(&dlci->close_work, K_NO_WAIT);`
	`1178`	`+ modem_work_schedule(&dlci->close_work, K_NO_WAIT);`
`1177`	`1179`	`}`
`1178`	`1180`
`1179`	`1181`	`return ret;`
`@@ -1210,7 +1212,7 @@ static void modem_cmux_dlci_open_handler(struct k_work *item)`
`1210`	`1212`	`};`
`1211`	`1213`
`1212`	`1214`	`modem_cmux_transmit_cmd_frame(dlci->cmux, &frame);`
`1213`		`- k_work_schedule(&dlci->open_work, MODEM_CMUX_T1_TIMEOUT);`
	`1215`	`+ modem_work_schedule(&dlci->open_work, MODEM_CMUX_T1_TIMEOUT);`
`1214`	`1216`	`}`
`1215`	`1217`
`1216`	`1218`	`static void modem_cmux_dlci_close_handler(struct k_work *item)`
`@@ -1239,7 +1241,7 @@ static void modem_cmux_dlci_close_handler(struct k_work *item)`
`1239`	`1241`	`};`
`1240`	`1242`
`1241`	`1243`	`modem_cmux_transmit_cmd_frame(cmux, &frame);`
`1242`		`- k_work_schedule(&dlci->close_work, MODEM_CMUX_T1_TIMEOUT);`
	`1244`	`+ modem_work_schedule(&dlci->close_work, MODEM_CMUX_T1_TIMEOUT);`
`1243`	`1245`	`}`
`1244`	`1246`
`1245`	`1247`	`static void modem_cmux_dlci_pipes_release(struct modem_cmux *cmux)`
`@@ -1367,7 +1369,7 @@ int modem_cmux_connect_async(struct modem_cmux *cmux)`
`1367`	`1369`	`}`
`1368`	`1370`
`1369`	`1371`	`if (k_work_delayable_is_pending(&cmux->connect_work) == false) {`
`1370`		`- k_work_schedule(&cmux->connect_work, K_NO_WAIT);`
	`1372`	`+ modem_work_schedule(&cmux->connect_work, K_NO_WAIT);`
`1371`	`1373`	`}`
`1372`	`1374`	`}`
`1373`	`1375`
`@@ -1406,7 +1408,7 @@ int modem_cmux_disconnect_async(struct modem_cmux *cmux)`
`1406`	`1408`	`}`
`1407`	`1409`
`1408`	`1410`	`if (k_work_delayable_is_pending(&cmux->disconnect_work) == false) {`
`1409`		`- k_work_schedule(&cmux->disconnect_work, K_NO_WAIT);`
	`1411`	`+ modem_work_schedule(&cmux->disconnect_work, K_NO_WAIT);`
`1410`	`1412`	`}`
`1411`	`1413`	`}`
`1412`	`1414`