blob: f19606019eb010cac1460da9f831451b4346e8ac [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
Marcel Holtmann0372a662005-10-28 19:20:45 +02003 * Bluetooth HCI UART driver
4 *
5 * Copyright (C) 2000-2001 Qualcomm Incorporated
6 * Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
7 * Copyright (C) 2004-2005 Marcel Holtmann <marcel@holtmann.org>
8 *
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/module.h>
27
28#include <linux/kernel.h>
29#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/types.h>
31#include <linux/fcntl.h>
32#include <linux/interrupt.h>
33#include <linux/ptrace.h>
34#include <linux/poll.h>
35
36#include <linux/slab.h>
37#include <linux/tty.h>
38#include <linux/errno.h>
39#include <linux/string.h>
40#include <linux/signal.h>
41#include <linux/ioctl.h>
42#include <linux/skbuff.h>
Frederic Danis18aeb442015-05-28 11:25:01 +020043#include <linux/firmware.h>
Hans de Goede56ea88e2017-10-04 20:43:35 +020044#include <linux/serdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#include <net/bluetooth/bluetooth.h>
47#include <net/bluetooth/hci_core.h>
48
Marcel Holtmannbca03c92015-04-06 00:52:14 -070049#include "btintel.h"
Marcel Holtmann3e0ac122015-04-05 22:52:12 -070050#include "btbcm.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include "hci_uart.h"
52
Marcel Holtmann788a6752015-04-04 22:36:04 -070053#define VERSION "2.3"
Marcel Holtmann0372a662005-10-28 19:20:45 +020054
Marcel Holtmann4ee7ef12015-04-04 22:11:43 -070055static const struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Marcel Holtmann4ee7ef12015-04-04 22:11:43 -070057int hci_uart_register_proto(const struct hci_uart_proto *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
59 if (p->id >= HCI_UART_MAX_PROTO)
60 return -EINVAL;
61
62 if (hup[p->id])
63 return -EEXIST;
64
65 hup[p->id] = p;
Marcel Holtmann0372a662005-10-28 19:20:45 +020066
Marcel Holtmann01009ee2015-04-04 22:27:35 -070067 BT_INFO("HCI UART protocol %s registered", p->name);
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 return 0;
70}
71
Marcel Holtmann4ee7ef12015-04-04 22:11:43 -070072int hci_uart_unregister_proto(const struct hci_uart_proto *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073{
74 if (p->id >= HCI_UART_MAX_PROTO)
75 return -EINVAL;
76
77 if (!hup[p->id])
78 return -EINVAL;
79
80 hup[p->id] = NULL;
Marcel Holtmann0372a662005-10-28 19:20:45 +020081
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 return 0;
83}
84
Marcel Holtmann4ee7ef12015-04-04 22:11:43 -070085static const struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086{
87 if (id >= HCI_UART_MAX_PROTO)
88 return NULL;
Marcel Holtmann0372a662005-10-28 19:20:45 +020089
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 return hup[id];
91}
92
93static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
94{
95 struct hci_dev *hdev = hu->hdev;
Marcel Holtmann0372a662005-10-28 19:20:45 +020096
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 /* Update HCI stat counters */
98 switch (pkt_type) {
99 case HCI_COMMAND_PKT:
100 hdev->stat.cmd_tx++;
101 break;
102
103 case HCI_ACLDATA_PKT:
104 hdev->stat.acl_tx++;
105 break;
106
107 case HCI_SCODATA_PKT:
Karl Beldan7f8f2722010-10-07 21:57:10 +0200108 hdev->stat.sco_tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 break;
110 }
111}
112
113static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
114{
115 struct sk_buff *skb = hu->tx_skb;
Marcel Holtmann0372a662005-10-28 19:20:45 +0200116
Dean Jenkins048e1bd2017-04-28 13:57:25 +0100117 if (!skb) {
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700118 percpu_down_read(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100119
Dean Jenkins048e1bd2017-04-28 13:57:25 +0100120 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
121 skb = hu->proto->dequeue(hu);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100122
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700123 percpu_up_read(&hu->proto_lock);
Dean Jenkins048e1bd2017-04-28 13:57:25 +0100124 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 hu->tx_skb = NULL;
Dean Jenkins048e1bd2017-04-28 13:57:25 +0100126 }
Marcel Holtmann0372a662005-10-28 19:20:45 +0200127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 return skb;
129}
130
131int hci_uart_tx_wakeup(struct hci_uart *hu)
132{
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700133 /* This may be called in an IRQ context, so we can't sleep. Therefore
134 * we try to acquire the lock only, and if that fails we assume the
135 * tty is being closed because that is the only time the write lock is
136 * acquired. If, however, at some point in the future the write lock
137 * is also acquired in other situations, then this must be revisited.
138 */
139 if (!percpu_down_read_trylock(&hu->proto_lock))
140 return 0;
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100141
Dean Jenkins2d6f1da2017-04-28 13:57:26 +0100142 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100143 goto no_schedule;
Dean Jenkins2d6f1da2017-04-28 13:57:26 +0100144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) {
146 set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100147 goto no_schedule;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 }
149
150 BT_DBG("");
151
Felipe Balbida64c272014-04-23 09:58:26 -0500152 schedule_work(&hu->write_work);
153
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100154no_schedule:
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700155 percpu_up_read(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100156
Felipe Balbida64c272014-04-23 09:58:26 -0500157 return 0;
158}
Sebastian Reichel081f36a2017-03-28 17:59:37 +0200159EXPORT_SYMBOL_GPL(hci_uart_tx_wakeup);
Felipe Balbida64c272014-04-23 09:58:26 -0500160
161static void hci_uart_write_work(struct work_struct *work)
162{
163 struct hci_uart *hu = container_of(work, struct hci_uart, write_work);
164 struct tty_struct *tty = hu->tty;
165 struct hci_dev *hdev = hu->hdev;
166 struct sk_buff *skb;
167
168 /* REVISIT: should we cope with bad skbs or ->write() returning
169 * and error value ?
170 */
171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172restart:
173 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
174
175 while ((skb = hci_uart_dequeue(hu))) {
176 int len;
Marcel Holtmann0372a662005-10-28 19:20:45 +0200177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
Alan Coxf34d7a52008-04-30 00:54:13 -0700179 len = tty->ops->write(tty, skb->data, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 hdev->stat.byte_tx += len;
181
182 skb_pull(skb, len);
183 if (skb->len) {
184 hu->tx_skb = skb;
185 break;
186 }
Marcel Holtmann0372a662005-10-28 19:20:45 +0200187
Marcel Holtmann618e8bc2015-11-05 07:33:56 +0100188 hci_uart_tx_complete(hu, hci_skb_pkt_type(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 kfree_skb(skb);
Marcel Holtmann0372a662005-10-28 19:20:45 +0200190 }
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
193 goto restart;
194
195 clear_bit(HCI_UART_SENDING, &hu->tx_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196}
197
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300198static void hci_uart_init_work(struct work_struct *work)
199{
200 struct hci_uart *hu = container_of(work, struct hci_uart, init_ready);
201 int err;
Dean Jenkinsa225b8c2017-04-20 18:06:40 +0100202 struct hci_dev *hdev;
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300203
204 if (!test_and_clear_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
205 return;
206
207 err = hci_register_dev(hu->hdev);
208 if (err < 0) {
209 BT_ERR("Can't register HCI device");
Jeremy Cline6ea83d92019-02-06 12:54:16 -0500210 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
211 hu->proto->close(hu);
Dean Jenkinsa225b8c2017-04-20 18:06:40 +0100212 hdev = hu->hdev;
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300213 hu->hdev = NULL;
Dean Jenkinsa225b8c2017-04-20 18:06:40 +0100214 hci_free_dev(hdev);
Dean Jenkinscb926522017-04-20 18:06:39 +0100215 return;
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300216 }
217
218 set_bit(HCI_UART_REGISTERED, &hu->flags);
219}
220
221int hci_uart_init_ready(struct hci_uart *hu)
222{
223 if (!test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
224 return -EALREADY;
225
226 schedule_work(&hu->init_ready);
227
228 return 0;
229}
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231/* ------- Interface to HCI layer ------ */
232/* Initialize device */
233static int hci_uart_open(struct hci_dev *hdev)
234{
235 BT_DBG("%s %p", hdev->name, hdev);
236
237 /* Nothing to do for UART driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 return 0;
239}
240
241/* Reset device */
242static int hci_uart_flush(struct hci_dev *hdev)
243{
David Herrmann155961e2012-02-09 21:58:32 +0100244 struct hci_uart *hu = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 struct tty_struct *tty = hu->tty;
246
247 BT_DBG("hdev %p tty %p", hdev, tty);
248
249 if (hu->tx_skb) {
250 kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
251 }
252
253 /* Flush any pending characters in the driver and discipline. */
254 tty_ldisc_flush(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -0700255 tty_driver_flush_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700257 percpu_down_read(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100258
Loic Poulain84cb3df2016-04-04 10:48:13 +0200259 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 hu->proto->flush(hu);
261
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700262 percpu_up_read(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 return 0;
265}
266
267/* Close device */
268static int hci_uart_close(struct hci_dev *hdev)
269{
270 BT_DBG("hdev %p", hdev);
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 hci_uart_flush(hdev);
David Newall3611f4d2008-02-11 21:41:30 -0800273 hdev->flush = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 return 0;
275}
276
277/* Send frames from HCI layer */
Marcel Holtmann7bd8f092013-10-11 06:19:18 -0700278static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Marcel Holtmann52bc4232013-10-11 07:01:03 -0700280 struct hci_uart *hu = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Marcel Holtmann618e8bc2015-11-05 07:33:56 +0100282 BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
283 skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700285 percpu_down_read(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100286
287 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700288 percpu_up_read(&hu->proto_lock);
Dean Jenkinsab00f892017-04-28 13:57:24 +0100289 return -EUNATCH;
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100290 }
Dean Jenkinsab00f892017-04-28 13:57:24 +0100291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 hu->proto->enqueue(hu, skb);
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700293 percpu_up_read(&hu->proto_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
295 hci_uart_tx_wakeup(hu);
Marcel Holtmann0372a662005-10-28 19:20:45 +0200296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 return 0;
298}
299
Vladis Dronov69f9c2b2019-07-30 11:33:45 +0200300/* Check the underlying device or tty has flow control support */
301bool hci_uart_has_flow_control(struct hci_uart *hu)
302{
303 /* serdev nodes check if the needed operations are present */
304 if (hu->serdev)
305 return true;
306
307 if (hu->tty->driver->ops->tiocmget && hu->tty->driver->ops->tiocmset)
308 return true;
309
310 return false;
311}
312
Ilya Faenson2a973df2015-06-17 17:30:56 -0400313/* Flow control or un-flow control the device */
314void hci_uart_set_flow_control(struct hci_uart *hu, bool enable)
315{
316 struct tty_struct *tty = hu->tty;
317 struct ktermios ktermios;
318 int status;
319 unsigned int set = 0;
320 unsigned int clear = 0;
321
Hans de Goede56ea88e2017-10-04 20:43:35 +0200322 if (hu->serdev) {
323 serdev_device_set_flow_control(hu->serdev, !enable);
324 serdev_device_set_rts(hu->serdev, !enable);
325 return;
326 }
327
Ilya Faenson2a973df2015-06-17 17:30:56 -0400328 if (enable) {
329 /* Disable hardware flow control */
330 ktermios = tty->termios;
331 ktermios.c_cflag &= ~CRTSCTS;
332 status = tty_set_termios(tty, &ktermios);
333 BT_DBG("Disabling hardware flow control: %s",
334 status ? "failed" : "success");
335
336 /* Clear RTS to prevent the device from sending */
337 /* Most UARTs need OUT2 to enable interrupts */
338 status = tty->driver->ops->tiocmget(tty);
339 BT_DBG("Current tiocm 0x%x", status);
340
341 set &= ~(TIOCM_OUT2 | TIOCM_RTS);
342 clear = ~set;
343 set &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
344 TIOCM_OUT2 | TIOCM_LOOP;
345 clear &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
346 TIOCM_OUT2 | TIOCM_LOOP;
347 status = tty->driver->ops->tiocmset(tty, set, clear);
348 BT_DBG("Clearing RTS: %s", status ? "failed" : "success");
349 } else {
350 /* Set RTS to allow the device to send again */
351 status = tty->driver->ops->tiocmget(tty);
352 BT_DBG("Current tiocm 0x%x", status);
353
354 set |= (TIOCM_OUT2 | TIOCM_RTS);
355 clear = ~set;
356 set &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
357 TIOCM_OUT2 | TIOCM_LOOP;
358 clear &= TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 |
359 TIOCM_OUT2 | TIOCM_LOOP;
360 status = tty->driver->ops->tiocmset(tty, set, clear);
361 BT_DBG("Setting RTS: %s", status ? "failed" : "success");
362
363 /* Re-enable hardware flow control */
364 ktermios = tty->termios;
365 ktermios.c_cflag |= CRTSCTS;
366 status = tty_set_termios(tty, &ktermios);
367 BT_DBG("Enabling hardware flow control: %s",
368 status ? "failed" : "success");
369 }
370}
371
372void hci_uart_set_speeds(struct hci_uart *hu, unsigned int init_speed,
373 unsigned int oper_speed)
374{
375 hu->init_speed = init_speed;
376 hu->oper_speed = oper_speed;
377}
378
Frederic Danis77213832015-05-28 11:25:03 +0200379void hci_uart_set_baudrate(struct hci_uart *hu, unsigned int speed)
380{
381 struct tty_struct *tty = hu->tty;
382 struct ktermios ktermios;
383
384 ktermios = tty->termios;
385 ktermios.c_cflag &= ~CBAUD;
Frederic Danis77213832015-05-28 11:25:03 +0200386 tty_termios_encode_baud_rate(&ktermios, speed, speed);
387
388 /* tty_set_termios() return not checked as it is always 0 */
389 tty_set_termios(tty, &ktermios);
390
Ilya Faenson2a973df2015-06-17 17:30:56 -0400391 BT_DBG("%s: New tty speeds: %d/%d", hu->hdev->name,
392 tty->termios.c_ispeed, tty->termios.c_ospeed);
Frederic Danis77213832015-05-28 11:25:03 +0200393}
394
Loic Poulaineb173802015-03-25 15:19:30 +0100395static int hci_uart_setup(struct hci_dev *hdev)
396{
397 struct hci_uart *hu = hci_get_drvdata(hdev);
Marcel Holtmannfb2ce8d2015-04-04 16:13:01 -0700398 struct hci_rp_read_local_version *ver;
399 struct sk_buff *skb;
Ilya Faenson2a973df2015-06-17 17:30:56 -0400400 unsigned int speed;
Frederic Danis77213832015-05-28 11:25:03 +0200401 int err;
402
Ilya Faenson2a973df2015-06-17 17:30:56 -0400403 /* Init speed if any */
Frederic Danis960ef1d2015-06-18 12:43:27 +0200404 if (hu->init_speed)
Ilya Faenson2a973df2015-06-17 17:30:56 -0400405 speed = hu->init_speed;
Frederic Danis960ef1d2015-06-18 12:43:27 +0200406 else if (hu->proto->init_speed)
407 speed = hu->proto->init_speed;
Ilya Faenson2a973df2015-06-17 17:30:56 -0400408 else
409 speed = 0;
Frederic Danis77213832015-05-28 11:25:03 +0200410
Ilya Faenson2a973df2015-06-17 17:30:56 -0400411 if (speed)
412 hci_uart_set_baudrate(hu, speed);
413
414 /* Operational speed if any */
Frederic Danis960ef1d2015-06-18 12:43:27 +0200415 if (hu->oper_speed)
Ilya Faenson2a973df2015-06-17 17:30:56 -0400416 speed = hu->oper_speed;
Frederic Danis960ef1d2015-06-18 12:43:27 +0200417 else if (hu->proto->oper_speed)
418 speed = hu->proto->oper_speed;
Ilya Faenson2a973df2015-06-17 17:30:56 -0400419 else
420 speed = 0;
421
422 if (hu->proto->set_baudrate && speed) {
423 err = hu->proto->set_baudrate(hu, speed);
Frederic Danis77213832015-05-28 11:25:03 +0200424 if (!err)
Ilya Faenson2a973df2015-06-17 17:30:56 -0400425 hci_uart_set_baudrate(hu, speed);
Frederic Danis77213832015-05-28 11:25:03 +0200426 }
Loic Poulaineb173802015-03-25 15:19:30 +0100427
428 if (hu->proto->setup)
429 return hu->proto->setup(hu);
430
Marcel Holtmannfb2ce8d2015-04-04 16:13:01 -0700431 if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags))
432 return 0;
433
434 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
435 HCI_INIT_TIMEOUT);
436 if (IS_ERR(skb)) {
437 BT_ERR("%s: Reading local version information failed (%ld)",
438 hdev->name, PTR_ERR(skb));
439 return 0;
440 }
441
442 if (skb->len != sizeof(*ver)) {
443 BT_ERR("%s: Event length mismatch for version information",
444 hdev->name);
445 goto done;
446 }
447
448 ver = (struct hci_rp_read_local_version *)skb->data;
449
450 switch (le16_to_cpu(ver->manufacturer)) {
Marcel Holtmann16e38872015-04-04 16:13:02 -0700451#ifdef CONFIG_BT_HCIUART_INTEL
452 case 2:
Marcel Holtmannbca03c92015-04-06 00:52:14 -0700453 hdev->set_bdaddr = btintel_set_bdaddr;
454 btintel_check_bdaddr(hdev);
Marcel Holtmann16e38872015-04-04 16:13:02 -0700455 break;
456#endif
Marcel Holtmanne9a2dd22015-04-04 16:13:03 -0700457#ifdef CONFIG_BT_HCIUART_BCM
458 case 15:
Marcel Holtmann3e0ac122015-04-05 22:52:12 -0700459 hdev->set_bdaddr = btbcm_set_bdaddr;
460 btbcm_check_bdaddr(hdev);
Marcel Holtmanne9a2dd22015-04-04 16:13:03 -0700461 break;
462#endif
Marcel Holtmannfb2ce8d2015-04-04 16:13:01 -0700463 }
464
465done:
466 kfree_skb(skb);
Loic Poulaineb173802015-03-25 15:19:30 +0100467 return 0;
468}
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470/* ------ LDISC part ------ */
471/* hci_uart_tty_open
Chan-yeol Park1687dfc2013-04-02 21:24:23 +0900472 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 * Called when line discipline changed to HCI_UART.
474 *
475 * Arguments:
476 * tty pointer to tty info structure
Chan-yeol Park1687dfc2013-04-02 21:24:23 +0900477 * Return Value:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 * 0 if success, otherwise error code
479 */
480static int hci_uart_tty_open(struct tty_struct *tty)
481{
Jiri Slabyf327b342012-10-18 22:26:34 +0200482 struct hci_uart *hu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 BT_DBG("tty %p", tty);
485
Alan Coxc19483c2010-10-22 14:11:26 +0100486 /* Error if the tty has no write op instead of leaving an exploitable
Derek Robsond98422c2017-07-22 13:47:07 +1200487 * hole
488 */
Alan Coxc19483c2010-10-22 14:11:26 +0100489 if (tty->ops->write == NULL)
490 return -EOPNOTSUPP;
491
Valentin Iliea08b15e2013-08-12 18:46:00 +0300492 hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL);
493 if (!hu) {
Marcel Holtmann77851622006-09-21 16:23:19 +0200494 BT_ERR("Can't allocate control structure");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return -ENFILE;
496 }
Marcel Holtmann0372a662005-10-28 19:20:45 +0200497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 tty->disc_data = hu;
499 hu->tty = tty;
Alan Cox33f0f882006-01-09 20:54:13 -0800500 tty->receive_room = 65536;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Sebastian Reichelaeac3012017-03-28 17:59:34 +0200502 /* disable alignment support by default */
503 hu->alignment = 1;
504 hu->padding = 0;
505
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300506 INIT_WORK(&hu->init_ready, hci_uart_init_work);
Felipe Balbida64c272014-04-23 09:58:26 -0500507 INIT_WORK(&hu->write_work, hci_uart_write_work);
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300508
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700509 percpu_init_rwsem(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100510
Peter Hurleye6e981c2015-11-27 16:39:00 -0500511 /* Flush any pending characters in the driver */
Alan Coxf34d7a52008-04-30 00:54:13 -0700512 tty_driver_flush_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514 return 0;
515}
516
517/* hci_uart_tty_close()
518 *
519 * Called when the line discipline is changed to something
520 * else, the tty is closed, or the tty detects a hangup.
521 */
522static void hci_uart_tty_close(struct tty_struct *tty)
523{
Marcel Holtmanndfe19d22015-04-04 19:57:21 -0700524 struct hci_uart *hu = tty->disc_data;
Johan Hedbergdac670b2012-07-16 16:12:10 +0300525 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
527 BT_DBG("tty %p", tty);
528
529 /* Detach from the tty */
530 tty->disc_data = NULL;
531
Johan Hedbergdac670b2012-07-16 16:12:10 +0300532 if (!hu)
533 return;
Marcel Holtmann22ad4202007-05-09 09:15:40 +0200534
Johan Hedbergdac670b2012-07-16 16:12:10 +0300535 hdev = hu->hdev;
536 if (hdev)
537 hci_uart_close(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100539 if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700540 percpu_down_write(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100541 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700542 percpu_up_write(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100543
Samuel Hollandcd270192020-08-01 11:29:56 -0500544 cancel_work_sync(&hu->init_ready);
Ronald Tschaläre508e602017-10-25 22:15:19 -0700545 cancel_work_sync(&hu->write_work);
546
Johan Hedbergdac670b2012-07-16 16:12:10 +0300547 if (hdev) {
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300548 if (test_bit(HCI_UART_REGISTERED, &hu->flags))
549 hci_unregister_dev(hdev);
Johan Hedbergdac670b2012-07-16 16:12:10 +0300550 hci_free_dev(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 }
Johan Hedbergdac670b2012-07-16 16:12:10 +0300552 hu->proto->close(hu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 }
Loic Poulain84cb3df2016-04-04 10:48:13 +0200554 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
Johan Hedbergdac670b2012-07-16 16:12:10 +0300555
Hermes Zhange3583d72018-08-28 09:48:30 +0800556 percpu_free_rwsem(&hu->proto_lock);
557
Johan Hedbergdac670b2012-07-16 16:12:10 +0300558 kfree(hu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559}
560
561/* hci_uart_tty_wakeup()
562 *
563 * Callback for transmit wakeup. Called when low level
564 * device driver can accept more send data.
565 *
566 * Arguments: tty pointer to associated tty instance data
567 * Return Value: None
568 */
569static void hci_uart_tty_wakeup(struct tty_struct *tty)
570{
Marcel Holtmanndfe19d22015-04-04 19:57:21 -0700571 struct hci_uart *hu = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 BT_DBG("");
574
575 if (!hu)
576 return;
577
578 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
579
580 if (tty != hu->tty)
581 return;
582
Loic Poulain84cb3df2016-04-04 10:48:13 +0200583 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 hci_uart_tx_wakeup(hu);
585}
586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587/* hci_uart_tty_receive()
Chan-yeol Park1687dfc2013-04-02 21:24:23 +0900588 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 * Called by tty low level driver when receive data is
590 * available.
Chan-yeol Park1687dfc2013-04-02 21:24:23 +0900591 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 * Arguments: tty pointer to tty isntance data
593 * data pointer to received data
594 * flags pointer to flags for data
595 * count count of received data in bytes
Chan-yeol Park1687dfc2013-04-02 21:24:23 +0900596 *
Linus Torvalds55db4c62011-06-04 06:33:24 +0900597 * Return Value: None
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 */
Marcel Holtmannfacf5222015-04-04 19:57:22 -0700599static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data,
600 char *flags, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
Marcel Holtmanndfe19d22015-04-04 19:57:21 -0700602 struct hci_uart *hu = tty->disc_data;
Marcel Holtmann0372a662005-10-28 19:20:45 +0200603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 if (!hu || tty != hu->tty)
Linus Torvalds55db4c62011-06-04 06:33:24 +0900605 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700607 percpu_down_read(&hu->proto_lock);
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100608
609 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700610 percpu_up_read(&hu->proto_lock);
Linus Torvalds55db4c62011-06-04 06:33:24 +0900611 return;
Dean Jenkinsdec2c922017-05-05 16:27:06 +0100612 }
Marcel Holtmann0372a662005-10-28 19:20:45 +0200613
Frederic Danis7649faf2015-09-23 18:18:10 +0200614 /* It does not need a lock here as it is already protected by a mutex in
615 * tty caller
616 */
Marcel Holtmann9d1c40e2015-04-04 20:59:41 -0700617 hu->proto->recv(hu, data, count);
Ronald Tschalärf6ec33f2017-10-25 22:14:53 -0700618 percpu_up_read(&hu->proto_lock);
Chan-yeol Park788f0922013-04-02 21:24:22 +0900619
620 if (hu->hdev)
621 hu->hdev->stat.byte_rx += count;
622
Alan Cox39c2e602008-04-30 00:54:18 -0700623 tty_unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624}
625
626static int hci_uart_register_dev(struct hci_uart *hu)
627{
628 struct hci_dev *hdev;
Jeremy Cline6ea83d92019-02-06 12:54:16 -0500629 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
631 BT_DBG("");
632
633 /* Initialize and register HCI device */
634 hdev = hci_alloc_dev();
635 if (!hdev) {
636 BT_ERR("Can't allocate HCI device");
637 return -ENOMEM;
638 }
639
640 hu->hdev = hdev;
641
Marcel Holtmannc13854c2010-02-08 15:27:07 +0100642 hdev->bus = HCI_UART;
David Herrmann155961e2012-02-09 21:58:32 +0100643 hci_set_drvdata(hdev, hu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Marcel Holtmannaee61f72015-10-20 21:30:45 +0200645 /* Only when vendor specific setup callback is provided, consider
646 * the manufacturer information valid. This avoids filling in the
647 * value for Ericsson when nothing is specified.
648 */
649 if (hu->proto->setup)
650 hdev->manufacturer = hu->proto->manufacturer;
651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 hdev->open = hci_uart_open;
653 hdev->close = hci_uart_close;
654 hdev->flush = hci_uart_flush;
655 hdev->send = hci_uart_send_frame;
Loic Poulaineb173802015-03-25 15:19:30 +0100656 hdev->setup = hci_uart_setup;
David Herrmann6935e0f2012-03-09 15:53:42 +0100657 SET_HCIDEV_DEV(hdev, hu->tty->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Johan Hedberg63c7d092010-07-12 11:37:04 -0300659 if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
660 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
661
Marcel Holtmann6afd04a2014-07-11 07:12:58 +0200662 if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
663 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
664
Marcel Holtmanna55e1f32012-02-24 17:12:24 +0100665 if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags))
Szymon Janca6c511c2012-05-23 12:35:46 +0200666 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
Marcel Holtmanna55e1f32012-02-24 17:12:24 +0100667
Marcel Holtmann8a7a3fd2012-02-24 17:09:38 +0100668 if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
669 hdev->dev_type = HCI_AMP;
670 else
Marcel Holtmannca8bee52016-07-05 14:30:14 +0200671 hdev->dev_type = HCI_PRIMARY;
Marcel Holtmann8a7a3fd2012-02-24 17:09:38 +0100672
Jeremy Cline6ea83d92019-02-06 12:54:16 -0500673 /* Only call open() for the protocol after hdev is fully initialized as
674 * open() (or a timer/workqueue it starts) may attempt to reference it.
675 */
676 err = hu->proto->open(hu);
677 if (err) {
678 hu->hdev = NULL;
679 hci_free_dev(hdev);
680 return err;
681 }
682
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300683 if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
684 return 0;
685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (hci_register_dev(hdev) < 0) {
687 BT_ERR("Can't register HCI device");
Jeremy Cline6ea83d92019-02-06 12:54:16 -0500688 hu->proto->close(hu);
Dean Jenkinsa225b8c2017-04-20 18:06:40 +0100689 hu->hdev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 hci_free_dev(hdev);
691 return -ENODEV;
692 }
693
Johan Hedberg9f2aee82012-07-16 16:12:11 +0300694 set_bit(HCI_UART_REGISTERED, &hu->flags);
695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 return 0;
697}
698
699static int hci_uart_set_proto(struct hci_uart *hu, int id)
700{
Marcel Holtmann4ee7ef12015-04-04 22:11:43 -0700701 const struct hci_uart_proto *p;
Marcel Holtmann0372a662005-10-28 19:20:45 +0200702 int err;
703
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 p = hci_uart_get_proto(id);
705 if (!p)
706 return -EPROTONOSUPPORT;
707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 hu->proto = p;
709
710 err = hci_uart_register_dev(hu);
711 if (err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 return err;
713 }
Marcel Holtmann0372a662005-10-28 19:20:45 +0200714
Kefeng Wanga1dbb342019-02-23 12:33:27 +0800715 set_bit(HCI_UART_PROTO_READY, &hu->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 return 0;
717}
718
Marcel Holtmannbb72bd62014-07-11 07:12:57 +0200719static int hci_uart_set_flags(struct hci_uart *hu, unsigned long flags)
720{
721 unsigned long valid_flags = BIT(HCI_UART_RAW_DEVICE) |
722 BIT(HCI_UART_RESET_ON_INIT) |
723 BIT(HCI_UART_CREATE_AMP) |
Marcel Holtmann6afd04a2014-07-11 07:12:58 +0200724 BIT(HCI_UART_INIT_PENDING) |
Marcel Holtmannfb2ce8d2015-04-04 16:13:01 -0700725 BIT(HCI_UART_EXT_CONFIG) |
726 BIT(HCI_UART_VND_DETECT);
Marcel Holtmannbb72bd62014-07-11 07:12:57 +0200727
Marcel Holtmann41533fe2015-04-01 13:51:51 -0700728 if (flags & ~valid_flags)
Marcel Holtmannbb72bd62014-07-11 07:12:57 +0200729 return -EINVAL;
730
731 hu->hdev_flags = flags;
732
733 return 0;
734}
735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736/* hci_uart_tty_ioctl()
737 *
738 * Process IOCTL system call for the tty device.
739 *
740 * Arguments:
741 *
742 * tty pointer to tty instance data
743 * file pointer to open file object for device
744 * cmd IOCTL command code
745 * arg argument for IOCTL call (cmd dependent)
746 *
747 * Return Value: Command dependent
748 */
Marcel Holtmannfacf5222015-04-04 19:57:22 -0700749static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file *file,
750 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
Marcel Holtmanndfe19d22015-04-04 19:57:21 -0700752 struct hci_uart *hu = tty->disc_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 int err = 0;
754
755 BT_DBG("");
756
757 /* Verify the status of the device */
758 if (!hu)
759 return -EBADF;
760
761 switch (cmd) {
762 case HCIUARTSETPROTO:
763 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
764 err = hci_uart_set_proto(hu, arg);
Vignesh Raman05650692016-09-23 18:56:28 +0100765 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
Marcel Holtmann0372a662005-10-28 19:20:45 +0200767 } else
Vignesh Raman05650692016-09-23 18:56:28 +0100768 err = -EBUSY;
Marcel Holtmannc33be3c2007-05-09 09:15:45 +0200769 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
771 case HCIUARTGETPROTO:
772 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
Vignesh Raman05650692016-09-23 18:56:28 +0100773 err = hu->proto->id;
774 else
775 err = -EUNATCH;
776 break;
Marcel Holtmann0372a662005-10-28 19:20:45 +0200777
Marcel Holtmannd2158742007-05-09 09:15:35 +0200778 case HCIUARTGETDEVICE:
Marcel Holtmannc7e0c142014-07-12 17:00:29 +0200779 if (test_bit(HCI_UART_REGISTERED, &hu->flags))
Vignesh Raman05650692016-09-23 18:56:28 +0100780 err = hu->hdev->id;
781 else
782 err = -EUNATCH;
783 break;
Marcel Holtmannd2158742007-05-09 09:15:35 +0200784
Johan Hedberg63c7d092010-07-12 11:37:04 -0300785 case HCIUARTSETFLAGS:
786 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
Vignesh Raman05650692016-09-23 18:56:28 +0100787 err = -EBUSY;
788 else
789 err = hci_uart_set_flags(hu, arg);
Johan Hedberg63c7d092010-07-12 11:37:04 -0300790 break;
791
792 case HCIUARTGETFLAGS:
Vignesh Raman05650692016-09-23 18:56:28 +0100793 err = hu->hdev_flags;
794 break;
Johan Hedberg63c7d092010-07-12 11:37:04 -0300795
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 default:
Alan Cox47afa7a2008-10-13 10:44:17 +0100797 err = n_tty_ioctl_helper(tty, file, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 break;
Peter Senna Tschudina20890d2012-09-07 17:24:39 +0200799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
801 return err;
802}
803
804/*
805 * We don't provide read/write/poll interface for user space.
806 */
Marcel Holtmann0372a662005-10-28 19:20:45 +0200807static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file,
Marcel Holtmannfacf5222015-04-04 19:57:22 -0700808 unsigned char __user *buf, size_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
810 return 0;
811}
812
Marcel Holtmann0372a662005-10-28 19:20:45 +0200813static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file,
Marcel Holtmannfacf5222015-04-04 19:57:22 -0700814 const unsigned char *data, size_t count)
Marcel Holtmann0372a662005-10-28 19:20:45 +0200815{
816 return 0;
817}
818
819static unsigned int hci_uart_tty_poll(struct tty_struct *tty,
Marcel Holtmannfacf5222015-04-04 19:57:22 -0700820 struct file *filp, poll_table *wait)
Marcel Holtmann0372a662005-10-28 19:20:45 +0200821{
822 return 0;
823}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825static int __init hci_uart_init(void)
826{
Alan Coxa352def2008-07-16 21:53:12 +0100827 static struct tty_ldisc_ops hci_uart_ldisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 int err;
829
830 BT_INFO("HCI UART driver ver %s", VERSION);
831
832 /* Register the tty discipline */
833
Prasanna Karthikacf50c52015-07-23 11:08:52 +0000834 memset(&hci_uart_ldisc, 0, sizeof(hci_uart_ldisc));
Marcel Holtmann0372a662005-10-28 19:20:45 +0200835 hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
836 hci_uart_ldisc.name = "n_hci";
837 hci_uart_ldisc.open = hci_uart_tty_open;
838 hci_uart_ldisc.close = hci_uart_tty_close;
839 hci_uart_ldisc.read = hci_uart_tty_read;
840 hci_uart_ldisc.write = hci_uart_tty_write;
841 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
842 hci_uart_ldisc.poll = hci_uart_tty_poll;
Marcel Holtmann0372a662005-10-28 19:20:45 +0200843 hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
844 hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;
845 hci_uart_ldisc.owner = THIS_MODULE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
Valentin Iliea08b15e2013-08-12 18:46:00 +0300847 err = tty_register_ldisc(N_HCI, &hci_uart_ldisc);
848 if (err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 BT_ERR("HCI line discipline registration failed. (%d)", err);
850 return err;
851 }
852
853#ifdef CONFIG_BT_HCIUART_H4
854 h4_init();
855#endif
856#ifdef CONFIG_BT_HCIUART_BCSP
857 bcsp_init();
858#endif
Ohad Ben-Cohen166d2f62007-10-20 13:42:36 +0200859#ifdef CONFIG_BT_HCIUART_LL
860 ll_init();
861#endif
Suraj Sumangalab3190df2010-07-19 12:34:07 +0530862#ifdef CONFIG_BT_HCIUART_ATH3K
863 ath_init();
864#endif
Johan Hedberg7dec65c2012-07-16 16:12:02 +0300865#ifdef CONFIG_BT_HCIUART_3WIRE
866 h5_init();
867#endif
Loic Poulainca93cee2015-07-01 12:20:26 +0200868#ifdef CONFIG_BT_HCIUART_INTEL
869 intel_init();
870#endif
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700871#ifdef CONFIG_BT_HCIUART_BCM
872 bcm_init();
873#endif
Ben Young Tae Kim0ff252c2015-08-10 14:24:17 -0700874#ifdef CONFIG_BT_HCIUART_QCA
875 qca_init();
876#endif
Loic Poulain395174b2016-02-22 10:48:03 +0100877#ifdef CONFIG_BT_HCIUART_AG6XX
878 ag6xx_init();
879#endif
Loic Poulain162f8122016-09-19 16:29:27 +0200880#ifdef CONFIG_BT_HCIUART_MRVL
881 mrvl_init();
882#endif
Ohad Ben-Cohen166d2f62007-10-20 13:42:36 +0200883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 return 0;
885}
886
887static void __exit hci_uart_exit(void)
888{
889 int err;
890
891#ifdef CONFIG_BT_HCIUART_H4
892 h4_deinit();
893#endif
894#ifdef CONFIG_BT_HCIUART_BCSP
895 bcsp_deinit();
896#endif
Ohad Ben-Cohen166d2f62007-10-20 13:42:36 +0200897#ifdef CONFIG_BT_HCIUART_LL
898 ll_deinit();
899#endif
Suraj Sumangalab3190df2010-07-19 12:34:07 +0530900#ifdef CONFIG_BT_HCIUART_ATH3K
901 ath_deinit();
902#endif
Johan Hedberg7dec65c2012-07-16 16:12:02 +0300903#ifdef CONFIG_BT_HCIUART_3WIRE
904 h5_deinit();
905#endif
Loic Poulainca93cee2015-07-01 12:20:26 +0200906#ifdef CONFIG_BT_HCIUART_INTEL
907 intel_deinit();
908#endif
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700909#ifdef CONFIG_BT_HCIUART_BCM
910 bcm_deinit();
911#endif
Ben Young Tae Kim0ff252c2015-08-10 14:24:17 -0700912#ifdef CONFIG_BT_HCIUART_QCA
913 qca_deinit();
914#endif
Loic Poulain395174b2016-02-22 10:48:03 +0100915#ifdef CONFIG_BT_HCIUART_AG6XX
916 ag6xx_deinit();
917#endif
Loic Poulain162f8122016-09-19 16:29:27 +0200918#ifdef CONFIG_BT_HCIUART_MRVL
919 mrvl_deinit();
920#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
922 /* Release tty registration of line discipline */
Valentin Iliea08b15e2013-08-12 18:46:00 +0300923 err = tty_unregister_ldisc(N_HCI);
924 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 BT_ERR("Can't unregister HCI line discipline (%d)", err);
926}
927
928module_init(hci_uart_init);
929module_exit(hci_uart_exit);
930
Marcel Holtmann63fbd242008-08-18 13:23:53 +0200931MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
933MODULE_VERSION(VERSION);
934MODULE_LICENSE("GPL");
935MODULE_ALIAS_LDISC(N_HCI);