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