Commit | Line | Data |
---|---|---|
c942fddf | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
82f5169b RH |
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> | |
82f5169b RH |
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 | ||
640e32c9 | 24 | static struct serdev_device_ops hci_serdev_client_ops; |
82f5169b RH |
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 | ||
5a637751 BG |
50 | if (!skb) { |
51 | if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) | |
52 | skb = hu->proto->dequeue(hu); | |
53 | } else | |
82f5169b RH |
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 | } | |
ea9ed991 | 88 | } while (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state)); |
82f5169b RH |
89 | |
90 | clear_bit(HCI_UART_SENDING, &hu->tx_state); | |
91 | } | |
92 | ||
93 | /* ------- Interface to HCI layer ------ */ | |
94 | ||
82f5169b RH |
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 | ||
412fe29f HG |
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 | ||
82f5169b RH |
126 | /* Close device */ |
127 | static int hci_uart_close(struct hci_dev *hdev) | |
128 | { | |
82f5169b RH |
129 | BT_DBG("hdev %p", hdev); |
130 | ||
131 | hci_uart_flush(hdev); | |
132 | hdev->flush = NULL; | |
133 | ||
82f5169b RH |
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) | |
2064ee33 | 182 | bt_dev_err(hdev, "Failed to set baudrate"); |
82f5169b RH |
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)) { | |
2064ee33 MH |
196 | bt_dev_err(hdev, "Reading local version info failed (%ld)", |
197 | PTR_ERR(skb)); | |
82f5169b RH |
198 | return 0; |
199 | } | |
200 | ||
0c0c09ff | 201 | if (skb->len != sizeof(*ver)) |
2064ee33 | 202 | bt_dev_err(hdev, "Event length mismatch for version info"); |
82f5169b RH |
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 | ||
640e32c9 | 263 | static struct serdev_device_ops hci_serdev_client_ops = { |
82f5169b RH |
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 | ||
52b318e6 SR |
276 | serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops); |
277 | ||
e9ca0807 | 278 | err = serdev_device_open(hu->serdev); |
82f5169b RH |
279 | if (err) |
280 | return err; | |
281 | ||
e9ca0807 HG |
282 | err = p->open(hu); |
283 | if (err) | |
284 | goto err_open; | |
285 | ||
82f5169b RH |
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 | ||
fdee6d8f | 302 | INIT_WORK(&hu->init_ready, hci_uart_init_work); |
82f5169b | 303 | INIT_WORK(&hu->write_work, hci_uart_write_work); |
d73e1728 | 304 | percpu_init_rwsem(&hu->proto_lock); |
82f5169b RH |
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 | ||
82f5169b RH |
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); | |
e9ca0807 HG |
349 | err_open: |
350 | serdev_device_close(hu->serdev); | |
82f5169b RH |
351 | return err; |
352 | } | |
081f36a8 | 353 | EXPORT_SYMBOL_GPL(hci_uart_register_device); |
c34dc3bf IM |
354 | |
355 | void hci_uart_unregister_device(struct hci_uart *hu) | |
356 | { | |
357 | struct hci_dev *hdev = hu->hdev; | |
358 | ||
7cf7846d | 359 | clear_bit(HCI_UART_PROTO_READY, &hu->flags); |
c34dc3bf IM |
360 | hci_unregister_dev(hdev); |
361 | hci_free_dev(hdev); | |
362 | ||
363 | cancel_work_sync(&hu->write_work); | |
364 | ||
365 | hu->proto->close(hu); | |
e9ca0807 | 366 | serdev_device_close(hu->serdev); |
c34dc3bf IM |
367 | } |
368 | EXPORT_SYMBOL_GPL(hci_uart_unregister_device); |