1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Bluetooth HCI serdev driver lib
4  *
5  *  Copyright (C) 2017  Linaro, Ltd., Rob Herring <robh@kernel.org>
6  *
7  *  Based on hci_ldisc.c:
8  *
9  *  Copyright (C) 2000-2001  Qualcomm Incorporated
10  *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
11  *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
12  */
13 
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/serdev.h>
17 #include <linux/skbuff.h>
18 
19 #include <net/bluetooth/bluetooth.h>
20 #include <net/bluetooth/hci_core.h>
21 
22 #include "hci_uart.h"
23 
24 static struct serdev_device_ops hci_serdev_client_ops;
25 
26 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
27 {
28 	struct hci_dev *hdev = hu->hdev;
29 
30 	/* Update HCI stat counters */
31 	switch (pkt_type) {
32 	case HCI_COMMAND_PKT:
33 		hdev->stat.cmd_tx++;
34 		break;
35 
36 	case HCI_ACLDATA_PKT:
37 		hdev->stat.acl_tx++;
38 		break;
39 
40 	case HCI_SCODATA_PKT:
41 		hdev->stat.sco_tx++;
42 		break;
43 	}
44 }
45 
46 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
47 {
48 	struct sk_buff *skb = hu->tx_skb;
49 
50 	if (!skb) {
51 		if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
52 			skb = hu->proto->dequeue(hu);
53 	} else
54 		hu->tx_skb = NULL;
55 
56 	return skb;
57 }
58 
59 static void hci_uart_write_work(struct work_struct *work)
60 {
61 	struct hci_uart *hu = container_of(work, struct hci_uart, write_work);
62 	struct serdev_device *serdev = hu->serdev;
63 	struct hci_dev *hdev = hu->hdev;
64 	struct sk_buff *skb;
65 
66 	/* REVISIT:
67 	 * should we cope with bad skbs or ->write() returning an error value?
68 	 */
69 	do {
70 		clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
71 
72 		while ((skb = hci_uart_dequeue(hu))) {
73 			int len;
74 
75 			len = serdev_device_write_buf(serdev,
76 						      skb->data, skb->len);
77 			hdev->stat.byte_tx += len;
78 
79 			skb_pull(skb, len);
80 			if (skb->len) {
81 				hu->tx_skb = skb;
82 				break;
83 			}
84 
85 			hci_uart_tx_complete(hu, hci_skb_pkt_type(skb));
86 			kfree_skb(skb);
87 		}
88 	} while (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state));
89 
90 	clear_bit(HCI_UART_SENDING, &hu->tx_state);
91 }
92 
93 /* ------- Interface to HCI layer ------ */
94 
95 /* Reset device */
96 static int hci_uart_flush(struct hci_dev *hdev)
97 {
98 	struct hci_uart *hu  = hci_get_drvdata(hdev);
99 
100 	BT_DBG("hdev %p serdev %p", hdev, hu->serdev);
101 
102 	if (hu->tx_skb) {
103 		kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
104 	}
105 
106 	/* Flush any pending characters in the driver and discipline. */
107 	serdev_device_write_flush(hu->serdev);
108 
109 	if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
110 		hu->proto->flush(hu);
111 
112 	return 0;
113 }
114 
115 /* Initialize device */
116 static int hci_uart_open(struct hci_dev *hdev)
117 {
118 	BT_DBG("%s %p", hdev->name, hdev);
119 
120 	/* Undo clearing this from hci_uart_close() */
121 	hdev->flush = hci_uart_flush;
122 
123 	return 0;
124 }
125 
126 /* Close device */
127 static int hci_uart_close(struct hci_dev *hdev)
128 {
129 	BT_DBG("hdev %p", hdev);
130 
131 	hci_uart_flush(hdev);
132 	hdev->flush = NULL;
133 
134 	return 0;
135 }
136 
137 /* Send frames from HCI layer */
138 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
139 {
140 	struct hci_uart *hu = hci_get_drvdata(hdev);
141 
142 	BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
143 	       skb->len);
144 
145 	hu->proto->enqueue(hu, skb);
146 
147 	hci_uart_tx_wakeup(hu);
148 
149 	return 0;
150 }
151 
152 static int hci_uart_setup(struct hci_dev *hdev)
153 {
154 	struct hci_uart *hu = hci_get_drvdata(hdev);
155 	struct hci_rp_read_local_version *ver;
156 	struct sk_buff *skb;
157 	unsigned int speed;
158 	int err;
159 
160 	/* Init speed if any */
161 	if (hu->init_speed)
162 		speed = hu->init_speed;
163 	else if (hu->proto->init_speed)
164 		speed = hu->proto->init_speed;
165 	else
166 		speed = 0;
167 
168 	if (speed)
169 		serdev_device_set_baudrate(hu->serdev, speed);
170 
171 	/* Operational speed if any */
172 	if (hu->oper_speed)
173 		speed = hu->oper_speed;
174 	else if (hu->proto->oper_speed)
175 		speed = hu->proto->oper_speed;
176 	else
177 		speed = 0;
178 
179 	if (hu->proto->set_baudrate && speed) {
180 		err = hu->proto->set_baudrate(hu, speed);
181 		if (err)
182 			bt_dev_err(hdev, "Failed to set baudrate");
183 		else
184 			serdev_device_set_baudrate(hu->serdev, speed);
185 	}
186 
187 	if (hu->proto->setup)
188 		return hu->proto->setup(hu);
189 
190 	if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags))
191 		return 0;
192 
193 	skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
194 			     HCI_INIT_TIMEOUT);
195 	if (IS_ERR(skb)) {
196 		bt_dev_err(hdev, "Reading local version info failed (%ld)",
197 			   PTR_ERR(skb));
198 		return 0;
199 	}
200 
201 	if (skb->len != sizeof(*ver))
202 		bt_dev_err(hdev, "Event length mismatch for version info");
203 
204 	kfree_skb(skb);
205 	return 0;
206 }
207 
208 /** hci_uart_write_wakeup - transmit buffer wakeup
209  * @serdev: serial device
210  *
211  * This function is called by the serdev framework when it accepts
212  * more data being sent.
213  */
214 static void hci_uart_write_wakeup(struct serdev_device *serdev)
215 {
216 	struct hci_uart *hu = serdev_device_get_drvdata(serdev);
217 
218 	BT_DBG("");
219 
220 	if (!hu || serdev != hu->serdev) {
221 		WARN_ON(1);
222 		return;
223 	}
224 
225 	if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
226 		hci_uart_tx_wakeup(hu);
227 }
228 
229 /** hci_uart_receive_buf - receive buffer wakeup
230  * @serdev: serial device
231  * @data:   pointer to received data
232  * @count:  count of received data in bytes
233  *
234  * This function is called by the serdev framework when it received data
235  * in the RX buffer.
236  *
237  * Return: number of processed bytes
238  */
239 static int hci_uart_receive_buf(struct serdev_device *serdev, const u8 *data,
240 				   size_t count)
241 {
242 	struct hci_uart *hu = serdev_device_get_drvdata(serdev);
243 
244 	if (!hu || serdev != hu->serdev) {
245 		WARN_ON(1);
246 		return 0;
247 	}
248 
249 	if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
250 		return 0;
251 
252 	/* It does not need a lock here as it is already protected by a mutex in
253 	 * tty caller
254 	 */
255 	hu->proto->recv(hu, data, count);
256 
257 	if (hu->hdev)
258 		hu->hdev->stat.byte_rx += count;
259 
260 	return count;
261 }
262 
263 static struct serdev_device_ops hci_serdev_client_ops = {
264 	.receive_buf = hci_uart_receive_buf,
265 	.write_wakeup = hci_uart_write_wakeup,
266 };
267 
268 int hci_uart_register_device(struct hci_uart *hu,
269 			     const struct hci_uart_proto *p)
270 {
271 	int err;
272 	struct hci_dev *hdev;
273 
274 	BT_DBG("");
275 
276 	serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops);
277 
278 	err = serdev_device_open(hu->serdev);
279 	if (err)
280 		return err;
281 
282 	err = p->open(hu);
283 	if (err)
284 		goto err_open;
285 
286 	hu->proto = p;
287 	set_bit(HCI_UART_PROTO_READY, &hu->flags);
288 
289 	/* Initialize and register HCI device */
290 	hdev = hci_alloc_dev();
291 	if (!hdev) {
292 		BT_ERR("Can't allocate HCI device");
293 		err = -ENOMEM;
294 		goto err_alloc;
295 	}
296 
297 	hu->hdev = hdev;
298 
299 	hdev->bus = HCI_UART;
300 	hci_set_drvdata(hdev, hu);
301 
302 	INIT_WORK(&hu->init_ready, hci_uart_init_work);
303 	INIT_WORK(&hu->write_work, hci_uart_write_work);
304 	percpu_init_rwsem(&hu->proto_lock);
305 
306 	/* Only when vendor specific setup callback is provided, consider
307 	 * the manufacturer information valid. This avoids filling in the
308 	 * value for Ericsson when nothing is specified.
309 	 */
310 	if (hu->proto->setup)
311 		hdev->manufacturer = hu->proto->manufacturer;
312 
313 	hdev->open  = hci_uart_open;
314 	hdev->close = hci_uart_close;
315 	hdev->flush = hci_uart_flush;
316 	hdev->send  = hci_uart_send_frame;
317 	hdev->setup = hci_uart_setup;
318 	SET_HCIDEV_DEV(hdev, &hu->serdev->dev);
319 
320 	if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
321 		set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
322 
323 	if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
324 		set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
325 
326 	if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
327 		hdev->dev_type = HCI_AMP;
328 	else
329 		hdev->dev_type = HCI_PRIMARY;
330 
331 	if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
332 		return 0;
333 
334 	if (hci_register_dev(hdev) < 0) {
335 		BT_ERR("Can't register HCI device");
336 		err = -ENODEV;
337 		goto err_register;
338 	}
339 
340 	set_bit(HCI_UART_REGISTERED, &hu->flags);
341 
342 	return 0;
343 
344 err_register:
345 	hci_free_dev(hdev);
346 err_alloc:
347 	clear_bit(HCI_UART_PROTO_READY, &hu->flags);
348 	p->close(hu);
349 err_open:
350 	serdev_device_close(hu->serdev);
351 	return err;
352 }
353 EXPORT_SYMBOL_GPL(hci_uart_register_device);
354 
355 void hci_uart_unregister_device(struct hci_uart *hu)
356 {
357 	struct hci_dev *hdev = hu->hdev;
358 
359 	clear_bit(HCI_UART_PROTO_READY, &hu->flags);
360 	hci_unregister_dev(hdev);
361 	hci_free_dev(hdev);
362 
363 	cancel_work_sync(&hu->write_work);
364 
365 	hu->proto->close(hu);
366 	serdev_device_close(hu->serdev);
367 }
368 EXPORT_SYMBOL_GPL(hci_uart_unregister_device);
369