1 /*
2 *
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 *
24 */
25
26 #include <linux/module.h>
27
28 #include <linux/kernel.h>
29 #include <linux/init.h>
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>
43 #include <linux/firmware.h>
44 #include <linux/serdev.h>
45
46 #include <net/bluetooth/bluetooth.h>
47 #include <net/bluetooth/hci_core.h>
48
49 #include "btintel.h"
50 #include "btbcm.h"
51 #include "hci_uart.h"
52
53 #define VERSION "2.3"
54
55 static const struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
56
hci_uart_register_proto(const struct hci_uart_proto * p)57 int hci_uart_register_proto(const struct hci_uart_proto *p)
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;
66
67 BT_INFO("HCI UART protocol %s registered", p->name);
68
69 return 0;
70 }
71
hci_uart_unregister_proto(const struct hci_uart_proto * p)72 int hci_uart_unregister_proto(const struct hci_uart_proto *p)
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;
81
82 return 0;
83 }
84
hci_uart_get_proto(unsigned int id)85 static const struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
86 {
87 if (id >= HCI_UART_MAX_PROTO)
88 return NULL;
89
90 return hup[id];
91 }
92
hci_uart_tx_complete(struct hci_uart * hu,int pkt_type)93 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
94 {
95 struct hci_dev *hdev = hu->hdev;
96
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:
108 hdev->stat.sco_tx++;
109 break;
110 }
111 }
112
hci_uart_dequeue(struct hci_uart * hu)113 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
114 {
115 struct sk_buff *skb = hu->tx_skb;
116
117 if (!skb) {
118 percpu_down_read(&hu->proto_lock);
119
120 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
121 skb = hu->proto->dequeue(hu);
122
123 percpu_up_read(&hu->proto_lock);
124 } else {
125 hu->tx_skb = NULL;
126 }
127
128 return skb;
129 }
130
hci_uart_tx_wakeup(struct hci_uart * hu)131 int hci_uart_tx_wakeup(struct hci_uart *hu)
132 {
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;
141
142 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags))
143 goto no_schedule;
144
145 if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) {
146 set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
147 goto no_schedule;
148 }
149
150 BT_DBG("");
151
152 schedule_work(&hu->write_work);
153
154 no_schedule:
155 percpu_up_read(&hu->proto_lock);
156
157 return 0;
158 }
159 EXPORT_SYMBOL_GPL(hci_uart_tx_wakeup);
160
hci_uart_write_work(struct work_struct * work)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
172 restart:
173 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
174
175 while ((skb = hci_uart_dequeue(hu))) {
176 int len;
177
178 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
179 len = tty->ops->write(tty, skb->data, skb->len);
180 hdev->stat.byte_tx += len;
181
182 skb_pull(skb, len);
183 if (skb->len) {
184 hu->tx_skb = skb;
185 break;
186 }
187
188 hci_uart_tx_complete(hu, hci_skb_pkt_type(skb));
189 kfree_skb(skb);
190 }
191
192 if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
193 goto restart;
194
195 clear_bit(HCI_UART_SENDING, &hu->tx_state);
196 }
197
hci_uart_init_work(struct work_struct * work)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;
202 struct hci_dev *hdev;
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");
210 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
211 hu->proto->close(hu);
212 hdev = hu->hdev;
213 hu->hdev = NULL;
214 hci_free_dev(hdev);
215 return;
216 }
217
218 set_bit(HCI_UART_REGISTERED, &hu->flags);
219 }
220
hci_uart_init_ready(struct hci_uart * hu)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
231 /* ------- Interface to HCI layer ------ */
232 /* Initialize device */
hci_uart_open(struct hci_dev * hdev)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 */
238 return 0;
239 }
240
241 /* Reset device */
hci_uart_flush(struct hci_dev * hdev)242 static int hci_uart_flush(struct hci_dev *hdev)
243 {
244 struct hci_uart *hu = hci_get_drvdata(hdev);
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);
255 tty_driver_flush_buffer(tty);
256
257 percpu_down_read(&hu->proto_lock);
258
259 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
260 hu->proto->flush(hu);
261
262 percpu_up_read(&hu->proto_lock);
263
264 return 0;
265 }
266
267 /* Close device */
hci_uart_close(struct hci_dev * hdev)268 static int hci_uart_close(struct hci_dev *hdev)
269 {
270 BT_DBG("hdev %p", hdev);
271
272 hci_uart_flush(hdev);
273 hdev->flush = NULL;
274 return 0;
275 }
276
277 /* Send frames from HCI layer */
hci_uart_send_frame(struct hci_dev * hdev,struct sk_buff * skb)278 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
279 {
280 struct hci_uart *hu = hci_get_drvdata(hdev);
281
282 BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb),
283 skb->len);
284
285 percpu_down_read(&hu->proto_lock);
286
287 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
288 percpu_up_read(&hu->proto_lock);
289 return -EUNATCH;
290 }
291
292 hu->proto->enqueue(hu, skb);
293 percpu_up_read(&hu->proto_lock);
294
295 hci_uart_tx_wakeup(hu);
296
297 return 0;
298 }
299
300 /* Check the underlying device or tty has flow control support */
hci_uart_has_flow_control(struct hci_uart * hu)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
313 /* Flow control or un-flow control the device */
hci_uart_set_flow_control(struct hci_uart * hu,bool enable)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
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
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
hci_uart_set_speeds(struct hci_uart * hu,unsigned int init_speed,unsigned int oper_speed)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
hci_uart_set_baudrate(struct hci_uart * hu,unsigned int speed)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;
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
391 BT_DBG("%s: New tty speeds: %d/%d", hu->hdev->name,
392 tty->termios.c_ispeed, tty->termios.c_ospeed);
393 }
394
hci_uart_setup(struct hci_dev * hdev)395 static int hci_uart_setup(struct hci_dev *hdev)
396 {
397 struct hci_uart *hu = hci_get_drvdata(hdev);
398 struct hci_rp_read_local_version *ver;
399 struct sk_buff *skb;
400 unsigned int speed;
401 int err;
402
403 /* Init speed if any */
404 if (hu->init_speed)
405 speed = hu->init_speed;
406 else if (hu->proto->init_speed)
407 speed = hu->proto->init_speed;
408 else
409 speed = 0;
410
411 if (speed)
412 hci_uart_set_baudrate(hu, speed);
413
414 /* Operational speed if any */
415 if (hu->oper_speed)
416 speed = hu->oper_speed;
417 else if (hu->proto->oper_speed)
418 speed = hu->proto->oper_speed;
419 else
420 speed = 0;
421
422 if (hu->proto->set_baudrate && speed) {
423 err = hu->proto->set_baudrate(hu, speed);
424 if (!err)
425 hci_uart_set_baudrate(hu, speed);
426 }
427
428 if (hu->proto->setup)
429 return hu->proto->setup(hu);
430
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)) {
451 #ifdef CONFIG_BT_HCIUART_INTEL
452 case 2:
453 hdev->set_bdaddr = btintel_set_bdaddr;
454 btintel_check_bdaddr(hdev);
455 break;
456 #endif
457 #ifdef CONFIG_BT_HCIUART_BCM
458 case 15:
459 hdev->set_bdaddr = btbcm_set_bdaddr;
460 btbcm_check_bdaddr(hdev);
461 break;
462 #endif
463 }
464
465 done:
466 kfree_skb(skb);
467 return 0;
468 }
469
470 /* ------ LDISC part ------ */
471 /* hci_uart_tty_open
472 *
473 * Called when line discipline changed to HCI_UART.
474 *
475 * Arguments:
476 * tty pointer to tty info structure
477 * Return Value:
478 * 0 if success, otherwise error code
479 */
hci_uart_tty_open(struct tty_struct * tty)480 static int hci_uart_tty_open(struct tty_struct *tty)
481 {
482 struct hci_uart *hu;
483
484 BT_DBG("tty %p", tty);
485
486 /* Error if the tty has no write op instead of leaving an exploitable
487 * hole
488 */
489 if (tty->ops->write == NULL)
490 return -EOPNOTSUPP;
491
492 hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL);
493 if (!hu) {
494 BT_ERR("Can't allocate control structure");
495 return -ENFILE;
496 }
497
498 tty->disc_data = hu;
499 hu->tty = tty;
500 tty->receive_room = 65536;
501
502 /* disable alignment support by default */
503 hu->alignment = 1;
504 hu->padding = 0;
505
506 INIT_WORK(&hu->init_ready, hci_uart_init_work);
507 INIT_WORK(&hu->write_work, hci_uart_write_work);
508
509 percpu_init_rwsem(&hu->proto_lock);
510
511 /* Flush any pending characters in the driver */
512 tty_driver_flush_buffer(tty);
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 */
hci_uart_tty_close(struct tty_struct * tty)522 static void hci_uart_tty_close(struct tty_struct *tty)
523 {
524 struct hci_uart *hu = tty->disc_data;
525 struct hci_dev *hdev;
526
527 BT_DBG("tty %p", tty);
528
529 /* Detach from the tty */
530 tty->disc_data = NULL;
531
532 if (!hu)
533 return;
534
535 hdev = hu->hdev;
536 if (hdev)
537 hci_uart_close(hdev);
538
539 if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
540 percpu_down_write(&hu->proto_lock);
541 clear_bit(HCI_UART_PROTO_READY, &hu->flags);
542 percpu_up_write(&hu->proto_lock);
543
544 cancel_work_sync(&hu->write_work);
545
546 if (hdev) {
547 if (test_bit(HCI_UART_REGISTERED, &hu->flags))
548 hci_unregister_dev(hdev);
549 hci_free_dev(hdev);
550 }
551 hu->proto->close(hu);
552 }
553 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
554
555 percpu_free_rwsem(&hu->proto_lock);
556
557 kfree(hu);
558 }
559
560 /* hci_uart_tty_wakeup()
561 *
562 * Callback for transmit wakeup. Called when low level
563 * device driver can accept more send data.
564 *
565 * Arguments: tty pointer to associated tty instance data
566 * Return Value: None
567 */
hci_uart_tty_wakeup(struct tty_struct * tty)568 static void hci_uart_tty_wakeup(struct tty_struct *tty)
569 {
570 struct hci_uart *hu = tty->disc_data;
571
572 BT_DBG("");
573
574 if (!hu)
575 return;
576
577 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
578
579 if (tty != hu->tty)
580 return;
581
582 if (test_bit(HCI_UART_PROTO_READY, &hu->flags))
583 hci_uart_tx_wakeup(hu);
584 }
585
586 /* hci_uart_tty_receive()
587 *
588 * Called by tty low level driver when receive data is
589 * available.
590 *
591 * Arguments: tty pointer to tty isntance data
592 * data pointer to received data
593 * flags pointer to flags for data
594 * count count of received data in bytes
595 *
596 * Return Value: None
597 */
hci_uart_tty_receive(struct tty_struct * tty,const u8 * data,char * flags,int count)598 static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data,
599 char *flags, int count)
600 {
601 struct hci_uart *hu = tty->disc_data;
602
603 if (!hu || tty != hu->tty)
604 return;
605
606 percpu_down_read(&hu->proto_lock);
607
608 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) {
609 percpu_up_read(&hu->proto_lock);
610 return;
611 }
612
613 /* It does not need a lock here as it is already protected by a mutex in
614 * tty caller
615 */
616 hu->proto->recv(hu, data, count);
617 percpu_up_read(&hu->proto_lock);
618
619 if (hu->hdev)
620 hu->hdev->stat.byte_rx += count;
621
622 tty_unthrottle(tty);
623 }
624
hci_uart_register_dev(struct hci_uart * hu)625 static int hci_uart_register_dev(struct hci_uart *hu)
626 {
627 struct hci_dev *hdev;
628 int err;
629
630 BT_DBG("");
631
632 /* Initialize and register HCI device */
633 hdev = hci_alloc_dev();
634 if (!hdev) {
635 BT_ERR("Can't allocate HCI device");
636 return -ENOMEM;
637 }
638
639 hu->hdev = hdev;
640
641 hdev->bus = HCI_UART;
642 hci_set_drvdata(hdev, hu);
643
644 /* Only when vendor specific setup callback is provided, consider
645 * the manufacturer information valid. This avoids filling in the
646 * value for Ericsson when nothing is specified.
647 */
648 if (hu->proto->setup)
649 hdev->manufacturer = hu->proto->manufacturer;
650
651 hdev->open = hci_uart_open;
652 hdev->close = hci_uart_close;
653 hdev->flush = hci_uart_flush;
654 hdev->send = hci_uart_send_frame;
655 hdev->setup = hci_uart_setup;
656 SET_HCIDEV_DEV(hdev, hu->tty->dev);
657
658 if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
659 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
660
661 if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
662 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
663
664 if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags))
665 set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
666
667 if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
668 hdev->dev_type = HCI_AMP;
669 else
670 hdev->dev_type = HCI_PRIMARY;
671
672 /* Only call open() for the protocol after hdev is fully initialized as
673 * open() (or a timer/workqueue it starts) may attempt to reference it.
674 */
675 err = hu->proto->open(hu);
676 if (err) {
677 hu->hdev = NULL;
678 hci_free_dev(hdev);
679 return err;
680 }
681
682 if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
683 return 0;
684
685 if (hci_register_dev(hdev) < 0) {
686 BT_ERR("Can't register HCI device");
687 hu->proto->close(hu);
688 hu->hdev = NULL;
689 hci_free_dev(hdev);
690 return -ENODEV;
691 }
692
693 set_bit(HCI_UART_REGISTERED, &hu->flags);
694
695 return 0;
696 }
697
hci_uart_set_proto(struct hci_uart * hu,int id)698 static int hci_uart_set_proto(struct hci_uart *hu, int id)
699 {
700 const struct hci_uart_proto *p;
701 int err;
702
703 p = hci_uart_get_proto(id);
704 if (!p)
705 return -EPROTONOSUPPORT;
706
707 hu->proto = p;
708
709 err = hci_uart_register_dev(hu);
710 if (err) {
711 return err;
712 }
713
714 set_bit(HCI_UART_PROTO_READY, &hu->flags);
715 return 0;
716 }
717
hci_uart_set_flags(struct hci_uart * hu,unsigned long flags)718 static int hci_uart_set_flags(struct hci_uart *hu, unsigned long flags)
719 {
720 unsigned long valid_flags = BIT(HCI_UART_RAW_DEVICE) |
721 BIT(HCI_UART_RESET_ON_INIT) |
722 BIT(HCI_UART_CREATE_AMP) |
723 BIT(HCI_UART_INIT_PENDING) |
724 BIT(HCI_UART_EXT_CONFIG) |
725 BIT(HCI_UART_VND_DETECT);
726
727 if (flags & ~valid_flags)
728 return -EINVAL;
729
730 hu->hdev_flags = flags;
731
732 return 0;
733 }
734
735 /* hci_uart_tty_ioctl()
736 *
737 * Process IOCTL system call for the tty device.
738 *
739 * Arguments:
740 *
741 * tty pointer to tty instance data
742 * file pointer to open file object for device
743 * cmd IOCTL command code
744 * arg argument for IOCTL call (cmd dependent)
745 *
746 * Return Value: Command dependent
747 */
hci_uart_tty_ioctl(struct tty_struct * tty,struct file * file,unsigned int cmd,unsigned long arg)748 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file *file,
749 unsigned int cmd, unsigned long arg)
750 {
751 struct hci_uart *hu = tty->disc_data;
752 int err = 0;
753
754 BT_DBG("");
755
756 /* Verify the status of the device */
757 if (!hu)
758 return -EBADF;
759
760 switch (cmd) {
761 case HCIUARTSETPROTO:
762 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
763 err = hci_uart_set_proto(hu, arg);
764 if (err)
765 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
766 } else
767 err = -EBUSY;
768 break;
769
770 case HCIUARTGETPROTO:
771 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
772 err = hu->proto->id;
773 else
774 err = -EUNATCH;
775 break;
776
777 case HCIUARTGETDEVICE:
778 if (test_bit(HCI_UART_REGISTERED, &hu->flags))
779 err = hu->hdev->id;
780 else
781 err = -EUNATCH;
782 break;
783
784 case HCIUARTSETFLAGS:
785 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
786 err = -EBUSY;
787 else
788 err = hci_uart_set_flags(hu, arg);
789 break;
790
791 case HCIUARTGETFLAGS:
792 err = hu->hdev_flags;
793 break;
794
795 default:
796 err = n_tty_ioctl_helper(tty, file, cmd, arg);
797 break;
798 }
799
800 return err;
801 }
802
803 /*
804 * We don't provide read/write/poll interface for user space.
805 */
hci_uart_tty_read(struct tty_struct * tty,struct file * file,unsigned char __user * buf,size_t nr)806 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file,
807 unsigned char __user *buf, size_t nr)
808 {
809 return 0;
810 }
811
hci_uart_tty_write(struct tty_struct * tty,struct file * file,const unsigned char * data,size_t count)812 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file,
813 const unsigned char *data, size_t count)
814 {
815 return 0;
816 }
817
hci_uart_tty_poll(struct tty_struct * tty,struct file * filp,poll_table * wait)818 static unsigned int hci_uart_tty_poll(struct tty_struct *tty,
819 struct file *filp, poll_table *wait)
820 {
821 return 0;
822 }
823
hci_uart_init(void)824 static int __init hci_uart_init(void)
825 {
826 static struct tty_ldisc_ops hci_uart_ldisc;
827 int err;
828
829 BT_INFO("HCI UART driver ver %s", VERSION);
830
831 /* Register the tty discipline */
832
833 memset(&hci_uart_ldisc, 0, sizeof(hci_uart_ldisc));
834 hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
835 hci_uart_ldisc.name = "n_hci";
836 hci_uart_ldisc.open = hci_uart_tty_open;
837 hci_uart_ldisc.close = hci_uart_tty_close;
838 hci_uart_ldisc.read = hci_uart_tty_read;
839 hci_uart_ldisc.write = hci_uart_tty_write;
840 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
841 hci_uart_ldisc.poll = hci_uart_tty_poll;
842 hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
843 hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;
844 hci_uart_ldisc.owner = THIS_MODULE;
845
846 err = tty_register_ldisc(N_HCI, &hci_uart_ldisc);
847 if (err) {
848 BT_ERR("HCI line discipline registration failed. (%d)", err);
849 return err;
850 }
851
852 #ifdef CONFIG_BT_HCIUART_H4
853 h4_init();
854 #endif
855 #ifdef CONFIG_BT_HCIUART_BCSP
856 bcsp_init();
857 #endif
858 #ifdef CONFIG_BT_HCIUART_LL
859 ll_init();
860 #endif
861 #ifdef CONFIG_BT_HCIUART_ATH3K
862 ath_init();
863 #endif
864 #ifdef CONFIG_BT_HCIUART_3WIRE
865 h5_init();
866 #endif
867 #ifdef CONFIG_BT_HCIUART_INTEL
868 intel_init();
869 #endif
870 #ifdef CONFIG_BT_HCIUART_BCM
871 bcm_init();
872 #endif
873 #ifdef CONFIG_BT_HCIUART_QCA
874 qca_init();
875 #endif
876 #ifdef CONFIG_BT_HCIUART_AG6XX
877 ag6xx_init();
878 #endif
879 #ifdef CONFIG_BT_HCIUART_MRVL
880 mrvl_init();
881 #endif
882
883 return 0;
884 }
885
hci_uart_exit(void)886 static void __exit hci_uart_exit(void)
887 {
888 int err;
889
890 #ifdef CONFIG_BT_HCIUART_H4
891 h4_deinit();
892 #endif
893 #ifdef CONFIG_BT_HCIUART_BCSP
894 bcsp_deinit();
895 #endif
896 #ifdef CONFIG_BT_HCIUART_LL
897 ll_deinit();
898 #endif
899 #ifdef CONFIG_BT_HCIUART_ATH3K
900 ath_deinit();
901 #endif
902 #ifdef CONFIG_BT_HCIUART_3WIRE
903 h5_deinit();
904 #endif
905 #ifdef CONFIG_BT_HCIUART_INTEL
906 intel_deinit();
907 #endif
908 #ifdef CONFIG_BT_HCIUART_BCM
909 bcm_deinit();
910 #endif
911 #ifdef CONFIG_BT_HCIUART_QCA
912 qca_deinit();
913 #endif
914 #ifdef CONFIG_BT_HCIUART_AG6XX
915 ag6xx_deinit();
916 #endif
917 #ifdef CONFIG_BT_HCIUART_MRVL
918 mrvl_deinit();
919 #endif
920
921 /* Release tty registration of line discipline */
922 err = tty_unregister_ldisc(N_HCI);
923 if (err)
924 BT_ERR("Can't unregister HCI line discipline (%d)", err);
925 }
926
927 module_init(hci_uart_init);
928 module_exit(hci_uart_exit);
929
930 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
931 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
932 MODULE_VERSION(VERSION);
933 MODULE_LICENSE("GPL");
934 MODULE_ALIAS_LDISC(N_HCI);
935