[nrf fromtree] modem: optional dedicated workqueue

JordanYates · rlubos · commit 857a583baef3 · 2025-11-04T09:04:09.000+01:00
Add the option to use a dedicated workqueue for the modem backend instead of the system workqueue. Signed-off-by: Jordan Yates <jordan@embeint.com> (cherry picked from commit 761961f)
diff --git a/doc/releases/release-notes-4.3.rst b/doc/releases/release-notes-4.3.rst
@@ -171,6 +171,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)
@@ -347,11 +349,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:
@@ -411,7 +413,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;
 }
 
@@ -1222,7 +1224,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)
@@ -1312,7 +1314,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)
@@ -1347,7 +1349,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
@@ -1397,7 +1399,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;
@@ -1476,7 +1478,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;
@@ -1514,7 +1516,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)
@@ -1543,7 +1545,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)
@@ -1666,7 +1668,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);
 		}
 	}
 
@@ -1704,7 +1706,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)`
`@@ -347,11 +349,11 @@ static void modem_cmux_bus_callback(struct modem_pipe *pipe, enum modem_pipe_eve`
`347`	`349`
`348`	`350`	`switch (event) {`
`349`	`351`	`case MODEM_PIPE_EVENT_RECEIVE_READY:`
`350`		`- k_work_schedule(&cmux->receive_work, K_NO_WAIT);`
	`352`	`+ modem_work_schedule(&cmux->receive_work, K_NO_WAIT);`
`351`	`353`	`break;`
`352`	`354`
`353`	`355`	`case MODEM_PIPE_EVENT_TRANSMIT_IDLE:`
`354`		`- k_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
	`356`	`+ modem_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
`355`	`357`	`break;`
`356`	`358`
`357`	`359`	`default:`
`@@ -411,7 +413,7 @@ static uint16_t modem_cmux_transmit_frame(struct modem_cmux *cmux,`
`411`	`413`	`buf[0] = fcs;`
`412`	`414`	`buf[1] = MODEM_CMUX_SOF;`
`413`	`415`	`ring_buf_put(&cmux->transmit_rb, buf, 2);`
`414`		`- k_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
	`416`	`+ modem_work_schedule(&cmux->transmit_work, K_NO_WAIT);`
`415`	`417`	`return data_len;`
`416`	`418`	`}`
`417`	`419`
`@@ -1222,7 +1224,7 @@ static void modem_cmux_receive_handler(struct k_work *item)`
`1222`	`1224`	`}`
`1223`	`1225`
`1224`	`1226`	`/* Reschedule received work */`
`1225`		`- k_work_schedule(&cmux->receive_work, K_NO_WAIT);`
	`1227`	`+ modem_work_schedule(&cmux->receive_work, K_NO_WAIT);`
`1226`	`1228`	`}`
`1227`	`1229`
`1228`	`1230`	`static void modem_cmux_dlci_notify_transmit_idle(struct modem_cmux *cmux)`
`@@ -1312,7 +1314,7 @@ static void modem_cmux_connect_handler(struct k_work *item)`
`1312`	`1314`	`};`
`1313`	`1315`
`1314`	`1316`	`modem_cmux_transmit_cmd_frame(cmux, &frame);`
`1315`		`- k_work_schedule(&cmux->connect_work, MODEM_CMUX_T1_TIMEOUT);`
	`1317`	`+ modem_work_schedule(&cmux->connect_work, MODEM_CMUX_T1_TIMEOUT);`
`1316`	`1318`	`}`
`1317`	`1319`
`1318`	`1320`	`static void modem_cmux_disconnect_handler(struct k_work *item)`
`@@ -1347,7 +1349,7 @@ static void modem_cmux_disconnect_handler(struct k_work *item)`
`1347`	`1349`
`1348`	`1350`	`/* Transmit close down command */`
`1349`	`1351`	`modem_cmux_transmit_cmd_frame(cmux, &frame);`
`1350`		`- k_work_schedule(&cmux->disconnect_work, MODEM_CMUX_T1_TIMEOUT);`
	`1352`	`+ modem_work_schedule(&cmux->disconnect_work, MODEM_CMUX_T1_TIMEOUT);`
`1351`	`1353`	`}`
`1352`	`1354`
`1353`	`1355`	`#if CONFIG_MODEM_STATS`
`@@ -1397,7 +1399,7 @@ static int modem_cmux_dlci_pipe_api_open(void *data)`
`1397`	`1399`	`K_SPINLOCK_BREAK;`
`1398`	`1400`	`}`
`1399`	`1401`
`1400`		`- k_work_schedule(&dlci->open_work, K_NO_WAIT);`
	`1402`	`+ modem_work_schedule(&dlci->open_work, K_NO_WAIT);`
`1401`	`1403`	`}`
`1402`	`1404`
`1403`	`1405`	`return ret;`
`@@ -1476,7 +1478,7 @@ static int modem_cmux_dlci_pipe_api_close(void *data)`
`1476`	`1478`	`K_SPINLOCK_BREAK;`
`1477`	`1479`	`}`
`1478`	`1480`
`1479`		`- k_work_schedule(&dlci->close_work, K_NO_WAIT);`
	`1481`	`+ modem_work_schedule(&dlci->close_work, K_NO_WAIT);`
`1480`	`1482`	`}`
`1481`	`1483`
`1482`	`1484`	`return ret;`
`@@ -1514,7 +1516,7 @@ static void modem_cmux_dlci_open_handler(struct k_work *item)`
`1514`	`1516`	`};`
`1515`	`1517`
`1516`	`1518`	`modem_cmux_transmit_cmd_frame(dlci->cmux, &frame);`
`1517`		`- k_work_schedule(&dlci->open_work, MODEM_CMUX_T1_TIMEOUT);`
	`1519`	`+ modem_work_schedule(&dlci->open_work, MODEM_CMUX_T1_TIMEOUT);`
`1518`	`1520`	`}`
`1519`	`1521`
`1520`	`1522`	`static void modem_cmux_dlci_close_handler(struct k_work *item)`
`@@ -1543,7 +1545,7 @@ static void modem_cmux_dlci_close_handler(struct k_work *item)`
`1543`	`1545`	`};`
`1544`	`1546`
`1545`	`1547`	`modem_cmux_transmit_cmd_frame(cmux, &frame);`
`1546`		`- k_work_schedule(&dlci->close_work, MODEM_CMUX_T1_TIMEOUT);`
	`1548`	`+ modem_work_schedule(&dlci->close_work, MODEM_CMUX_T1_TIMEOUT);`
`1547`	`1549`	`}`
`1548`	`1550`
`1549`	`1551`	`static void modem_cmux_dlci_pipes_release(struct modem_cmux *cmux)`
`@@ -1666,7 +1668,7 @@ int modem_cmux_connect_async(struct modem_cmux *cmux)`
`1666`	`1668`	`}`
`1667`	`1669`
`1668`	`1670`	`if (k_work_delayable_is_pending(&cmux->connect_work) == false) {`
`1669`		`- k_work_schedule(&cmux->connect_work, K_NO_WAIT);`
	`1671`	`+ modem_work_schedule(&cmux->connect_work, K_NO_WAIT);`
`1670`	`1672`	`}`
`1671`	`1673`	`}`
`1672`	`1674`
`@@ -1704,7 +1706,7 @@ int modem_cmux_disconnect_async(struct modem_cmux *cmux)`
`1704`	`1706`	`}`
`1705`	`1707`
`1706`	`1708`	`if (k_work_delayable_is_pending(&cmux->disconnect_work) == false) {`
`1707`		`- k_work_schedule(&cmux->disconnect_work, K_NO_WAIT);`
	`1709`	`+ modem_work_schedule(&cmux->disconnect_work, K_NO_WAIT);`
`1708`	`1710`	`}`
`1709`	`1711`	`}`
`1710`	`1712`