Bluetooth: Host: Use a dedicated workqueue wherever possible

Avoid the system workqueue, and introduce a general purpose Bluetooth
workqueue that can be used in most situations.

Signed-off-by: Johan Hedberg <[email protected]>

Author: jhedberg

subsys/bluetooth/host/Kconfig

@@ -75,7 +75,6 @@ config BT_HCI_TX_PRIO
 
 choice BT_RECV_CONTEXT
 	prompt "BT RX Thread Selection"
-	default BT_RECV_WORKQ_SYS if SOC_SERIES_NRF51X
 	default BT_RECV_WORKQ_BT
 	help
 	  Selects in which context incoming low priority HCI packets are processed.
@@ -85,7 +84,8 @@ choice BT_RECV_CONTEXT
 	  packets are processed.
 
 config BT_RECV_WORKQ_SYS
-	bool "Process low priority HCI packets in the system work queue"
+	bool "Process low priority HCI packets in the system work queue [DEPRECATED]"
+	select DEPRECATED
 	help
 	  When this option is selected, the host will process incoming low priority HCI packets
 	  in the system work queue.
@@ -127,6 +127,20 @@ config BT_RX_PRIO
 	int
 	default 8
 
+config BT_WQ
+	bool
+	default y if BT_RECV_WORKQ_BT
+
+if BT_WQ
+config BT_WQ_STACK_SIZE
+	int
+	default BT_RX_STACK_SIZE
+
+config BT_WQ_PRIO
+	int
+	default BT_RX_PRIO
+endif
+
 config BT_DRIVER_RX_HIGH_PRIO
 	# Hidden option for Co-Operative HCI driver RX thread priority
 	int

subsys/bluetooth/host/adv.c

@@ -1318,8 +1318,8 @@ int bt_le_adv_start(const struct bt_le_adv_param *param,
 
 	if (ad_is_limited(ad, ad_len)) {
 		k_work_init_delayable(&adv->lim_adv_timeout_work, adv_timeout);
-		k_work_reschedule(&adv->lim_adv_timeout_work,
-				  K_SECONDS(CONFIG_BT_LIM_ADV_TIMEOUT));
+		bt_work_reschedule(&adv->lim_adv_timeout_work,
+				   K_SECONDS(CONFIG_BT_LIM_ADV_TIMEOUT));
 	}
 
 	return err;

subsys/bluetooth/host/att.c

@@ -625,7 +625,7 @@ static void chan_rebegin_att_timeout(struct bt_att_tx_meta_data *user_data)
 	 * in-flight.
 	 */
 	if (chan->req) {
-		k_work_reschedule(&chan->timeout_work, BT_ATT_TIMEOUT);
+		bt_work_reschedule(&chan->timeout_work, BT_ATT_TIMEOUT);
 	}
 }
 
@@ -3544,8 +3544,8 @@ static int att_schedule_eatt_connect(struct bt_conn *conn, uint8_t chans_to_conn
 
 	att->eatt.chans_to_connect = chans_to_connect;
 
-	return k_work_reschedule(&att->eatt.connection_work,
-				 credit_based_connection_delay(conn));
+	return bt_work_reschedule(&att->eatt.connection_work,
+				  credit_based_connection_delay(conn));
 }
 
 static void handle_potential_collision(struct bt_att *att)

subsys/bluetooth/host/classic/avctp.c

@@ -63,7 +63,7 @@ static void avctp_tx_raise(int msec)
 		return;
 	}
 	LOG_DBG("kick TX");
-	k_work_schedule(&avctp_tx_work, K_MSEC(msec));
+	bt_work_schedule(&avctp_tx_work, K_MSEC(msec));
 }
 
 static void bt_avctp_clear_tx(struct bt_avctp *session)

subsys/bluetooth/host/classic/avdtp.c

@@ -288,7 +288,7 @@ static void avdtp_tx_raise(void)
 {
 	if (!sys_slist_is_empty(&avdtp_tx_list)) {
 		LOG_DBG("kick TX");
-		k_work_submit(&avdtp_tx_work);
+		bt_work_submit(&avdtp_tx_work);
 	}
 }
 
@@ -1390,7 +1390,7 @@ static int avdtp_send_cmd(struct bt_avdtp *session, struct net_buf *buf, struct
 	/* Initialize and start timeout timer */
 	k_work_init_delayable(&session->timeout_work, avdtp_timeout);
 	/* Start timeout work */
-	k_work_reschedule(&session->timeout_work, AVDTP_TIMEOUT);
+	bt_work_reschedule(&session->timeout_work, AVDTP_TIMEOUT);
 
 	return 0;
 }

subsys/bluetooth/host/classic/br.c

@@ -1259,8 +1259,8 @@ int bt_br_set_discoverable(bool enable, bool limited)
 		err = write_scan_enable(BT_BREDR_SCAN_INQUIRY | BT_BREDR_SCAN_PAGE);
 		if (!err && (limited == true)) {
 			atomic_set_bit(bt_dev.flags, BT_DEV_LIMITED_DISCOVERABLE_MODE);
-			k_work_reschedule(&bt_br_limited_discoverable_timeout,
-					  K_SECONDS(CONFIG_BT_LIMITED_DISCOVERABLE_DURATION));
+			bt_work_reschedule(&bt_br_limited_discoverable_timeout,
+					   K_SECONDS(CONFIG_BT_LIMITED_DISCOVERABLE_DURATION));
 		}
 		return err;
 	}

subsys/bluetooth/host/classic/hfp_ag.c

@@ -429,7 +429,7 @@ static int hfp_ag_send_data(struct bt_hfp_ag *ag, bt_hfp_ag_tx_cb_t cb, void *us
 	hfp_ag_unlock(ag);
 
 	/* Always active tx work */
-	k_work_reschedule(&ag->tx_work, K_NO_WAIT);
+	bt_work_reschedule(&ag->tx_work, K_NO_WAIT);
 
 	return 0;
 
@@ -724,20 +724,20 @@ static void bt_hfp_ag_set_call_state(struct bt_hfp_ag_call *call, bt_hfp_call_st
 		free_call(call);
 		break;
 	case BT_HFP_CALL_OUTGOING:
-		k_work_reschedule(&call->deferred_work,
+		bt_work_reschedule(&call->deferred_work,
 				  K_SECONDS(CONFIG_BT_HFP_AG_OUTGOING_TIMEOUT));
 		break;
 	case BT_HFP_CALL_INCOMING:
-		k_work_reschedule(&call->deferred_work,
+		bt_work_reschedule(&call->deferred_work,
 				  K_SECONDS(CONFIG_BT_HFP_AG_INCOMING_TIMEOUT));
 		break;
 	case BT_HFP_CALL_ALERTING:
 		if (!atomic_test_bit(call->flags, BT_HFP_AG_CALL_INCOMING_3WAY)) {
-			k_work_reschedule(&call->ringing_work, K_NO_WAIT);
+			bt_work_reschedule(&call->ringing_work, K_NO_WAIT);
 		} else {
 			k_work_cancel_delayable(&call->ringing_work);
 		}
-		k_work_reschedule(&call->deferred_work,
+		bt_work_reschedule(&call->deferred_work,
 				  K_SECONDS(CONFIG_BT_HFP_AG_ALERTING_TIMEOUT));
 		break;
 	case BT_HFP_CALL_ACTIVE:
@@ -872,7 +872,7 @@ static void bt_ag_tx_work(struct k_work *work)
 				LOG_WRN("tx ongoing flag is not set");
 			}
 			/* Due to the work is failed, restart the tx work */
-			k_work_reschedule(&ag->tx_work, K_NO_WAIT);
+			bt_work_reschedule(&ag->tx_work, K_NO_WAIT);
 		}
 	}
 
@@ -1162,7 +1162,7 @@ static int bt_hfp_ag_cind_handler(struct bt_hfp_ag *ag, struct net_buf *buf)
 		} else {
 			err = -EINPROGRESS;
 			atomic_set_bit(ag->flags, BT_HGP_AG_ONGOING_CALLS);
-			k_work_reschedule(&ag->ongoing_call_work,
+			bt_work_reschedule(&ag->ongoing_call_work,
 					  K_MSEC(CONFIG_BT_HFP_AG_GET_ONGOING_CALL_TIMEOUT));
 		}
 	}
@@ -3595,7 +3595,7 @@ static void hfp_ag_sent(struct bt_rfcomm_dlc *dlc, int err)
 	LOG_DBG("Completed pending tx %p", tx);
 
 	/* Restart the tx work */
-	k_work_reschedule(&ag->tx_work, K_NO_WAIT);
+	bt_work_reschedule(&ag->tx_work, K_NO_WAIT);
 
 	tx->err = err;
 	k_fifo_put(&ag_tx_notify, tx);
@@ -3739,7 +3739,7 @@ static void bt_ag_ringing_work_cb(struct bt_hfp_ag *ag, void *user_data)
 			return;
 		}
 
-		k_work_reschedule(&call->ringing_work,
+		bt_work_reschedule(&call->ringing_work,
 				  K_SECONDS(CONFIG_BT_HFP_AG_RING_NOTIFY_INTERVAL));
 
 		err = hfp_ag_send_data(ag, NULL, NULL, "\r\nRING\r\n");

subsys/bluetooth/host/classic/l2cap_br.c

@@ -445,29 +445,29 @@ static void l2cap_br_start_timer(struct bt_l2cap_br_chan *br_chan, enum l2cap_br
 	if (type == BT_L2CAP_BR_TIMER_RET) {
 		if (!atomic_test_and_set_bit(br_chan->flags, L2CAP_FLAG_RET_TIMER)) {
 			k_work_cancel_delayable(&br_chan->monitor_work);
-			k_work_schedule(&br_chan->ret_work, K_MSEC(br_chan->tx.ret_timeout));
+			bt_work_schedule(&br_chan->ret_work, K_MSEC(br_chan->tx.ret_timeout));
 			LOG_DBG("Start ret timer");
 		} else {
 			if (!restart) {
 				return;
 			}
 
-			k_work_reschedule(&br_chan->ret_work, K_MSEC(br_chan->tx.ret_timeout));
+			bt_work_reschedule(&br_chan->ret_work, K_MSEC(br_chan->tx.ret_timeout));
 			LOG_DBG("Restart ret timer");
 		}
 	} else {
 		if (atomic_test_and_clear_bit(br_chan->flags, L2CAP_FLAG_RET_TIMER)) {
 			k_work_cancel_delayable(&br_chan->ret_work);
-			k_work_schedule(&br_chan->monitor_work,
-					K_MSEC(br_chan->tx.monitor_timeout));
+			bt_work_schedule(&br_chan->monitor_work,
+					 K_MSEC(br_chan->tx.monitor_timeout));
 			LOG_DBG("Start monitor timer");
 		} else {
 			if (!restart) {
 				return;
 			}
 
-			k_work_reschedule(&br_chan->monitor_work,
-					  K_MSEC(br_chan->tx.monitor_timeout));
+			bt_work_reschedule(&br_chan->monitor_work,
+					   K_MSEC(br_chan->tx.monitor_timeout));
 			LOG_DBG("Restart monitor timer");
 		}
 	}
@@ -743,7 +743,7 @@ static void l2cap_br_ret_timeout(struct k_work *work)
 
 	/* Restart the timer */
 	if (atomic_test_bit(br_chan->flags, L2CAP_FLAG_RET_TIMER)) {
-		k_work_schedule(&br_chan->ret_work, K_MSEC(br_chan->tx.ret_timeout));
+		bt_work_schedule(&br_chan->ret_work, K_MSEC(br_chan->tx.ret_timeout));
 	}
 
 	LOG_DBG("chan %p retransmission timeout", br_chan);
@@ -812,7 +812,7 @@ static void l2cap_br_monitor_timeout(struct k_work *work)
 
 	/* Restart the timer */
 	if (!atomic_test_bit(br_chan->flags, L2CAP_FLAG_RET_TIMER)) {
-		k_work_schedule(&br_chan->monitor_work, K_MSEC(br_chan->tx.monitor_timeout));
+		bt_work_schedule(&br_chan->monitor_work, K_MSEC(br_chan->tx.monitor_timeout));
 	}
 
 	LOG_DBG("chan %p monitor timeout", br_chan);
@@ -974,7 +974,7 @@ static void l2cap_br_chan_send_req(struct bt_l2cap_br_chan *chan,
 	 * final expiration, when the response is received, or the physical
 	 * link is lost.
 	 */
-	k_work_reschedule(&chan->rtx_work, timeout);
+	bt_work_reschedule(&chan->rtx_work, timeout);
 }
 
 #if defined(CONFIG_BT_L2CAP_RET_FC)
@@ -4913,7 +4913,7 @@ static void l2cap_br_conn_rsp(struct bt_l2cap_br *l2cap, uint8_t ident, struct n
 		break;
 	case BT_L2CAP_BR_PENDING:
 		br_chan->ident = ident;
-		k_work_reschedule(&br_chan->rtx_work, L2CAP_BR_CONN_TIMEOUT);
+		bt_work_reschedule(&br_chan->rtx_work, L2CAP_BR_CONN_TIMEOUT);
 		break;
 	default:
 		l2cap_br_chan_cleanup(chan);

subsys/bluetooth/host/classic/rfcomm.c

@@ -242,7 +242,7 @@ static void rfcomm_dlc_tx_trigger(struct bt_rfcomm_dlc *dlc)
 
 	LOG_DBG("DLC %p TX trigger", dlc);
 
-	err = k_work_submit(&dlc->tx_work);
+	err = bt_work_submit(&dlc->tx_work);
 	if (err < 0) {
 		LOG_ERR("Failed to submit tx work: %d", err);
 	}
@@ -408,7 +408,7 @@ static void rfcomm_session_disconnect(struct bt_rfcomm_session *session)
 
 	session->state = BT_RFCOMM_STATE_DISCONNECTING;
 	rfcomm_send_disc(session, 0);
-	k_work_reschedule(&session->rtx_work, RFCOMM_DISC_TIMEOUT);
+	bt_work_reschedule(&session->rtx_work, RFCOMM_DISC_TIMEOUT);
 }
 
 static struct net_buf *rfcomm_make_uih_msg(struct bt_rfcomm_session *session,
@@ -498,7 +498,7 @@ static void rfcomm_dlc_init(struct bt_rfcomm_dlc *dlc,
 	k_work_init_delayable(&dlc->rtx_work, rfcomm_dlc_rtx_timeout);
 
 	/* Start a conn timer which includes auth as well */
-	k_work_schedule(&dlc->rtx_work, RFCOMM_CONN_TIMEOUT);
+	bt_work_schedule(&dlc->rtx_work, RFCOMM_CONN_TIMEOUT);
 
 	dlc->_next = session->dlcs;
 	session->dlcs = dlc;
@@ -686,7 +686,7 @@ static void rfcomm_dlc_tx_worker(struct k_work *work)
 
 	if (dlc->state == BT_RFCOMM_STATE_DISCONNECTING) {
 		rfcomm_send_disc(dlc->session, dlc->dlci);
-		k_work_reschedule(&dlc->rtx_work, RFCOMM_DISC_TIMEOUT);
+		bt_work_reschedule(&dlc->rtx_work, RFCOMM_DISC_TIMEOUT);
 	} else {
 		rfcomm_dlc_destroy(dlc);
 	}
@@ -955,7 +955,7 @@ static int rfcomm_dlc_close(struct bt_rfcomm_dlc *dlc)
 	case BT_RFCOMM_STATE_CONFIG:
 		dlc->state = BT_RFCOMM_STATE_DISCONNECTING;
 		rfcomm_send_disc(dlc->session, dlc->dlci);
-		k_work_reschedule(&dlc->rtx_work, RFCOMM_DISC_TIMEOUT);
+		bt_work_reschedule(&dlc->rtx_work, RFCOMM_DISC_TIMEOUT);
 		break;
 	case BT_RFCOMM_STATE_CONNECTED:
 		dlc->state = BT_RFCOMM_STATE_DISCONNECTING;
@@ -1375,8 +1375,8 @@ static void rfcomm_handle_disc(struct bt_rfcomm_session *session, uint8_t dlci)
 
 		if (!session->dlcs) {
 			/* Start a session idle timer */
-			k_work_reschedule(&dlc->session->rtx_work,
-					  RFCOMM_IDLE_TIMEOUT);
+			bt_work_reschedule(&dlc->session->rtx_work,
+					   RFCOMM_IDLE_TIMEOUT);
 		}
 	} else {
 		/* Cancel idle timer */
@@ -1834,7 +1834,7 @@ int bt_rfcomm_dlc_disconnect(struct bt_rfcomm_dlc *dlc)
 		 */
 		dlc->state = BT_RFCOMM_STATE_USER_DISCONNECT;
 		rfcomm_dlc_tx_trigger(dlc);
-		k_work_reschedule(&dlc->rtx_work, RFCOMM_DISC_TIMEOUT);
+		bt_work_reschedule(&dlc->rtx_work, RFCOMM_DISC_TIMEOUT);
 
 		return 0;
 	}

subsys/bluetooth/host/conn.c

@@ -1219,8 +1219,7 @@ void bt_conn_set_state(struct bt_conn *conn, bt_conn_state_t state)
 			}
 #endif /* CONFIG_BT_GAP_AUTO_UPDATE_CONN_PARAMS */
 
-			k_work_schedule(&conn->deferred_work,
-					CONN_UPDATE_TIMEOUT);
+			k_work_schedule(&conn->deferred_work, CONN_UPDATE_TIMEOUT);
 		}
 #endif /* CONFIG_BT_CONN */
 
@@ -1832,7 +1831,7 @@ static K_WORK_DEFINE(procedures_on_connect, auto_initiated_procedures);
 static void schedule_auto_initiated_procedures(struct bt_conn *conn)
 {
 	LOG_DBG("[%p] Scheduling auto-init procedures", conn);
-	k_work_submit(&procedures_on_connect);
+	bt_work_submit(&procedures_on_connect);
 }
 
 void bt_conn_connected(struct bt_conn *conn)