michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: use K_KERNEL_STACK macros

Browse source 
None of these threads run in user mode and we can save some
memory.

Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
This commit is contained in:
Andrew Boie 2020-07-31 12:29:38 -07:00 • committed by Anas Nashif
commit 7d920ba39b
78 changed files with 105 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

2
drivers/adc/adc_lmp90xxx.c
View file

@ -141,7 +141,7 @@ struct lmp90xxx_data {
struct k_sem acq_sem;
struct k_sem drdyb_sem;
K_THREAD_STACK_MEMBER(stack,
K_KERNEL_STACK_MEMBER(stack,
CONFIG_ADC_LMP90XXX_ACQUISITION_THREAD_STACK_SIZE);
};

2
drivers/adc/adc_mcp320x.c
View file

@ -45,7 +45,7 @@ struct mcp320x_data {
struct k_thread thread;
struct k_sem sem;
K_THREAD_STACK_MEMBER(stack,
K_KERNEL_STACK_MEMBER(stack,
CONFIG_ADC_MCP320X_ACQUISITION_THREAD_STACK_SIZE);
};

4
drivers/bluetooth/hci/h4.c
View file

@ -34,7 +34,7 @@
#define H4_SCO 0x03
#define H4_EVT 0x04
static K_THREAD_STACK_DEFINE(rx_thread_stack, CONFIG_BT_RX_STACK_SIZE);
static K_KERNEL_STACK_DEFINE(rx_thread_stack, CONFIG_BT_RX_STACK_SIZE);
static struct k_thread rx_thread_data;
static struct {
@ -446,7 +446,7 @@ static int h4_open(void)
uart_irq_callback_set(h4_dev, bt_uart_isr);
k_thread_create(&rx_thread_data, rx_thread_stack,
K_THREAD_STACK_SIZEOF(rx_thread_stack),
K_KERNEL_STACK_SIZEOF(rx_thread_stack),
rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RX_PRIO),
0, K_NO_WAIT);

8
drivers/bluetooth/hci/h5.c
View file

@ -29,8 +29,8 @@
#include "../util.h"
static K_THREAD_STACK_DEFINE(tx_stack, 256);
static K_THREAD_STACK_DEFINE(rx_stack, 256);
static K_KERNEL_STACK_DEFINE(tx_stack, 256);
static K_KERNEL_STACK_DEFINE(rx_stack, 256);
static struct k_thread tx_thread_data;
static struct k_thread rx_thread_data;
@ -700,7 +700,7 @@ static void h5_init(void)
/* TX thread */
k_fifo_init(&h5.tx_queue);
k_thread_create(&tx_thread_data, tx_stack,
K_THREAD_STACK_SIZEOF(tx_stack),
K_KERNEL_STACK_SIZEOF(tx_stack),
(k_thread_entry_t)tx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_HCI_TX_PRIO),
0, K_NO_WAIT);
@ -708,7 +708,7 @@ static void h5_init(void)
k_fifo_init(&h5.rx_queue);
k_thread_create(&rx_thread_data, rx_stack,
K_THREAD_STACK_SIZEOF(rx_stack),
K_KERNEL_STACK_SIZEOF(rx_stack),
(k_thread_entry_t)rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RX_PRIO),
0, K_NO_WAIT);

4
drivers/bluetooth/hci/ipm_stm32wb.c
View file

@ -70,7 +70,7 @@ static bt_addr_t bd_addr_udn;
/* Rx thread definitions */
K_FIFO_DEFINE(ipm_rx_events_fifo);
static K_THREAD_STACK_DEFINE(ipm_rx_stack, CONFIG_BT_STM32_IPM_RX_STACK_SIZE);
static K_KERNEL_STACK_DEFINE(ipm_rx_stack, CONFIG_BT_STM32_IPM_RX_STACK_SIZE);
static struct k_thread ipm_rx_thread_data;
static void stm32wb_start_ble(void)
@ -492,7 +492,7 @@ static int bt_ipm_open(void)
/* Start RX thread */
k_thread_create(&ipm_rx_thread_data, ipm_rx_stack,
K_THREAD_STACK_SIZEOF(ipm_rx_stack),
K_KERNEL_STACK_SIZEOF(ipm_rx_stack),
(k_thread_entry_t)bt_ipm_rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RX_PRIO - 1),
0, K_NO_WAIT);

4
drivers/bluetooth/hci/rpmsg_nrf53.c
View file

@ -20,7 +20,7 @@ void bt_rpmsg_rx(uint8_t *data, size_t len);
static K_SEM_DEFINE(ready_sem, 0, 1);
static K_SEM_DEFINE(rx_sem, 0, 1);
static K_THREAD_STACK_DEFINE(bt_rpmsg_rx_thread_stack,
static K_KERNEL_STACK_DEFINE(bt_rpmsg_rx_thread_stack,
CONFIG_BT_RPMSG_NRF53_RX_STACK_SIZE);
static struct k_thread bt_rpmsg_rx_thread_data;
@ -180,7 +180,7 @@ int bt_rpmsg_platform_init(void)
/* Setup thread for RX data processing. */
k_thread_create(&bt_rpmsg_rx_thread_data, bt_rpmsg_rx_thread_stack,
K_THREAD_STACK_SIZEOF(bt_rpmsg_rx_thread_stack),
K_KERNEL_STACK_SIZEOF(bt_rpmsg_rx_thread_stack),
bt_rpmsg_rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RPMSG_NRF53_RX_PRIO),
0, K_NO_WAIT);

4
drivers/bluetooth/hci/spi.c
View file

@ -77,7 +77,7 @@ static K_SEM_DEFINE(sem_initialised, 0, 1);
static K_SEM_DEFINE(sem_request, 0, 1);
static K_SEM_DEFINE(sem_busy, 1, 1);
static K_THREAD_STACK_DEFINE(spi_rx_stack, 256);
static K_KERNEL_STACK_DEFINE(spi_rx_stack, 256);
static struct k_thread spi_rx_thread_data;
#if defined(CONFIG_BT_DEBUG_HCI_DRIVER)
@ -504,7 +504,7 @@ static int bt_spi_open(void)
/* Start RX thread */
k_thread_create(&spi_rx_thread_data, spi_rx_stack,
K_THREAD_STACK_SIZEOF(spi_rx_stack),
K_KERNEL_STACK_SIZEOF(spi_rx_stack),
(k_thread_entry_t)bt_spi_rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RX_PRIO - 1),
0, K_NO_WAIT);

4
drivers/bluetooth/hci/userchan.c
View file

@ -47,7 +47,7 @@ struct sockaddr_hci {
#define H4_SCO 0x03
#define H4_EVT 0x04
static K_THREAD_STACK_DEFINE(rx_thread_stack,
static K_KERNEL_STACK_DEFINE(rx_thread_stack,
CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
static struct k_thread rx_thread_data;
@ -187,7 +187,7 @@ static int uc_open(void)
BT_DBG("User Channel opened as fd %d", uc_fd);
k_thread_create(&rx_thread_data, rx_thread_stack,
K_THREAD_STACK_SIZEOF(rx_thread_stack),
K_KERNEL_STACK_SIZEOF(rx_thread_stack),
rx_thread, NULL, NULL, NULL,
K_PRIO_COOP(CONFIG_BT_RX_PRIO - 1),
0, K_NO_WAIT);

6
drivers/can/can_loopback.c
View file

@ -13,7 +13,7 @@
#include <logging/log.h>
LOG_MODULE_DECLARE(can_driver, CONFIG_CAN_LOG_LEVEL);
K_THREAD_STACK_DEFINE(tx_thread_stack,
K_KERNEL_STACK_DEFINE(tx_thread_stack,
CONFIG_CAN_LOOPBACK_TX_THREAD_STACK_SIZE);
struct k_thread tx_thread_data;
@ -258,7 +258,7 @@ static int can_loopback_init(struct device *dev)
}
tx_tid = k_thread_create(&tx_thread_data, tx_thread_stack,
K_THREAD_STACK_SIZEOF(tx_thread_stack),
K_KERNEL_STACK_SIZEOF(tx_thread_stack),
tx_thread, data, NULL, NULL,
CONFIG_CAN_LOOPBACK_TX_THREAD_PRIORITY,
0, K_NO_WAIT);
@ -299,7 +299,7 @@ static int socket_can_init_1(struct device *dev)
socket_context->rx_tid =
k_thread_create(&socket_context->rx_thread_data,
rx_thread_stack,
K_THREAD_STACK_SIZEOF(rx_thread_stack),
K_KERNEL_STACK_SIZEOF(rx_thread_stack),
rx_thread, socket_context, NULL, NULL,
RX_THREAD_PRIORITY, 0, K_NO_WAIT);

2
drivers/can/can_mcp2515.c
View file

@ -829,7 +829,7 @@ static int mcp2515_init(struct device *dev)
#if DT_NODE_HAS_STATUS(DT_DRV_INST(0), okay)
static K_THREAD_STACK_DEFINE(mcp2515_int_thread_stack,
static K_KERNEL_STACK_DEFINE(mcp2515_int_thread_stack,
CONFIG_CAN_MCP2515_INT_THREAD_STACK_SIZE);
static struct mcp2515_data mcp2515_data_1 = {

2
drivers/can/can_mcux_flexcan.c
View file

@ -745,7 +745,7 @@ static int socket_can_init_0(struct device *dev)
socket_context->rx_tid =
k_thread_create(&socket_context->rx_thread_data,
rx_thread_stack,
K_THREAD_STACK_SIZEOF(rx_thread_stack),
K_KERNEL_STACK_SIZEOF(rx_thread_stack),
rx_thread, socket_context, NULL, NULL,
RX_THREAD_PRIORITY, 0, K_NO_WAIT);

4
drivers/can/can_stm32.c
View file

@ -1117,7 +1117,7 @@ static int socket_can_init_1(struct device *dev)
socket_context->rx_tid =
k_thread_create(&socket_context->rx_thread_data,
rx_thread_stack,
K_THREAD_STACK_SIZEOF(rx_thread_stack),
K_KERNEL_STACK_SIZEOF(rx_thread_stack),
rx_thread, socket_context, NULL, NULL,
RX_THREAD_PRIORITY, 0, K_NO_WAIT);
@ -1200,7 +1200,7 @@ static int socket_can_init_2(struct device *dev)
socket_context->rx_tid =
k_thread_create(&socket_context->rx_thread_data,
rx_thread_stack,
K_THREAD_STACK_SIZEOF(rx_thread_stack),
K_KERNEL_STACK_SIZEOF(rx_thread_stack),
rx_thread, socket_context, NULL, NULL,
RX_THREAD_PRIORITY, 0, K_NO_WAIT);

2
drivers/can/socket_can_generic.h
View file

@ -21,7 +21,7 @@
/* TODO: make msgq size configurable */
CAN_DEFINE_MSGQ(socket_can_msgq, 5);
K_THREAD_STACK_DEFINE(rx_thread_stack, RX_THREAD_STACK_SIZE);
K_KERNEL_STACK_DEFINE(rx_thread_stack, RX_THREAD_STACK_SIZE);
struct socket_can_context {
struct device *can_dev;

2
drivers/console/native_posix_console.c
View file

@ -64,7 +64,7 @@ static struct k_fifo *lines_queue;
static uint8_t (*completion_cb)(char *line, uint8_t len);
static bool stdin_is_tty;
static K_THREAD_STACK_DEFINE(stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
static K_KERNEL_STACK_DEFINE(stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
static struct k_thread native_stdio_thread;
static inline void found_eof(void)

4
drivers/console/uart_mux.c
View file

@ -32,7 +32,7 @@ LOG_MODULE_REGISTER(uart_mux, CONFIG_UART_MUX_LOG_LEVEL);
* as the GSM modem uses global workqueue which causes difficulties if we do
* the same here. This workqueue is shared between all the DLCI channels.
*/
K_THREAD_STACK_DEFINE(uart_mux_stack, UART_MUX_WORKQ_STACK_SIZE);
K_KERNEL_STACK_DEFINE(uart_mux_stack, UART_MUX_WORKQ_STACK_SIZE);
static struct k_work_q uart_mux_workq;
/* The UART mux contains information about the real UART. It will synchronize
@ -848,7 +848,7 @@ static int init_uart_mux(struct device *device)
ARG_UNUSED(device);
k_work_q_start(&uart_mux_workq, uart_mux_stack,
K_THREAD_STACK_SIZEOF(uart_mux_stack),
K_KERNEL_STACK_SIZEOF(uart_mux_stack),
K_PRIO_COOP(UART_MUX_WORKQ_PRIORITY));
k_thread_name_set(&uart_mux_workq.thread, "uart_mux_workq");

2
drivers/ethernet/eth_enc28j60_priv.h
View file

@ -229,7 +229,7 @@ struct eth_enc28j60_config {
struct eth_enc28j60_runtime {
struct net_if *iface;
K_THREAD_STACK_MEMBER(thread_stack,
K_KERNEL_STACK_MEMBER(thread_stack,
CONFIG_ETH_ENC28J60_RX_THREAD_STACK_SIZE);
struct k_thread thread;
uint8_t mac_address[6];

2
drivers/ethernet/eth_enc424j600_priv.h
View file

@ -289,7 +289,7 @@ struct enc424j600_config {
struct enc424j600_runtime {
struct net_if *iface;
K_THREAD_STACK_MEMBER(thread_stack,
K_KERNEL_STACK_MEMBER(thread_stack,
CONFIG_ETH_ENC424J600_RX_THREAD_STACK_SIZE);
struct k_thread thread;

2
drivers/ethernet/eth_gecko.c
View file

@ -611,7 +611,7 @@ static void eth_iface_init(struct net_if *iface)
/* Start interruption-poll thread */
k_thread_create(&dev_data->rx_thread, dev_data->rx_thread_stack,
K_THREAD_STACK_SIZEOF(dev_data->rx_thread_stack),
K_KERNEL_STACK_SIZEOF(dev_data->rx_thread_stack),
rx_thread, (void *) dev, NULL, NULL,
K_PRIO_COOP(CONFIG_ETH_GECKO_RX_THREAD_PRIO),
0, K_NO_WAIT);

2
drivers/ethernet/eth_gecko_priv.h
View file

@ -88,7 +88,7 @@ struct eth_gecko_dev_data {
struct k_sem tx_sem;
struct k_sem rx_sem;
K_THREAD_STACK_MEMBER(rx_thread_stack,
K_KERNEL_STACK_MEMBER(rx_thread_stack,
CONFIG_ETH_GECKO_RX_THREAD_STACK_SIZE);
struct k_thread rx_thread;
bool link_up;

4
drivers/ethernet/eth_native_posix.c
View file

@ -65,7 +65,7 @@ struct eth_context {
#endif
};
K_THREAD_STACK_DEFINE(eth_rx_stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
K_KERNEL_STACK_DEFINE(eth_rx_stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
static struct k_thread rx_thread_data;
/* TODO: support multiple interfaces */
@ -385,7 +385,7 @@ static void eth_rx(struct eth_context *ctx)
static void create_rx_handler(struct eth_context *ctx)
{
k_thread_create(&rx_thread_data, eth_rx_stack,
K_THREAD_STACK_SIZEOF(eth_rx_stack),
K_KERNEL_STACK_SIZEOF(eth_rx_stack),
(k_thread_entry_t)eth_rx,
ctx, NULL, NULL, K_PRIO_COOP(14),
0, K_NO_WAIT);

2
drivers/ethernet/eth_stm32_hal.c
View file

@ -586,7 +586,7 @@ static int eth_initialize(struct device *dev)
/* Start interruption-poll thread */
k_thread_create(&dev_data->rx_thread, dev_data->rx_thread_stack,
K_THREAD_STACK_SIZEOF(dev_data->rx_thread_stack),
K_KERNEL_STACK_SIZEOF(dev_data->rx_thread_stack),
rx_thread, (void *) dev, NULL, NULL,
K_PRIO_COOP(CONFIG_ETH_STM32_HAL_RX_THREAD_PRIO),
0, K_NO_WAIT);

2
drivers/ethernet/eth_stm32_hal_priv.h
View file

@ -40,7 +40,7 @@ struct eth_stm32_hal_dev_data {
struct device *clock;
struct k_mutex tx_mutex;
struct k_sem rx_int_sem;
K_THREAD_STACK_MEMBER(rx_thread_stack,
K_KERNEL_STACK_MEMBER(rx_thread_stack,
CONFIG_ETH_STM32_HAL_RX_THREAD_STACK_SIZE);
struct k_thread rx_thread;
bool link_up;

2
drivers/ieee802154/ieee802154_cc1200.h
View file

@ -53,7 +53,7 @@ struct cc1200_context {
atomic_t tx;
atomic_t tx_start;
/************RX************/
K_THREAD_STACK_MEMBER(rx_stack,
K_KERNEL_STACK_MEMBER(rx_stack,
CONFIG_IEEE802154_CC1200_RX_STACK_SIZE);
struct k_thread rx_thread;
struct k_sem rx_lock;

2
drivers/ieee802154/ieee802154_cc13xx_cc26xx.c
View file

@ -434,7 +434,7 @@ static void ieee802154_cc13xx_cc26xx_data_init(struct device *dev)
k_sem_init(&drv_data->rx_done, 0, UINT_MAX);
k_thread_create(&drv_data->rx_thread, drv_data->rx_stack,
K_THREAD_STACK_SIZEOF(drv_data->rx_stack),
K_KERNEL_STACK_SIZEOF(drv_data->rx_stack),
ieee802154_cc13xx_cc26xx_rx, dev, NULL, NULL,
K_PRIO_COOP(2), 0, K_NO_WAIT);
}

2
drivers/ieee802154/ieee802154_cc13xx_cc26xx.h
View file

@ -66,7 +66,7 @@ struct ieee802154_cc13xx_cc26xx_data {
struct k_sem fg_done;
struct k_sem rx_done;
K_THREAD_STACK_MEMBER(rx_stack,
K_KERNEL_STACK_MEMBER(rx_stack,
CONFIG_IEEE802154_CC13XX_CC26XX_RX_STACK_SIZE);
struct k_thread rx_thread;

2
drivers/ieee802154/ieee802154_cc2520.h
View file

@ -45,7 +45,7 @@ struct cc2520_context {
struct k_sem tx_sync;
atomic_t tx;
/************RX************/
K_THREAD_STACK_MEMBER(cc2520_rx_stack,
K_KERNEL_STACK_MEMBER(cc2520_rx_stack,
CONFIG_IEEE802154_CC2520_RX_STACK_SIZE);
struct k_thread cc2520_rx_thread;
struct k_sem rx_lock;

4
drivers/ieee802154/ieee802154_dw1000.c
View file

@ -66,7 +66,7 @@ LOG_MODULE_REGISTER(dw1000, LOG_LEVEL_INF);
#define DWT_WORK_QUEUE_STACK_SIZE 512
static struct k_work_q dwt_work_queue;
static K_THREAD_STACK_DEFINE(dwt_work_queue_stack,
static K_KERNEL_STACK_DEFINE(dwt_work_queue_stack,
DWT_WORK_QUEUE_STACK_SIZE);
struct dwt_phy_config {
@ -1607,7 +1607,7 @@ static int dw1000_init(struct device *dev)
/* Initialize IRQ event work queue */
k_work_q_start(&dwt_work_queue,
dwt_work_queue_stack,
K_THREAD_STACK_SIZEOF(dwt_work_queue_stack),
K_KERNEL_STACK_SIZEOF(dwt_work_queue_stack),
CONFIG_SYSTEM_WORKQUEUE_PRIORITY);
k_work_init(&ctx->irq_cb_work, dwt_irq_work_handler);

2
drivers/ieee802154/ieee802154_mcr20a.h
View file

@ -35,7 +35,7 @@ struct mcr20a_context {
struct k_sem seq_sync;
atomic_t seq_retval;
/************RX************/
K_THREAD_STACK_MEMBER(mcr20a_rx_stack,
K_KERNEL_STACK_MEMBER(mcr20a_rx_stack,
CONFIG_IEEE802154_MCR20A_RX_STACK_SIZE);
struct k_thread mcr20a_rx_thread;
};

2
drivers/ieee802154/ieee802154_nrf5.h
View file

@ -31,7 +31,7 @@ struct nrf5_802154_data {
uint8_t mac[8];
/* RX thread stack. */
K_THREAD_STACK_MEMBER(rx_stack, CONFIG_IEEE802154_NRF5_RX_STACK_SIZE);
K_KERNEL_STACK_MEMBER(rx_stack, CONFIG_IEEE802154_NRF5_RX_STACK_SIZE);
/* RX thread control block. */
struct k_thread rx_thread;

2
drivers/ieee802154/ieee802154_rf2xx.h
View file

@ -116,7 +116,7 @@ struct rf2xx_context {
struct gpio_callback irq_cb;
struct k_thread trx_thread;
K_THREAD_STACK_MEMBER(trx_stack,
K_KERNEL_STACK_MEMBER(trx_stack,
CONFIG_IEEE802154_RF2XX_RX_STACK_SIZE);
struct k_sem trx_isr_lock;
struct k_sem trx_tx_sync;

2
drivers/kscan/kscan_mchp_xec.c
View file

@ -54,7 +54,7 @@ struct kscan_xec_data {
struct k_thread thread;
atomic_t enable_scan;
K_THREAD_STACK_MEMBER(thread_stack, TASK_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, TASK_STACK_SIZE);
};
static KSCAN_Type *base = (KSCAN_Type *)

2
drivers/led/ht16k33.c
View file

@ -89,7 +89,7 @@ struct ht16k33_data {
struct k_timer timer;
uint16_t key_state[HT16K33_KEYSCAN_ROWS];
K_THREAD_STACK_MEMBER(irq_thread_stack,
K_KERNEL_STACK_MEMBER(irq_thread_stack,
CONFIG_HT16K33_KEYSCAN_IRQ_THREAD_STACK_SIZE);
#endif /* CONFIG_HT16K33_KEYSCAN */
};

4
drivers/modem/gsm_ppp.c
View file

@ -68,7 +68,7 @@ static struct gsm_modem {
NET_BUF_POOL_DEFINE(gsm_recv_pool, GSM_RECV_MAX_BUF, GSM_RECV_BUF_SIZE,
0, NULL);
K_THREAD_STACK_DEFINE(gsm_rx_stack, GSM_RX_STACK_SIZE);
K_KERNEL_STACK_DEFINE(gsm_rx_stack, GSM_RX_STACK_SIZE);
struct k_thread gsm_rx_thread;
@ -615,7 +615,7 @@ static int gsm_init(struct device *device)
gsm->context.iface.read, gsm->context.iface.write);
k_thread_create(&gsm_rx_thread, gsm_rx_stack,
K_THREAD_STACK_SIZEOF(gsm_rx_stack),
K_KERNEL_STACK_SIZEOF(gsm_rx_stack),
(k_thread_entry_t) gsm_rx,
gsm, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT);
k_thread_name_set(&gsm_rx_thread, "gsm_rx");

8
drivers/modem/ublox-sara-r4.c
View file

@ -107,12 +107,12 @@ NET_BUF_POOL_DEFINE(mdm_recv_pool, MDM_RECV_MAX_BUF, MDM_RECV_BUF_SIZE,
0, NULL);
/* RX thread structures */
K_THREAD_STACK_DEFINE(modem_rx_stack,
K_KERNEL_STACK_DEFINE(modem_rx_stack,
CONFIG_MODEM_UBLOX_SARA_R4_RX_STACK_SIZE);
struct k_thread modem_rx_thread;
/* RX thread work queue */
K_THREAD_STACK_DEFINE(modem_workq_stack,
K_KERNEL_STACK_DEFINE(modem_workq_stack,
CONFIG_MODEM_UBLOX_SARA_R4_RX_WORKQ_STACK_SIZE);
static struct k_work_q modem_workq;
@ -1725,7 +1725,7 @@ static int modem_init(struct device *dev)
/* initialize the work queue */
k_work_q_start(&modem_workq,
modem_workq_stack,
K_THREAD_STACK_SIZEOF(modem_workq_stack),
K_KERNEL_STACK_SIZEOF(modem_workq_stack),
K_PRIO_COOP(7));
/* socket config */
@ -1787,7 +1787,7 @@ static int modem_init(struct device *dev)
/* start RX thread */
k_thread_create(&modem_rx_thread, modem_rx_stack,
K_THREAD_STACK_SIZEOF(modem_rx_stack),
K_KERNEL_STACK_SIZEOF(modem_rx_stack),
(k_thread_entry_t) modem_rx,
NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT);

8
drivers/modem/wncm14a2a.c
View file

@ -149,12 +149,12 @@ NET_BUF_POOL_DEFINE(mdm_recv_pool, MDM_RECV_MAX_BUF, MDM_RECV_BUF_SIZE,
static uint8_t mdm_recv_buf[MDM_MAX_DATA_LENGTH];
/* RX thread structures */
K_THREAD_STACK_DEFINE(wncm14a2a_rx_stack,
K_KERNEL_STACK_DEFINE(wncm14a2a_rx_stack,
CONFIG_MODEM_WNCM14A2A_RX_STACK_SIZE);
struct k_thread wncm14a2a_rx_thread;
/* RX thread work queue */
K_THREAD_STACK_DEFINE(wncm14a2a_workq_stack,
K_KERNEL_STACK_DEFINE(wncm14a2a_workq_stack,
CONFIG_MODEM_WNCM14A2A_RX_WORKQ_STACK_SIZE);
static struct k_work_q wncm14a2a_workq;
@ -1462,7 +1462,7 @@ static int wncm14a2a_init(struct device *dev)
/* initialize the work queue */
k_work_q_start(&wncm14a2a_workq,
wncm14a2a_workq_stack,
K_THREAD_STACK_SIZEOF(wncm14a2a_workq_stack),
K_KERNEL_STACK_SIZEOF(wncm14a2a_workq_stack),
K_PRIO_COOP(7));
ictx.last_socket_id = 0;
@ -1496,7 +1496,7 @@ static int wncm14a2a_init(struct device *dev)
/* start RX thread */
k_thread_create(&wncm14a2a_rx_thread, wncm14a2a_rx_stack,
K_THREAD_STACK_SIZEOF(wncm14a2a_rx_stack),
K_KERNEL_STACK_SIZEOF(wncm14a2a_rx_stack),
(k_thread_entry_t) wncm14a2a_rx,
NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT);

4
drivers/net/ppp.c
View file

@ -47,7 +47,7 @@ enum ppp_driver_state {
#define PPP_WORKQ_PRIORITY CONFIG_NET_PPP_RX_PRIORITY
#define PPP_WORKQ_STACK_SIZE CONFIG_NET_PPP_RX_STACK_SIZE
K_THREAD_STACK_DEFINE(ppp_workq, PPP_WORKQ_STACK_SIZE);
K_KERNEL_STACK_DEFINE(ppp_workq, PPP_WORKQ_STACK_SIZE);
struct ppp_driver_context {
struct device *dev;
@ -693,7 +693,7 @@ static int ppp_driver_init(struct device *dev)
k_work_init(&ppp->cb_work, ppp_isr_cb_work);
k_work_q_start(&ppp->cb_workq, ppp_workq,
K_THREAD_STACK_SIZEOF(ppp_workq),
K_KERNEL_STACK_SIZEOF(ppp_workq),
K_PRIO_COOP(PPP_WORKQ_PRIORITY));
k_thread_name_set(&ppp->cb_workq.thread, "ppp_workq");
#endif

2
drivers/sensor/adt7420/adt7420.h
View file

@ -71,7 +71,7 @@ struct adt7420_data {
struct device *dev;
#if defined(CONFIG_ADT7420_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_ADT7420_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADT7420_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ADT7420_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/adxl362/adxl362.h
View file

@ -211,7 +211,7 @@ struct adxl362_data {
struct sensor_trigger drdy_trigger;
#if defined(CONFIG_ADXL362_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_ADXL362_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADXL362_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ADXL362_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/adxl372/adxl372.h
View file

@ -300,7 +300,7 @@ struct adxl372_data {
struct device *dev;
#if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_ADXL372_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ADXL372_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/amg88xx/amg88xx.h
View file

@ -92,7 +92,7 @@ struct amg88xx_data {
struct sensor_trigger th_trigger;
#if defined(CONFIG_AMG88XX_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_AMG88XX_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_AMG88XX_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_AMG88XX_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/bma280/bma280.h
View file

@ -132,7 +132,7 @@ struct bma280_data {
sensor_trigger_handler_t any_motion_handler;
#if defined(CONFIG_BMA280_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_BMA280_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_BMA280_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_BMA280_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/bmc150_magn/bmc150_magn.h
View file

@ -117,7 +117,7 @@ struct bmc150_magn_data {
struct k_sem sem;
#if defined(CONFIG_BMC150_MAGN_TRIGGER)
K_THREAD_STACK_MEMBER(thread_stack,
K_KERNEL_STACK_MEMBER(thread_stack,
CONFIG_BMC150_MAGN_TRIGGER_THREAD_STACK);
struct k_thread thread;
#endif

2
drivers/sensor/bmg160/bmg160_trigger.c
View file

@ -180,7 +180,7 @@ static void bmg160_handle_int(void *arg)
}
#ifdef CONFIG_BMG160_TRIGGER_OWN_THREAD
static K_THREAD_STACK_DEFINE(bmg160_thread_stack, CONFIG_BMG160_THREAD_STACK_SIZE);
static K_KERNEL_STACK_DEFINE(bmg160_thread_stack, CONFIG_BMG160_THREAD_STACK_SIZE);
static struct k_thread bmg160_thread;
static void bmg160_thread_main(void *arg1, void *arg2, void *arg3)

2
drivers/sensor/bmi160/bmi160_trigger.c
View file

@ -80,7 +80,7 @@ static void bmi160_handle_interrupts(void *arg)
}
#ifdef CONFIG_BMI160_TRIGGER_OWN_THREAD
static K_THREAD_STACK_DEFINE(bmi160_thread_stack, CONFIG_BMI160_THREAD_STACK_SIZE);
static K_KERNEL_STACK_DEFINE(bmi160_thread_stack, CONFIG_BMI160_THREAD_STACK_SIZE);
static struct k_thread bmi160_thread;
static void bmi160_thread_main(void *arg1, void *unused1, void *unused2)

2
drivers/sensor/ccs811/ccs811.h
View file

@ -62,7 +62,7 @@ struct ccs811_data {
sensor_trigger_handler_t handler;
struct sensor_trigger trigger;
#if defined(CONFIG_CCS811_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_CCS811_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_CCS811_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_CCS811_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/fxas21002/fxas21002.h
View file

@ -79,7 +79,7 @@ struct fxas21002_data {
sensor_trigger_handler_t drdy_handler;
#endif
#ifdef CONFIG_FXAS21002_TRIGGER_OWN_THREAD
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_FXAS21002_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_FXAS21002_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#endif

2
drivers/sensor/fxos8700/fxos8700.h
View file

@ -162,7 +162,7 @@ struct fxos8700_data {
sensor_trigger_handler_t motion_handler;
#endif
#ifdef CONFIG_FXOS8700_TRIGGER_OWN_THREAD
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_FXOS8700_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_FXOS8700_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#endif

2
drivers/sensor/hmc5883l/hmc5883l.h
View file

@ -55,7 +55,7 @@ struct hmc5883l_data {
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_HMC5883L_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_HMC5883L_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_HMC5883L_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_HMC5883L_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/hts221/hts221.h
View file

@ -51,7 +51,7 @@ struct hts221_data {
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_HTS221_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_HTS221_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_HTS221_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem drdy_sem;
#elif defined(CONFIG_HTS221_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/iis2dh/iis2dh.h
View file

@ -69,7 +69,7 @@ struct iis2dh_data {
struct gpio_callback gpio_cb;
sensor_trigger_handler_t drdy_handler;
#if defined(CONFIG_IIS2DH_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_IIS2DH_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS2DH_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS2DH_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/iis2dlpc/iis2dlpc.h
View file

@ -123,7 +123,7 @@ struct iis2dlpc_data {
sensor_trigger_handler_t double_tap_handler;
#endif /* CONFIG_IIS2DLPC_PULSE */
#if defined(CONFIG_IIS2DLPC_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_IIS2DLPC_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS2DLPC_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS2DLPC_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/iis2mdc/iis2mdc.h
View file

@ -70,7 +70,7 @@ struct iis2mdc_data {
struct device *dev;
#if defined(CONFIG_IIS2MDC_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_IIS2MDC_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS2MDC_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS2MDC_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/iis3dhhc/iis3dhhc.h
View file

@ -60,7 +60,7 @@ struct iis3dhhc_data {
struct device *dev;
#if defined(CONFIG_IIS3DHHC_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_IIS3DHHC_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_IIS3DHHC_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_IIS3DHHC_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/isl29035/isl29035.h
View file

@ -122,7 +122,7 @@ struct isl29035_driver_data {
sensor_trigger_handler_t th_handler;
#if defined(CONFIG_ISL29035_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_ISL29035_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ISL29035_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_ISL29035_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/ism330dhcx/ism330dhcx.h
View file

@ -181,7 +181,7 @@ struct ism330dhcx_data {
struct device *dev;
#if defined(CONFIG_ISM330DHCX_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_ISM330DHCX_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ISM330DHCX_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_ISM330DHCX_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lis2dh/lis2dh.h
View file

@ -246,7 +246,7 @@ struct lis2dh_data {
enum sensor_channel chan_drdy;
#if defined(CONFIG_LIS2DH_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LIS2DH_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DH_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2DH_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lis2ds12/lis2ds12.h
View file

@ -123,7 +123,7 @@ struct lis2ds12_data {
struct device *dev;
#if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LIS2DS12_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DS12_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem trig_sem;
#elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lis2dw12/lis2dw12.h
View file

@ -126,7 +126,7 @@ struct lis2dw12_data {
sensor_trigger_handler_t double_tap_handler;
#endif /* CONFIG_LIS2DW12_PULSE */
#if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LIS2DW12_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2DW12_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lis2mdl/lis2mdl.h
View file

@ -70,7 +70,7 @@ struct lis2mdl_data {
struct device *dev;
#if defined(CONFIG_LIS2MDL_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LIS2MDL_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS2MDL_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LIS2MDL_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lis3mdl/lis3mdl.h
View file

@ -125,7 +125,7 @@ struct lis3mdl_data {
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_LIS3MDL_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LIS3MDL_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LIS3MDL_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_LIS3MDL_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lps22hh/lps22hh.h
View file

@ -73,7 +73,7 @@ struct lps22hh_data {
struct device *dev;
#if defined(CONFIG_LPS22HH_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LPS22HH_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LPS22HH_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LPS22HH_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lsm6dsl/lsm6dsl.h
View file

@ -657,7 +657,7 @@ struct lsm6dsl_data {
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_LSM6DSL_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LSM6DSL_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LSM6DSL_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lsm6dso/lsm6dso.h
View file

@ -180,7 +180,7 @@ struct lsm6dso_data {
struct device *dev;
#if defined(CONFIG_LSM6DSO_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_LSM6DSO_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_LSM6DSO_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_LSM6DSO_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/lsm9ds0_gyro/lsm9ds0_gyro.h
View file

@ -228,7 +228,7 @@ struct lsm9ds0_gyro_data {
#endif
#if defined(CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY)
K_THREAD_STACK_MEMBER(thread_stack,
K_KERNEL_STACK_MEMBER(thread_stack,
CONFIG_LSM9DS0_GYRO_THREAD_STACK_SIZE);
struct k_thread thread;
struct device *dev;

2
drivers/sensor/mcp9808/mcp9808_trigger.c
View file

@ -146,7 +146,7 @@ static void mcp9808_thread_main(int arg1, int arg2)
}
}
static K_THREAD_STACK_DEFINE(mcp9808_thread_stack, CONFIG_MCP9808_THREAD_STACK_SIZE);
static K_KERNEL_STACK_DEFINE(mcp9808_thread_stack, CONFIG_MCP9808_THREAD_STACK_SIZE);
static struct k_thread mcp9808_thread;
#else /* CONFIG_MCP9808_TRIGGER_GLOBAL_THREAD */

2
drivers/sensor/mpu6050/mpu6050.h
View file

@ -58,7 +58,7 @@ struct mpu6050_data {
sensor_trigger_handler_t data_ready_handler;
#if defined(CONFIG_MPU6050_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_MPU6050_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_MPU6050_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/sht3xd/sht3xd.h
View file

@ -76,7 +76,7 @@ struct sht3xd_data {
struct sensor_trigger trigger;
#if defined(CONFIG_SHT3XD_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_SHT3XD_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_SHT3XD_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_SHT3XD_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/stts751/stts751.h
View file

@ -57,7 +57,7 @@ struct stts751_data {
struct device *dev;
#if defined(CONFIG_STTS751_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_STTS751_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_STTS751_THREAD_STACK_SIZE);
struct k_thread thread;
struct k_sem gpio_sem;
#elif defined(CONFIG_STTS751_TRIGGER_GLOBAL_THREAD)

2
drivers/sensor/sx9500/sx9500_trigger.c
View file

@ -20,7 +20,7 @@
LOG_MODULE_DECLARE(SX9500, CONFIG_SENSOR_LOG_LEVEL);
#ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD
static K_THREAD_STACK_DEFINE(sx9500_thread_stack, CONFIG_SX9500_THREAD_STACK_SIZE);
static K_KERNEL_STACK_DEFINE(sx9500_thread_stack, CONFIG_SX9500_THREAD_STACK_SIZE);
static struct k_thread sx9500_thread;
#endif

2
drivers/sensor/tmp007/tmp007.h
View file

@ -49,7 +49,7 @@ struct tmp007_data {
struct sensor_trigger th_trigger;
#if defined(CONFIG_TMP007_TRIGGER_OWN_THREAD)
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_TMP007_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_TMP007_THREAD_STACK_SIZE);
struct k_sem gpio_sem;
struct k_thread thread;
#elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_THREAD)

2
drivers/serial/uart_miv.c
View file

@ -108,7 +108,7 @@
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
static struct k_thread rx_thread;
static K_THREAD_STACK_DEFINE(rx_stack, 512);
static K_KERNEL_STACK_DEFINE(rx_stack, 512);
#endif
struct uart_miv_regs_t {

2
drivers/usb/device/usb_dc_kinetis.c
View file

@ -110,7 +110,7 @@ struct usb_device_data {
struct usb_ep_ctrl_data ep_ctrl[NUM_OF_EP_MAX];
bool attached;
K_THREAD_STACK_MEMBER(thread_stack, USBD_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, USBD_THREAD_STACK_SIZE);
struct k_thread thread;
};

2
drivers/usb/device/usb_dc_native_posix.c
View file

@ -27,7 +27,7 @@ LOG_MODULE_REGISTER(native_posix);
#define USBIP_MAX_PACKET_SIZE 64
K_THREAD_STACK_MEMBER(thread_stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
static struct k_thread thread;
static void thread_main(void *a, void *b, void *c)

4
drivers/usb/device/usb_dc_nrfx.c
View file

@ -282,7 +282,7 @@ K_FIFO_DEFINE(usbd_evt_fifo);
* of a system work queue item waiting for a USB transfer to be finished.
*/
static struct k_work_q usbd_work_queue;
static K_THREAD_STACK_DEFINE(usbd_work_queue_stack,
static K_KERNEL_STACK_DEFINE(usbd_work_queue_stack,
CONFIG_USB_NRFX_WORK_QUEUE_STACK_SIZE);
@ -1331,7 +1331,7 @@ int usb_dc_attach(void)
k_work_q_start(&usbd_work_queue,
usbd_work_queue_stack,
K_THREAD_STACK_SIZEOF(usbd_work_queue_stack),
K_KERNEL_STACK_SIZEOF(usbd_work_queue_stack),
CONFIG_SYSTEM_WORKQUEUE_PRIORITY);
k_work_init(&ctx->usb_work, usbd_work_handler);

8
drivers/wifi/esp/esp.c
View file

@ -46,12 +46,12 @@ NET_BUF_POOL_DEFINE(mdm_recv_pool, MDM_RECV_MAX_BUF, MDM_RECV_BUF_SIZE,
0, NULL);
/* RX thread structures */
K_THREAD_STACK_DEFINE(esp_rx_stack,
K_KERNEL_STACK_DEFINE(esp_rx_stack,
CONFIG_WIFI_ESP_RX_STACK_SIZE);
struct k_thread esp_rx_thread;
/* RX thread work queue */
K_THREAD_STACK_DEFINE(esp_workq_stack,
K_KERNEL_STACK_DEFINE(esp_workq_stack,
CONFIG_WIFI_ESP_WORKQ_STACK_SIZE);
struct esp_data esp_driver_data;
@ -821,7 +821,7 @@ static int esp_init(struct device *dev)
/* initialize the work queue */
k_work_q_start(&data->workq, esp_workq_stack,
K_THREAD_STACK_SIZEOF(esp_workq_stack),
K_KERNEL_STACK_SIZEOF(esp_workq_stack),
K_PRIO_COOP(CONFIG_WIFI_ESP_WORKQ_THREAD_PRIORITY));
k_thread_name_set(&data->workq.thread, "esp_workq");
@ -868,7 +868,7 @@ static int esp_init(struct device *dev)
/* start RX thread */
k_thread_create(&esp_rx_thread, esp_rx_stack,
K_THREAD_STACK_SIZEOF(esp_rx_stack),
K_KERNEL_STACK_SIZEOF(esp_rx_stack),
(k_thread_entry_t)esp_rx,
dev, NULL, NULL,
K_PRIO_COOP(CONFIG_WIFI_ESP_RX_THREAD_PRIORITY), 0,

2
drivers/wifi/eswifi/eswifi_bus_spi.c
View file

@ -19,7 +19,7 @@ LOG_MODULE_DECLARE(LOG_MODULE_NAME);
#include "eswifi.h"
#define ESWIFI_SPI_THREAD_STACK_SIZE 1024
K_THREAD_STACK_MEMBER(eswifi_spi_poll_stack, ESWIFI_SPI_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(eswifi_spi_poll_stack, ESWIFI_SPI_THREAD_STACK_SIZE);
#define SPI_READ_CHUNK_SIZE 32

4
drivers/wifi/eswifi/eswifi_core.c
View file

@ -33,7 +33,7 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include "eswifi.h"
#define ESWIFI_WORKQUEUE_STACK_SIZE 1024
K_THREAD_STACK_DEFINE(eswifi_work_q_stack, ESWIFI_WORKQUEUE_STACK_SIZE);
K_KERNEL_STACK_DEFINE(eswifi_work_q_stack, ESWIFI_WORKQUEUE_STACK_SIZE);
static struct eswifi_dev eswifi0; /* static instance */
@ -666,7 +666,7 @@ static int eswifi_init(struct device *dev)
GPIO_OUTPUT_ACTIVE);
k_work_q_start(&eswifi->work_q, eswifi_work_q_stack,
K_THREAD_STACK_SIZEOF(eswifi_work_q_stack),
K_KERNEL_STACK_SIZEOF(eswifi_work_q_stack),
CONFIG_SYSTEM_WORKQUEUE_PRIORITY - 1);
k_work_init(&eswifi->request_work, eswifi_request_work);

2
drivers/wifi/winc1500/wifi_winc1500.c
View file

@ -127,7 +127,7 @@ NET_BUF_POOL_DEFINE(winc1500_tx_pool, CONFIG_WIFI_WINC1500_BUF_CTR,
NET_BUF_POOL_DEFINE(winc1500_rx_pool, CONFIG_WIFI_WINC1500_BUF_CTR,
CONFIG_WIFI_WINC1500_MAX_PACKET_SIZE, 0, NULL);
K_THREAD_STACK_MEMBER(winc1500_stack, CONFIG_WIFI_WINC1500_THREAD_STACK_SIZE);
K_KERNEL_STACK_MEMBER(winc1500_stack, CONFIG_WIFI_WINC1500_THREAD_STACK_SIZE);
struct k_thread winc1500_thread_data;
struct socket_data {