Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 3 | * 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include <linux/module.h> |
| 27 | |
| 28 | #include <linux/kernel.h> |
| 29 | #include <linux/init.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | #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 Danis | 18aeb44 | 2015-05-28 11:25:01 +0200 | [diff] [blame] | 43 | #include <linux/firmware.h> |
Hans de Goede | 56ea88e | 2017-10-04 20:43:35 +0200 | [diff] [blame] | 44 | #include <linux/serdev.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | |
| 46 | #include <net/bluetooth/bluetooth.h> |
| 47 | #include <net/bluetooth/hci_core.h> |
| 48 | |
Marcel Holtmann | bca03c9 | 2015-04-06 00:52:14 -0700 | [diff] [blame] | 49 | #include "btintel.h" |
Marcel Holtmann | 3e0ac12 | 2015-04-05 22:52:12 -0700 | [diff] [blame] | 50 | #include "btbcm.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | #include "hci_uart.h" |
| 52 | |
Marcel Holtmann | 788a675 | 2015-04-04 22:36:04 -0700 | [diff] [blame] | 53 | #define VERSION "2.3" |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 54 | |
Marcel Holtmann | 4ee7ef1 | 2015-04-04 22:11:43 -0700 | [diff] [blame] | 55 | static const struct hci_uart_proto *hup[HCI_UART_MAX_PROTO]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | |
Marcel Holtmann | 4ee7ef1 | 2015-04-04 22:11:43 -0700 | [diff] [blame] | 57 | int hci_uart_register_proto(const struct hci_uart_proto *p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | { |
| 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 Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 66 | |
Marcel Holtmann | 01009ee | 2015-04-04 22:27:35 -0700 | [diff] [blame] | 67 | BT_INFO("HCI UART protocol %s registered", p->name); |
| 68 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | return 0; |
| 70 | } |
| 71 | |
Marcel Holtmann | 4ee7ef1 | 2015-04-04 22:11:43 -0700 | [diff] [blame] | 72 | int hci_uart_unregister_proto(const struct hci_uart_proto *p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | { |
| 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 Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 81 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | return 0; |
| 83 | } |
| 84 | |
Marcel Holtmann | 4ee7ef1 | 2015-04-04 22:11:43 -0700 | [diff] [blame] | 85 | static const struct hci_uart_proto *hci_uart_get_proto(unsigned int id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | { |
| 87 | if (id >= HCI_UART_MAX_PROTO) |
| 88 | return NULL; |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 89 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | return hup[id]; |
| 91 | } |
| 92 | |
| 93 | static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type) |
| 94 | { |
| 95 | struct hci_dev *hdev = hu->hdev; |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 96 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | /* 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 Beldan | 7f8f272 | 2010-10-07 21:57:10 +0200 | [diff] [blame] | 108 | hdev->stat.sco_tx++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | break; |
| 110 | } |
| 111 | } |
| 112 | |
| 113 | static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu) |
| 114 | { |
| 115 | struct sk_buff *skb = hu->tx_skb; |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 116 | |
Dean Jenkins | 048e1bd | 2017-04-28 13:57:25 +0100 | [diff] [blame] | 117 | if (!skb) { |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 118 | percpu_down_read(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 119 | |
Dean Jenkins | 048e1bd | 2017-04-28 13:57:25 +0100 | [diff] [blame] | 120 | if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) |
| 121 | skb = hu->proto->dequeue(hu); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 122 | |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 123 | percpu_up_read(&hu->proto_lock); |
Dean Jenkins | 048e1bd | 2017-04-28 13:57:25 +0100 | [diff] [blame] | 124 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | hu->tx_skb = NULL; |
Dean Jenkins | 048e1bd | 2017-04-28 13:57:25 +0100 | [diff] [blame] | 126 | } |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 127 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | return skb; |
| 129 | } |
| 130 | |
| 131 | int hci_uart_tx_wakeup(struct hci_uart *hu) |
| 132 | { |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 133 | /* 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 Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 141 | |
Dean Jenkins | 2d6f1da | 2017-04-28 13:57:26 +0100 | [diff] [blame] | 142 | if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 143 | goto no_schedule; |
Dean Jenkins | 2d6f1da | 2017-04-28 13:57:26 +0100 | [diff] [blame] | 144 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) { |
| 146 | set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 147 | goto no_schedule; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | BT_DBG(""); |
| 151 | |
Felipe Balbi | da64c27 | 2014-04-23 09:58:26 -0500 | [diff] [blame] | 152 | schedule_work(&hu->write_work); |
| 153 | |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 154 | no_schedule: |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 155 | percpu_up_read(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 156 | |
Felipe Balbi | da64c27 | 2014-04-23 09:58:26 -0500 | [diff] [blame] | 157 | return 0; |
| 158 | } |
Sebastian Reichel | 081f36a | 2017-03-28 17:59:37 +0200 | [diff] [blame] | 159 | EXPORT_SYMBOL_GPL(hci_uart_tx_wakeup); |
Felipe Balbi | da64c27 | 2014-04-23 09:58:26 -0500 | [diff] [blame] | 160 | |
| 161 | static 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | restart: |
| 173 | clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); |
| 174 | |
| 175 | while ((skb = hci_uart_dequeue(hu))) { |
| 176 | int len; |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 177 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); |
Alan Cox | f34d7a5 | 2008-04-30 00:54:13 -0700 | [diff] [blame] | 179 | len = tty->ops->write(tty, skb->data, skb->len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | hdev->stat.byte_tx += len; |
| 181 | |
| 182 | skb_pull(skb, len); |
| 183 | if (skb->len) { |
| 184 | hu->tx_skb = skb; |
| 185 | break; |
| 186 | } |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 187 | |
Marcel Holtmann | 618e8bc | 2015-11-05 07:33:56 +0100 | [diff] [blame] | 188 | hci_uart_tx_complete(hu, hci_skb_pkt_type(skb)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | kfree_skb(skb); |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 190 | } |
| 191 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state)) |
| 193 | goto restart; |
| 194 | |
| 195 | clear_bit(HCI_UART_SENDING, &hu->tx_state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | } |
| 197 | |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 198 | static 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 Jenkins | a225b8c | 2017-04-20 18:06:40 +0100 | [diff] [blame] | 202 | struct hci_dev *hdev; |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 203 | |
| 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 Cline | 6ea83d9 | 2019-02-06 12:54:16 -0500 | [diff] [blame] | 210 | clear_bit(HCI_UART_PROTO_READY, &hu->flags); |
| 211 | hu->proto->close(hu); |
Dean Jenkins | a225b8c | 2017-04-20 18:06:40 +0100 | [diff] [blame] | 212 | hdev = hu->hdev; |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 213 | hu->hdev = NULL; |
Dean Jenkins | a225b8c | 2017-04-20 18:06:40 +0100 | [diff] [blame] | 214 | hci_free_dev(hdev); |
Dean Jenkins | cb92652 | 2017-04-20 18:06:39 +0100 | [diff] [blame] | 215 | return; |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | set_bit(HCI_UART_REGISTERED, &hu->flags); |
| 219 | } |
| 220 | |
| 221 | int 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | /* ------- Interface to HCI layer ------ */ |
| 232 | /* Initialize device */ |
| 233 | static 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | return 0; |
| 239 | } |
| 240 | |
| 241 | /* Reset device */ |
| 242 | static int hci_uart_flush(struct hci_dev *hdev) |
| 243 | { |
David Herrmann | 155961e | 2012-02-09 21:58:32 +0100 | [diff] [blame] | 244 | struct hci_uart *hu = hci_get_drvdata(hdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | 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 Cox | f34d7a5 | 2008-04-30 00:54:13 -0700 | [diff] [blame] | 255 | tty_driver_flush_buffer(tty); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 257 | percpu_down_read(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 258 | |
Loic Poulain | 84cb3df | 2016-04-04 10:48:13 +0200 | [diff] [blame] | 259 | if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | hu->proto->flush(hu); |
| 261 | |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 262 | percpu_up_read(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 263 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | return 0; |
| 265 | } |
| 266 | |
| 267 | /* Close device */ |
| 268 | static int hci_uart_close(struct hci_dev *hdev) |
| 269 | { |
| 270 | BT_DBG("hdev %p", hdev); |
| 271 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | hci_uart_flush(hdev); |
David Newall | 3611f4d | 2008-02-11 21:41:30 -0800 | [diff] [blame] | 273 | hdev->flush = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | return 0; |
| 275 | } |
| 276 | |
| 277 | /* Send frames from HCI layer */ |
Marcel Holtmann | 7bd8f09 | 2013-10-11 06:19:18 -0700 | [diff] [blame] | 278 | static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | { |
Marcel Holtmann | 52bc423 | 2013-10-11 07:01:03 -0700 | [diff] [blame] | 280 | struct hci_uart *hu = hci_get_drvdata(hdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | |
Marcel Holtmann | 618e8bc | 2015-11-05 07:33:56 +0100 | [diff] [blame] | 282 | BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb), |
| 283 | skb->len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 285 | percpu_down_read(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 286 | |
| 287 | if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) { |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 288 | percpu_up_read(&hu->proto_lock); |
Dean Jenkins | ab00f89 | 2017-04-28 13:57:24 +0100 | [diff] [blame] | 289 | return -EUNATCH; |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 290 | } |
Dean Jenkins | ab00f89 | 2017-04-28 13:57:24 +0100 | [diff] [blame] | 291 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | hu->proto->enqueue(hu, skb); |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 293 | percpu_up_read(&hu->proto_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | |
| 295 | hci_uart_tx_wakeup(hu); |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 296 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | return 0; |
| 298 | } |
| 299 | |
Vladis Dronov | 69f9c2b | 2019-07-30 11:33:45 +0200 | [diff] [blame] | 300 | /* Check the underlying device or tty has flow control support */ |
| 301 | bool 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 Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 313 | /* Flow control or un-flow control the device */ |
| 314 | void 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 Goede | 56ea88e | 2017-10-04 20:43:35 +0200 | [diff] [blame] | 322 | 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 Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 328 | 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 | |
| 372 | void 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 Danis | 7721383 | 2015-05-28 11:25:03 +0200 | [diff] [blame] | 379 | void 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 Danis | 7721383 | 2015-05-28 11:25:03 +0200 | [diff] [blame] | 386 | 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 Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 391 | BT_DBG("%s: New tty speeds: %d/%d", hu->hdev->name, |
| 392 | tty->termios.c_ispeed, tty->termios.c_ospeed); |
Frederic Danis | 7721383 | 2015-05-28 11:25:03 +0200 | [diff] [blame] | 393 | } |
| 394 | |
Loic Poulain | eb17380 | 2015-03-25 15:19:30 +0100 | [diff] [blame] | 395 | static int hci_uart_setup(struct hci_dev *hdev) |
| 396 | { |
| 397 | struct hci_uart *hu = hci_get_drvdata(hdev); |
Marcel Holtmann | fb2ce8d | 2015-04-04 16:13:01 -0700 | [diff] [blame] | 398 | struct hci_rp_read_local_version *ver; |
| 399 | struct sk_buff *skb; |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 400 | unsigned int speed; |
Frederic Danis | 7721383 | 2015-05-28 11:25:03 +0200 | [diff] [blame] | 401 | int err; |
| 402 | |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 403 | /* Init speed if any */ |
Frederic Danis | 960ef1d | 2015-06-18 12:43:27 +0200 | [diff] [blame] | 404 | if (hu->init_speed) |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 405 | speed = hu->init_speed; |
Frederic Danis | 960ef1d | 2015-06-18 12:43:27 +0200 | [diff] [blame] | 406 | else if (hu->proto->init_speed) |
| 407 | speed = hu->proto->init_speed; |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 408 | else |
| 409 | speed = 0; |
Frederic Danis | 7721383 | 2015-05-28 11:25:03 +0200 | [diff] [blame] | 410 | |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 411 | if (speed) |
| 412 | hci_uart_set_baudrate(hu, speed); |
| 413 | |
| 414 | /* Operational speed if any */ |
Frederic Danis | 960ef1d | 2015-06-18 12:43:27 +0200 | [diff] [blame] | 415 | if (hu->oper_speed) |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 416 | speed = hu->oper_speed; |
Frederic Danis | 960ef1d | 2015-06-18 12:43:27 +0200 | [diff] [blame] | 417 | else if (hu->proto->oper_speed) |
| 418 | speed = hu->proto->oper_speed; |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 419 | else |
| 420 | speed = 0; |
| 421 | |
| 422 | if (hu->proto->set_baudrate && speed) { |
| 423 | err = hu->proto->set_baudrate(hu, speed); |
Frederic Danis | 7721383 | 2015-05-28 11:25:03 +0200 | [diff] [blame] | 424 | if (!err) |
Ilya Faenson | 2a973df | 2015-06-17 17:30:56 -0400 | [diff] [blame] | 425 | hci_uart_set_baudrate(hu, speed); |
Frederic Danis | 7721383 | 2015-05-28 11:25:03 +0200 | [diff] [blame] | 426 | } |
Loic Poulain | eb17380 | 2015-03-25 15:19:30 +0100 | [diff] [blame] | 427 | |
| 428 | if (hu->proto->setup) |
| 429 | return hu->proto->setup(hu); |
| 430 | |
Marcel Holtmann | fb2ce8d | 2015-04-04 16:13:01 -0700 | [diff] [blame] | 431 | 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 Holtmann | 16e3887 | 2015-04-04 16:13:02 -0700 | [diff] [blame] | 451 | #ifdef CONFIG_BT_HCIUART_INTEL |
| 452 | case 2: |
Marcel Holtmann | bca03c9 | 2015-04-06 00:52:14 -0700 | [diff] [blame] | 453 | hdev->set_bdaddr = btintel_set_bdaddr; |
| 454 | btintel_check_bdaddr(hdev); |
Marcel Holtmann | 16e3887 | 2015-04-04 16:13:02 -0700 | [diff] [blame] | 455 | break; |
| 456 | #endif |
Marcel Holtmann | e9a2dd2 | 2015-04-04 16:13:03 -0700 | [diff] [blame] | 457 | #ifdef CONFIG_BT_HCIUART_BCM |
| 458 | case 15: |
Marcel Holtmann | 3e0ac12 | 2015-04-05 22:52:12 -0700 | [diff] [blame] | 459 | hdev->set_bdaddr = btbcm_set_bdaddr; |
| 460 | btbcm_check_bdaddr(hdev); |
Marcel Holtmann | e9a2dd2 | 2015-04-04 16:13:03 -0700 | [diff] [blame] | 461 | break; |
| 462 | #endif |
Marcel Holtmann | fb2ce8d | 2015-04-04 16:13:01 -0700 | [diff] [blame] | 463 | } |
| 464 | |
| 465 | done: |
| 466 | kfree_skb(skb); |
Loic Poulain | eb17380 | 2015-03-25 15:19:30 +0100 | [diff] [blame] | 467 | return 0; |
| 468 | } |
| 469 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | /* ------ LDISC part ------ */ |
| 471 | /* hci_uart_tty_open |
Chan-yeol Park | 1687dfc | 2013-04-02 21:24:23 +0900 | [diff] [blame] | 472 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 473 | * Called when line discipline changed to HCI_UART. |
| 474 | * |
| 475 | * Arguments: |
| 476 | * tty pointer to tty info structure |
Chan-yeol Park | 1687dfc | 2013-04-02 21:24:23 +0900 | [diff] [blame] | 477 | * Return Value: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 478 | * 0 if success, otherwise error code |
| 479 | */ |
| 480 | static int hci_uart_tty_open(struct tty_struct *tty) |
| 481 | { |
Jiri Slaby | f327b34 | 2012-10-18 22:26:34 +0200 | [diff] [blame] | 482 | struct hci_uart *hu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | |
| 484 | BT_DBG("tty %p", tty); |
| 485 | |
Alan Cox | c19483c | 2010-10-22 14:11:26 +0100 | [diff] [blame] | 486 | /* Error if the tty has no write op instead of leaving an exploitable |
Derek Robson | d98422c | 2017-07-22 13:47:07 +1200 | [diff] [blame] | 487 | * hole |
| 488 | */ |
Alan Cox | c19483c | 2010-10-22 14:11:26 +0100 | [diff] [blame] | 489 | if (tty->ops->write == NULL) |
| 490 | return -EOPNOTSUPP; |
| 491 | |
Valentin Ilie | a08b15e | 2013-08-12 18:46:00 +0300 | [diff] [blame] | 492 | hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL); |
| 493 | if (!hu) { |
Marcel Holtmann | 7785162 | 2006-09-21 16:23:19 +0200 | [diff] [blame] | 494 | BT_ERR("Can't allocate control structure"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | return -ENFILE; |
| 496 | } |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 497 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 498 | tty->disc_data = hu; |
| 499 | hu->tty = tty; |
Alan Cox | 33f0f88 | 2006-01-09 20:54:13 -0800 | [diff] [blame] | 500 | tty->receive_room = 65536; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | |
Sebastian Reichel | aeac301 | 2017-03-28 17:59:34 +0200 | [diff] [blame] | 502 | /* disable alignment support by default */ |
| 503 | hu->alignment = 1; |
| 504 | hu->padding = 0; |
| 505 | |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 506 | INIT_WORK(&hu->init_ready, hci_uart_init_work); |
Felipe Balbi | da64c27 | 2014-04-23 09:58:26 -0500 | [diff] [blame] | 507 | INIT_WORK(&hu->write_work, hci_uart_write_work); |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 508 | |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 509 | percpu_init_rwsem(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 510 | |
Peter Hurley | e6e981c | 2015-11-27 16:39:00 -0500 | [diff] [blame] | 511 | /* Flush any pending characters in the driver */ |
Alan Cox | f34d7a5 | 2008-04-30 00:54:13 -0700 | [diff] [blame] | 512 | tty_driver_flush_buffer(tty); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 513 | |
| 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 | */ |
| 522 | static void hci_uart_tty_close(struct tty_struct *tty) |
| 523 | { |
Marcel Holtmann | dfe19d2 | 2015-04-04 19:57:21 -0700 | [diff] [blame] | 524 | struct hci_uart *hu = tty->disc_data; |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 525 | struct hci_dev *hdev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | |
| 527 | BT_DBG("tty %p", tty); |
| 528 | |
| 529 | /* Detach from the tty */ |
| 530 | tty->disc_data = NULL; |
| 531 | |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 532 | if (!hu) |
| 533 | return; |
Marcel Holtmann | 22ad420 | 2007-05-09 09:15:40 +0200 | [diff] [blame] | 534 | |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 535 | hdev = hu->hdev; |
| 536 | if (hdev) |
| 537 | hci_uart_close(hdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 538 | |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 539 | if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) { |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 540 | percpu_down_write(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 541 | clear_bit(HCI_UART_PROTO_READY, &hu->flags); |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 542 | percpu_up_write(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 543 | |
Samuel Holland | cd27019 | 2020-08-01 11:29:56 -0500 | [diff] [blame] | 544 | cancel_work_sync(&hu->init_ready); |
Ronald Tschalär | e508e60 | 2017-10-25 22:15:19 -0700 | [diff] [blame] | 545 | cancel_work_sync(&hu->write_work); |
| 546 | |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 547 | if (hdev) { |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 548 | if (test_bit(HCI_UART_REGISTERED, &hu->flags)) |
| 549 | hci_unregister_dev(hdev); |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 550 | hci_free_dev(hdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 551 | } |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 552 | hu->proto->close(hu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | } |
Loic Poulain | 84cb3df | 2016-04-04 10:48:13 +0200 | [diff] [blame] | 554 | clear_bit(HCI_UART_PROTO_SET, &hu->flags); |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 555 | |
Hermes Zhang | e3583d7 | 2018-08-28 09:48:30 +0800 | [diff] [blame] | 556 | percpu_free_rwsem(&hu->proto_lock); |
| 557 | |
Johan Hedberg | dac670b | 2012-07-16 16:12:10 +0300 | [diff] [blame] | 558 | kfree(hu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 559 | } |
| 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 | */ |
| 569 | static void hci_uart_tty_wakeup(struct tty_struct *tty) |
| 570 | { |
Marcel Holtmann | dfe19d2 | 2015-04-04 19:57:21 -0700 | [diff] [blame] | 571 | struct hci_uart *hu = tty->disc_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 572 | |
| 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 Poulain | 84cb3df | 2016-04-04 10:48:13 +0200 | [diff] [blame] | 583 | if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 584 | hci_uart_tx_wakeup(hu); |
| 585 | } |
| 586 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | /* hci_uart_tty_receive() |
Chan-yeol Park | 1687dfc | 2013-04-02 21:24:23 +0900 | [diff] [blame] | 588 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 589 | * Called by tty low level driver when receive data is |
| 590 | * available. |
Chan-yeol Park | 1687dfc | 2013-04-02 21:24:23 +0900 | [diff] [blame] | 591 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 592 | * 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 Park | 1687dfc | 2013-04-02 21:24:23 +0900 | [diff] [blame] | 596 | * |
Linus Torvalds | 55db4c6 | 2011-06-04 06:33:24 +0900 | [diff] [blame] | 597 | * Return Value: None |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 598 | */ |
Marcel Holtmann | facf522 | 2015-04-04 19:57:22 -0700 | [diff] [blame] | 599 | static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data, |
| 600 | char *flags, int count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 601 | { |
Marcel Holtmann | dfe19d2 | 2015-04-04 19:57:21 -0700 | [diff] [blame] | 602 | struct hci_uart *hu = tty->disc_data; |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 603 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 604 | if (!hu || tty != hu->tty) |
Linus Torvalds | 55db4c6 | 2011-06-04 06:33:24 +0900 | [diff] [blame] | 605 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 606 | |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 607 | percpu_down_read(&hu->proto_lock); |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 608 | |
| 609 | if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) { |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 610 | percpu_up_read(&hu->proto_lock); |
Linus Torvalds | 55db4c6 | 2011-06-04 06:33:24 +0900 | [diff] [blame] | 611 | return; |
Dean Jenkins | dec2c92 | 2017-05-05 16:27:06 +0100 | [diff] [blame] | 612 | } |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 613 | |
Frederic Danis | 7649faf | 2015-09-23 18:18:10 +0200 | [diff] [blame] | 614 | /* It does not need a lock here as it is already protected by a mutex in |
| 615 | * tty caller |
| 616 | */ |
Marcel Holtmann | 9d1c40e | 2015-04-04 20:59:41 -0700 | [diff] [blame] | 617 | hu->proto->recv(hu, data, count); |
Ronald Tschalär | f6ec33f | 2017-10-25 22:14:53 -0700 | [diff] [blame] | 618 | percpu_up_read(&hu->proto_lock); |
Chan-yeol Park | 788f092 | 2013-04-02 21:24:22 +0900 | [diff] [blame] | 619 | |
| 620 | if (hu->hdev) |
| 621 | hu->hdev->stat.byte_rx += count; |
| 622 | |
Alan Cox | 39c2e60 | 2008-04-30 00:54:18 -0700 | [diff] [blame] | 623 | tty_unthrottle(tty); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 624 | } |
| 625 | |
| 626 | static int hci_uart_register_dev(struct hci_uart *hu) |
| 627 | { |
| 628 | struct hci_dev *hdev; |
Jeremy Cline | 6ea83d9 | 2019-02-06 12:54:16 -0500 | [diff] [blame] | 629 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 630 | |
| 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 Holtmann | c13854c | 2010-02-08 15:27:07 +0100 | [diff] [blame] | 642 | hdev->bus = HCI_UART; |
David Herrmann | 155961e | 2012-02-09 21:58:32 +0100 | [diff] [blame] | 643 | hci_set_drvdata(hdev, hu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 644 | |
Marcel Holtmann | aee61f7 | 2015-10-20 21:30:45 +0200 | [diff] [blame] | 645 | /* 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 652 | 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 Poulain | eb17380 | 2015-03-25 15:19:30 +0100 | [diff] [blame] | 656 | hdev->setup = hci_uart_setup; |
David Herrmann | 6935e0f | 2012-03-09 15:53:42 +0100 | [diff] [blame] | 657 | SET_HCIDEV_DEV(hdev, hu->tty->dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 658 | |
Johan Hedberg | 63c7d09 | 2010-07-12 11:37:04 -0300 | [diff] [blame] | 659 | if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags)) |
| 660 | set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks); |
| 661 | |
Marcel Holtmann | 6afd04a | 2014-07-11 07:12:58 +0200 | [diff] [blame] | 662 | if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags)) |
| 663 | set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks); |
| 664 | |
Marcel Holtmann | a55e1f3 | 2012-02-24 17:12:24 +0100 | [diff] [blame] | 665 | if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags)) |
Szymon Janc | a6c511c | 2012-05-23 12:35:46 +0200 | [diff] [blame] | 666 | set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); |
Marcel Holtmann | a55e1f3 | 2012-02-24 17:12:24 +0100 | [diff] [blame] | 667 | |
Marcel Holtmann | 8a7a3fd | 2012-02-24 17:09:38 +0100 | [diff] [blame] | 668 | if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags)) |
| 669 | hdev->dev_type = HCI_AMP; |
| 670 | else |
Marcel Holtmann | ca8bee5 | 2016-07-05 14:30:14 +0200 | [diff] [blame] | 671 | hdev->dev_type = HCI_PRIMARY; |
Marcel Holtmann | 8a7a3fd | 2012-02-24 17:09:38 +0100 | [diff] [blame] | 672 | |
Jeremy Cline | 6ea83d9 | 2019-02-06 12:54:16 -0500 | [diff] [blame] | 673 | /* 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 Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 683 | if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) |
| 684 | return 0; |
| 685 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 686 | if (hci_register_dev(hdev) < 0) { |
| 687 | BT_ERR("Can't register HCI device"); |
Jeremy Cline | 6ea83d9 | 2019-02-06 12:54:16 -0500 | [diff] [blame] | 688 | hu->proto->close(hu); |
Dean Jenkins | a225b8c | 2017-04-20 18:06:40 +0100 | [diff] [blame] | 689 | hu->hdev = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 690 | hci_free_dev(hdev); |
| 691 | return -ENODEV; |
| 692 | } |
| 693 | |
Johan Hedberg | 9f2aee8 | 2012-07-16 16:12:11 +0300 | [diff] [blame] | 694 | set_bit(HCI_UART_REGISTERED, &hu->flags); |
| 695 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 696 | return 0; |
| 697 | } |
| 698 | |
| 699 | static int hci_uart_set_proto(struct hci_uart *hu, int id) |
| 700 | { |
Marcel Holtmann | 4ee7ef1 | 2015-04-04 22:11:43 -0700 | [diff] [blame] | 701 | const struct hci_uart_proto *p; |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 702 | int err; |
| 703 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 704 | p = hci_uart_get_proto(id); |
| 705 | if (!p) |
| 706 | return -EPROTONOSUPPORT; |
| 707 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 708 | hu->proto = p; |
| 709 | |
| 710 | err = hci_uart_register_dev(hu); |
| 711 | if (err) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 712 | return err; |
| 713 | } |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 714 | |
Kefeng Wang | a1dbb34 | 2019-02-23 12:33:27 +0800 | [diff] [blame] | 715 | set_bit(HCI_UART_PROTO_READY, &hu->flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 716 | return 0; |
| 717 | } |
| 718 | |
Marcel Holtmann | bb72bd6 | 2014-07-11 07:12:57 +0200 | [diff] [blame] | 719 | static 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 Holtmann | 6afd04a | 2014-07-11 07:12:58 +0200 | [diff] [blame] | 724 | BIT(HCI_UART_INIT_PENDING) | |
Marcel Holtmann | fb2ce8d | 2015-04-04 16:13:01 -0700 | [diff] [blame] | 725 | BIT(HCI_UART_EXT_CONFIG) | |
| 726 | BIT(HCI_UART_VND_DETECT); |
Marcel Holtmann | bb72bd6 | 2014-07-11 07:12:57 +0200 | [diff] [blame] | 727 | |
Marcel Holtmann | 41533fe | 2015-04-01 13:51:51 -0700 | [diff] [blame] | 728 | if (flags & ~valid_flags) |
Marcel Holtmann | bb72bd6 | 2014-07-11 07:12:57 +0200 | [diff] [blame] | 729 | return -EINVAL; |
| 730 | |
| 731 | hu->hdev_flags = flags; |
| 732 | |
| 733 | return 0; |
| 734 | } |
| 735 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 736 | /* 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 Holtmann | facf522 | 2015-04-04 19:57:22 -0700 | [diff] [blame] | 749 | static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file *file, |
| 750 | unsigned int cmd, unsigned long arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 751 | { |
Marcel Holtmann | dfe19d2 | 2015-04-04 19:57:21 -0700 | [diff] [blame] | 752 | struct hci_uart *hu = tty->disc_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 753 | 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 Raman | 0565069 | 2016-09-23 18:56:28 +0100 | [diff] [blame] | 765 | if (err) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 766 | clear_bit(HCI_UART_PROTO_SET, &hu->flags); |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 767 | } else |
Vignesh Raman | 0565069 | 2016-09-23 18:56:28 +0100 | [diff] [blame] | 768 | err = -EBUSY; |
Marcel Holtmann | c33be3c | 2007-05-09 09:15:45 +0200 | [diff] [blame] | 769 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 770 | |
| 771 | case HCIUARTGETPROTO: |
| 772 | if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) |
Vignesh Raman | 0565069 | 2016-09-23 18:56:28 +0100 | [diff] [blame] | 773 | err = hu->proto->id; |
| 774 | else |
| 775 | err = -EUNATCH; |
| 776 | break; |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 777 | |
Marcel Holtmann | d215874 | 2007-05-09 09:15:35 +0200 | [diff] [blame] | 778 | case HCIUARTGETDEVICE: |
Marcel Holtmann | c7e0c14 | 2014-07-12 17:00:29 +0200 | [diff] [blame] | 779 | if (test_bit(HCI_UART_REGISTERED, &hu->flags)) |
Vignesh Raman | 0565069 | 2016-09-23 18:56:28 +0100 | [diff] [blame] | 780 | err = hu->hdev->id; |
| 781 | else |
| 782 | err = -EUNATCH; |
| 783 | break; |
Marcel Holtmann | d215874 | 2007-05-09 09:15:35 +0200 | [diff] [blame] | 784 | |
Johan Hedberg | 63c7d09 | 2010-07-12 11:37:04 -0300 | [diff] [blame] | 785 | case HCIUARTSETFLAGS: |
| 786 | if (test_bit(HCI_UART_PROTO_SET, &hu->flags)) |
Vignesh Raman | 0565069 | 2016-09-23 18:56:28 +0100 | [diff] [blame] | 787 | err = -EBUSY; |
| 788 | else |
| 789 | err = hci_uart_set_flags(hu, arg); |
Johan Hedberg | 63c7d09 | 2010-07-12 11:37:04 -0300 | [diff] [blame] | 790 | break; |
| 791 | |
| 792 | case HCIUARTGETFLAGS: |
Vignesh Raman | 0565069 | 2016-09-23 18:56:28 +0100 | [diff] [blame] | 793 | err = hu->hdev_flags; |
| 794 | break; |
Johan Hedberg | 63c7d09 | 2010-07-12 11:37:04 -0300 | [diff] [blame] | 795 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 796 | default: |
Alan Cox | 47afa7a | 2008-10-13 10:44:17 +0100 | [diff] [blame] | 797 | err = n_tty_ioctl_helper(tty, file, cmd, arg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 798 | break; |
Peter Senna Tschudin | a20890d | 2012-09-07 17:24:39 +0200 | [diff] [blame] | 799 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 800 | |
| 801 | return err; |
| 802 | } |
| 803 | |
| 804 | /* |
| 805 | * We don't provide read/write/poll interface for user space. |
| 806 | */ |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 807 | static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, |
Marcel Holtmann | facf522 | 2015-04-04 19:57:22 -0700 | [diff] [blame] | 808 | unsigned char __user *buf, size_t nr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 809 | { |
| 810 | return 0; |
| 811 | } |
| 812 | |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 813 | static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, |
Marcel Holtmann | facf522 | 2015-04-04 19:57:22 -0700 | [diff] [blame] | 814 | const unsigned char *data, size_t count) |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 815 | { |
| 816 | return 0; |
| 817 | } |
| 818 | |
| 819 | static unsigned int hci_uart_tty_poll(struct tty_struct *tty, |
Marcel Holtmann | facf522 | 2015-04-04 19:57:22 -0700 | [diff] [blame] | 820 | struct file *filp, poll_table *wait) |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 821 | { |
| 822 | return 0; |
| 823 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 824 | |
| 825 | static int __init hci_uart_init(void) |
| 826 | { |
Alan Cox | a352def | 2008-07-16 21:53:12 +0100 | [diff] [blame] | 827 | static struct tty_ldisc_ops hci_uart_ldisc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 828 | int err; |
| 829 | |
| 830 | BT_INFO("HCI UART driver ver %s", VERSION); |
| 831 | |
| 832 | /* Register the tty discipline */ |
| 833 | |
Prasanna Karthik | acf50c5 | 2015-07-23 11:08:52 +0000 | [diff] [blame] | 834 | memset(&hci_uart_ldisc, 0, sizeof(hci_uart_ldisc)); |
Marcel Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 835 | 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 Holtmann | 0372a66 | 2005-10-28 19:20:45 +0200 | [diff] [blame] | 843 | 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 846 | |
Valentin Ilie | a08b15e | 2013-08-12 18:46:00 +0300 | [diff] [blame] | 847 | err = tty_register_ldisc(N_HCI, &hci_uart_ldisc); |
| 848 | if (err) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 849 | 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-Cohen | 166d2f6 | 2007-10-20 13:42:36 +0200 | [diff] [blame] | 859 | #ifdef CONFIG_BT_HCIUART_LL |
| 860 | ll_init(); |
| 861 | #endif |
Suraj Sumangala | b3190df | 2010-07-19 12:34:07 +0530 | [diff] [blame] | 862 | #ifdef CONFIG_BT_HCIUART_ATH3K |
| 863 | ath_init(); |
| 864 | #endif |
Johan Hedberg | 7dec65c | 2012-07-16 16:12:02 +0300 | [diff] [blame] | 865 | #ifdef CONFIG_BT_HCIUART_3WIRE |
| 866 | h5_init(); |
| 867 | #endif |
Loic Poulain | ca93cee | 2015-07-01 12:20:26 +0200 | [diff] [blame] | 868 | #ifdef CONFIG_BT_HCIUART_INTEL |
| 869 | intel_init(); |
| 870 | #endif |
Marcel Holtmann | bdd8818 | 2015-04-05 22:52:18 -0700 | [diff] [blame] | 871 | #ifdef CONFIG_BT_HCIUART_BCM |
| 872 | bcm_init(); |
| 873 | #endif |
Ben Young Tae Kim | 0ff252c | 2015-08-10 14:24:17 -0700 | [diff] [blame] | 874 | #ifdef CONFIG_BT_HCIUART_QCA |
| 875 | qca_init(); |
| 876 | #endif |
Loic Poulain | 395174b | 2016-02-22 10:48:03 +0100 | [diff] [blame] | 877 | #ifdef CONFIG_BT_HCIUART_AG6XX |
| 878 | ag6xx_init(); |
| 879 | #endif |
Loic Poulain | 162f812 | 2016-09-19 16:29:27 +0200 | [diff] [blame] | 880 | #ifdef CONFIG_BT_HCIUART_MRVL |
| 881 | mrvl_init(); |
| 882 | #endif |
Ohad Ben-Cohen | 166d2f6 | 2007-10-20 13:42:36 +0200 | [diff] [blame] | 883 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 884 | return 0; |
| 885 | } |
| 886 | |
| 887 | static 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-Cohen | 166d2f6 | 2007-10-20 13:42:36 +0200 | [diff] [blame] | 897 | #ifdef CONFIG_BT_HCIUART_LL |
| 898 | ll_deinit(); |
| 899 | #endif |
Suraj Sumangala | b3190df | 2010-07-19 12:34:07 +0530 | [diff] [blame] | 900 | #ifdef CONFIG_BT_HCIUART_ATH3K |
| 901 | ath_deinit(); |
| 902 | #endif |
Johan Hedberg | 7dec65c | 2012-07-16 16:12:02 +0300 | [diff] [blame] | 903 | #ifdef CONFIG_BT_HCIUART_3WIRE |
| 904 | h5_deinit(); |
| 905 | #endif |
Loic Poulain | ca93cee | 2015-07-01 12:20:26 +0200 | [diff] [blame] | 906 | #ifdef CONFIG_BT_HCIUART_INTEL |
| 907 | intel_deinit(); |
| 908 | #endif |
Marcel Holtmann | bdd8818 | 2015-04-05 22:52:18 -0700 | [diff] [blame] | 909 | #ifdef CONFIG_BT_HCIUART_BCM |
| 910 | bcm_deinit(); |
| 911 | #endif |
Ben Young Tae Kim | 0ff252c | 2015-08-10 14:24:17 -0700 | [diff] [blame] | 912 | #ifdef CONFIG_BT_HCIUART_QCA |
| 913 | qca_deinit(); |
| 914 | #endif |
Loic Poulain | 395174b | 2016-02-22 10:48:03 +0100 | [diff] [blame] | 915 | #ifdef CONFIG_BT_HCIUART_AG6XX |
| 916 | ag6xx_deinit(); |
| 917 | #endif |
Loic Poulain | 162f812 | 2016-09-19 16:29:27 +0200 | [diff] [blame] | 918 | #ifdef CONFIG_BT_HCIUART_MRVL |
| 919 | mrvl_deinit(); |
| 920 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 921 | |
| 922 | /* Release tty registration of line discipline */ |
Valentin Ilie | a08b15e | 2013-08-12 18:46:00 +0300 | [diff] [blame] | 923 | err = tty_unregister_ldisc(N_HCI); |
| 924 | if (err) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 925 | BT_ERR("Can't unregister HCI line discipline (%d)", err); |
| 926 | } |
| 927 | |
| 928 | module_init(hci_uart_init); |
| 929 | module_exit(hci_uart_exit); |
| 930 | |
Marcel Holtmann | 63fbd24 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 931 | MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 932 | MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION); |
| 933 | MODULE_VERSION(VERSION); |
| 934 | MODULE_LICENSE("GPL"); |
| 935 | MODULE_ALIAS_LDISC(N_HCI); |