1/* $NetBSD: btuart.c,v 1.28 2015/08/20 14:40:17 christos Exp $ */
2
3/*-
4 * Copyright (c) 2006, 2007 KIYOHARA Takashi
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
20 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__KERNEL_RCSID(0, "$NetBSD: btuart.c,v 1.28 2015/08/20 14:40:17 christos Exp $");
31
32#include <sys/param.h>
33#include <sys/conf.h>
34#include <sys/device.h>
35#include <sys/errno.h>
36#include <sys/fcntl.h>
37#include <sys/kauth.h>
38#include <sys/kernel.h>
39#include <sys/malloc.h>
40#include <sys/mbuf.h>
41#include <sys/proc.h>
42#include <sys/syslimits.h>
43#include <sys/systm.h>
44#include <sys/tty.h>
45
46#include <sys/bus.h>
47#include <sys/intr.h>
48
49#include <netbt/bluetooth.h>
50#include <netbt/hci.h>
51
52#include "ioconf.h"
53
54struct btuart_softc {
55 device_t sc_dev;
56 struct tty * sc_tp; /* tty pointer */
57
58 bool sc_enabled; /* device is enabled */
59 struct hci_unit *sc_unit; /* Bluetooth HCI handle */
60 struct bt_stats sc_stats;
61
62 int sc_state; /* receive state */
63 int sc_want; /* how much we want */
64 struct mbuf * sc_rxp; /* incoming packet */
65
66 bool sc_xmit; /* transmit is active */
67 struct mbuf * sc_txp; /* outgoing packet */
68
69 /* transmit queues */
70 MBUFQ_HEAD() sc_cmdq;
71 MBUFQ_HEAD() sc_aclq;
72 MBUFQ_HEAD() sc_scoq;
73};
74
75/* sc_state */
76#define BTUART_RECV_PKT_TYPE 0 /* packet type */
77#define BTUART_RECV_ACL_HDR 1 /* acl header */
78#define BTUART_RECV_SCO_HDR 2 /* sco header */
79#define BTUART_RECV_EVENT_HDR 3 /* event header */
80#define BTUART_RECV_ACL_DATA 4 /* acl packet data */
81#define BTUART_RECV_SCO_DATA 5 /* sco packet data */
82#define BTUART_RECV_EVENT_DATA 6 /* event packet data */
83
84static int btuart_match(device_t, cfdata_t, void *);
85static void btuart_attach(device_t, device_t, void *);
86static int btuart_detach(device_t, int);
87
88static int btuartopen(dev_t, struct tty *);
89static int btuartclose(struct tty *, int);
90static int btuartioctl(struct tty *, u_long, void *, int, struct lwp *);
91static int btuartinput(int, struct tty *);
92static int btuartstart(struct tty *);
93
94static int btuart_enable(device_t);
95static void btuart_disable(device_t);
96static void btuart_output_cmd(device_t, struct mbuf *);
97static void btuart_output_acl(device_t, struct mbuf *);
98static void btuart_output_sco(device_t, struct mbuf *);
99static void btuart_stats(device_t, struct bt_stats *, int);
100
101/*
102 * It doesn't need to be exported, as only btuartattach() uses it,
103 * but there's no "official" way to make it static.
104 */
105CFATTACH_DECL_NEW(btuart, sizeof(struct btuart_softc),
106 btuart_match, btuart_attach, btuart_detach, NULL);
107
108static struct linesw btuart_disc = {
109 .l_name = "btuart",
110 .l_open = btuartopen,
111 .l_close = btuartclose,
112 .l_read = ttyerrio,
113 .l_write = ttyerrio,
114 .l_ioctl = btuartioctl,
115 .l_rint = btuartinput,
116 .l_start = btuartstart,
117 .l_modem = ttymodem,
118 .l_poll = ttyerrpoll,
119};
120
121static const struct hci_if btuart_hci = {
122 .enable = btuart_enable,
123 .disable = btuart_disable,
124 .output_cmd = btuart_output_cmd,
125 .output_acl = btuart_output_acl,
126 .output_sco = btuart_output_sco,
127 .get_stats = btuart_stats,
128 .ipl = IPL_TTY,
129};
130
131/*****************************************************************************
132 *
133 * autoconf(9) functions
134 */
135
136/*
137 * pseudo-device attach routine.
138 */
139void
140btuartattach(int num __unused)
141{
142 int error;
143
144 error = ttyldisc_attach(&btuart_disc);
145 if (error) {
146 aprint_error("%s: unable to register line discipline, "
147 "error = %d\n", btuart_cd.cd_name, error);
148
149 return;
150 }
151
152 error = config_cfattach_attach(btuart_cd.cd_name, &btuart_ca);
153 if (error) {
154 aprint_error("%s: unable to register cfattach, error = %d\n",
155 btuart_cd.cd_name, error);
156
157 config_cfdriver_detach(&btuart_cd);
158 (void) ttyldisc_detach(&btuart_disc);
159 }
160}
161
162/*
163 * Autoconf match routine.
164 */
165static int
166btuart_match(device_t self __unused, cfdata_t cfdata __unused,
167 void *arg __unused)
168{
169
170 /* pseudo-device; always present */
171 return 1;
172}
173
174/*
175 * Autoconf attach routine.
176 * Called by config_attach_pseudo(9) when we open the line discipline.
177 */
178static void
179btuart_attach(device_t parent __unused, device_t self, void *aux __unused)
180{
181 struct btuart_softc *sc = device_private(self);
182
183 sc->sc_dev = self;
184
185 MBUFQ_INIT(&sc->sc_cmdq);
186 MBUFQ_INIT(&sc->sc_aclq);
187 MBUFQ_INIT(&sc->sc_scoq);
188
189 /* Attach Bluetooth unit */
190 sc->sc_unit = hci_attach_pcb(&btuart_hci, self, 0);
191 if (sc->sc_unit == NULL)
192 aprint_error_dev(self, "HCI attach failed\n");
193}
194
195/*
196 * Autoconf detach routine.
197 * Called when we close the line discipline.
198 */
199static int
200btuart_detach(device_t self, int flags __unused)
201{
202 struct btuart_softc *sc = device_private(self);
203
204 btuart_disable(self);
205
206 if (sc->sc_unit) {
207 hci_detach_pcb(sc->sc_unit);
208 sc->sc_unit = NULL;
209 }
210
211 return 0;
212}
213
214/*****************************************************************************
215 *
216 * Line discipline functions.
217 */
218
219static int
220btuartopen(dev_t devno __unused, struct tty *tp)
221{
222 struct btuart_softc *sc;
223 device_t dev;
224 cfdata_t cfdata;
225 struct lwp *l = curlwp; /* XXX */
226 int error, unit, s;
227
228 error = kauth_authorize_device(l->l_cred, KAUTH_DEVICE_BLUETOOTH_BTUART,
229 KAUTH_ARG(KAUTH_REQ_DEVICE_BLUETOOTH_BTUART_ADD), NULL, NULL, NULL);
230 if (error)
231 return (error);
232
233 s = spltty();
234
235 if (tp->t_linesw == &btuart_disc) {
236 sc = tp->t_sc;
237 if (sc != NULL) {
238 splx(s);
239 return EBUSY;
240 }
241 }
242
243 KASSERT(tp->t_oproc != NULL);
244
245 cfdata = malloc(sizeof(struct cfdata), M_DEVBUF, M_WAITOK);
246 for (unit = 0; unit < btuart_cd.cd_ndevs; unit++)
247 if (device_lookup(&btuart_cd, unit) == NULL)
248 break;
249
250 cfdata->cf_name = btuart_cd.cd_name;
251 cfdata->cf_atname = btuart_cd.cd_name;
252 cfdata->cf_unit = unit;
253 cfdata->cf_fstate = FSTATE_STAR;
254
255 dev = config_attach_pseudo(cfdata);
256 if (dev == NULL) {
257 free(cfdata, M_DEVBUF);
258 splx(s);
259 return EIO;
260 }
261 sc = device_private(dev);
262
263 aprint_normal_dev(dev, "major %llu minor %llu\n",
264 (unsigned long long)major(tp->t_dev),
265 (unsigned long long)minor(tp->t_dev));
266
267 sc->sc_tp = tp;
268 tp->t_sc = sc;
269
270 mutex_spin_enter(&tty_lock);
271 ttyflush(tp, FREAD | FWRITE);
272 mutex_spin_exit(&tty_lock);
273
274 splx(s);
275
276 return 0;
277}
278
279static int
280btuartclose(struct tty *tp, int flag __unused)
281{
282 struct btuart_softc *sc = tp->t_sc;
283 cfdata_t cfdata;
284 int s;
285
286 s = spltty();
287
288 mutex_spin_enter(&tty_lock);
289 ttyflush(tp, FREAD | FWRITE);
290 mutex_spin_exit(&tty_lock); /* XXX */
291
292 ttyldisc_release(tp->t_linesw);
293 tp->t_linesw = ttyldisc_default();
294
295 if (sc != NULL) {
296 tp->t_sc = NULL;
297 if (sc->sc_tp == tp) {
298 cfdata = device_cfdata(sc->sc_dev);
299 config_detach(sc->sc_dev, 0);
300 free(cfdata, M_DEVBUF);
301 }
302 }
303
304 splx(s);
305
306 return 0;
307}
308
309static int
310btuartioctl(struct tty *tp, u_long cmd, void *data __unused,
311 int flag __unused, struct lwp *l __unused)
312{
313 struct btuart_softc *sc = tp->t_sc;
314 int error;
315
316 if (sc == NULL || tp != sc->sc_tp)
317 return EPASSTHROUGH;
318
319 switch(cmd) {
320 default:
321 error = EPASSTHROUGH;
322 break;
323 }
324
325 return error;
326}
327
328static int
329btuartinput(int c, struct tty *tp)
330{
331 struct btuart_softc *sc = tp->t_sc;
332 struct mbuf *m = sc->sc_rxp;
333 int space = 0;
334
335 if (!sc->sc_enabled)
336 return 0;
337
338 c &= TTY_CHARMASK;
339
340 /* If we already started a packet, find the trailing end of it. */
341 if (m) {
342 while (m->m_next)
343 m = m->m_next;
344
345 space = M_TRAILINGSPACE(m);
346 }
347
348 if (space == 0) {
349 if (m == NULL) {
350 /* new packet */
351 MGETHDR(m, M_DONTWAIT, MT_DATA);
352 if (m == NULL) {
353 aprint_error_dev(sc->sc_dev, "out of memory\n");
354 sc->sc_stats.err_rx++;
355 return 0; /* (lost sync) */
356 }
357
358 sc->sc_rxp = m;
359 m->m_pkthdr.len = m->m_len = 0;
360 space = MHLEN;
361
362 sc->sc_state = BTUART_RECV_PKT_TYPE;
363 sc->sc_want = 1;
364 } else {
365 /* extend mbuf */
366 MGET(m->m_next, M_DONTWAIT, MT_DATA);
367 if (m->m_next == NULL) {
368 aprint_error_dev(sc->sc_dev, "out of memory\n");
369 sc->sc_stats.err_rx++;
370 return 0; /* (lost sync) */
371 }
372
373 m = m->m_next;
374 m->m_len = 0;
375 space = MLEN;
376
377 if (sc->sc_want > MINCLSIZE) {
378 MCLGET(m, M_DONTWAIT);
379 if (m->m_flags & M_EXT)
380 space = MCLBYTES;
381 }
382 }
383 }
384
385 mtod(m, uint8_t *)[m->m_len++] = c;
386 sc->sc_rxp->m_pkthdr.len++;
387 sc->sc_stats.byte_rx++;
388
389 sc->sc_want--;
390 if (sc->sc_want > 0)
391 return 0; /* want more */
392
393 switch (sc->sc_state) {
394 case BTUART_RECV_PKT_TYPE: /* Got packet type */
395
396 switch (c) {
397 case HCI_ACL_DATA_PKT:
398 sc->sc_state = BTUART_RECV_ACL_HDR;
399 sc->sc_want = sizeof(hci_acldata_hdr_t) - 1;
400 break;
401
402 case HCI_SCO_DATA_PKT:
403 sc->sc_state = BTUART_RECV_SCO_HDR;
404 sc->sc_want = sizeof(hci_scodata_hdr_t) - 1;
405 break;
406
407 case HCI_EVENT_PKT:
408 sc->sc_state = BTUART_RECV_EVENT_HDR;
409 sc->sc_want = sizeof(hci_event_hdr_t) - 1;
410 break;
411
412 default:
413 aprint_error_dev(sc->sc_dev,
414 "Unknown packet type=%#x!\n", c);
415 sc->sc_stats.err_rx++;
416 m_freem(sc->sc_rxp);
417 sc->sc_rxp = NULL;
418 return 0; /* (lost sync) */
419 }
420
421 break;
422
423 /*
424 * we assume (correctly of course :) that the packet headers all fit
425 * into a single pkthdr mbuf
426 */
427 case BTUART_RECV_ACL_HDR: /* Got ACL Header */
428 sc->sc_state = BTUART_RECV_ACL_DATA;
429 sc->sc_want = mtod(m, hci_acldata_hdr_t *)->length;
430 sc->sc_want = le16toh(sc->sc_want);
431 break;
432
433 case BTUART_RECV_SCO_HDR: /* Got SCO Header */
434 sc->sc_state = BTUART_RECV_SCO_DATA;
435 sc->sc_want = mtod(m, hci_scodata_hdr_t *)->length;
436 break;
437
438 case BTUART_RECV_EVENT_HDR: /* Got Event Header */
439 sc->sc_state = BTUART_RECV_EVENT_DATA;
440 sc->sc_want = mtod(m, hci_event_hdr_t *)->length;
441 break;
442
443 case BTUART_RECV_ACL_DATA: /* ACL Packet Complete */
444 if (!hci_input_acl(sc->sc_unit, sc->sc_rxp))
445 sc->sc_stats.err_rx++;
446
447 sc->sc_stats.acl_rx++;
448 sc->sc_rxp = m = NULL;
449 break;
450
451 case BTUART_RECV_SCO_DATA: /* SCO Packet Complete */
452 if (!hci_input_sco(sc->sc_unit, sc->sc_rxp))
453 sc->sc_stats.err_rx++;
454
455 sc->sc_stats.sco_rx++;
456 sc->sc_rxp = m = NULL;
457 break;
458
459 case BTUART_RECV_EVENT_DATA: /* Event Packet Complete */
460 if (!hci_input_event(sc->sc_unit, sc->sc_rxp))
461 sc->sc_stats.err_rx++;
462
463 sc->sc_stats.evt_rx++;
464 sc->sc_rxp = m = NULL;
465 break;
466
467 default:
468 panic("%s: invalid state %d!\n",
469 device_xname(sc->sc_dev), sc->sc_state);
470 }
471
472 return 0;
473}
474
475static int
476btuartstart(struct tty *tp)
477{
478 struct btuart_softc *sc = tp->t_sc;
479 struct mbuf *m;
480 int count, rlen;
481 uint8_t *rptr;
482
483 if (!sc->sc_enabled)
484 return 0;
485
486 m = sc->sc_txp;
487 if (m == NULL) {
488 if (MBUFQ_FIRST(&sc->sc_cmdq)) {
489 MBUFQ_DEQUEUE(&sc->sc_cmdq, m);
490 sc->sc_stats.cmd_tx++;
491 } else if (MBUFQ_FIRST(&sc->sc_scoq)) {
492 MBUFQ_DEQUEUE(&sc->sc_scoq, m);
493 sc->sc_stats.sco_tx++;
494 } else if (MBUFQ_FIRST(&sc->sc_aclq)) {
495 MBUFQ_DEQUEUE(&sc->sc_aclq, m);
496 sc->sc_stats.acl_tx++;
497 } else {
498 sc->sc_xmit = false;
499 return 0; /* no more to send */
500 }
501
502 sc->sc_txp = m;
503 sc->sc_xmit = true;
504 }
505
506 count = 0;
507 rlen = 0;
508 rptr = mtod(m, uint8_t *);
509
510 for(;;) {
511 if (rlen >= m->m_len) {
512 m = m->m_next;
513 if (m == NULL) {
514 m = sc->sc_txp;
515 sc->sc_txp = NULL;
516
517 if (M_GETCTX(m, void *) == NULL)
518 m_freem(m);
519 else if (!hci_complete_sco(sc->sc_unit, m))
520 sc->sc_stats.err_tx++;
521
522 break;
523 }
524
525 rlen = 0;
526 rptr = mtod(m, uint8_t *);
527 continue;
528 }
529
530 if (putc(*rptr++, &tp->t_outq) < 0) {
531 m_adj(m, rlen);
532 break;
533 }
534 rlen++;
535 count++;
536 }
537
538 sc->sc_stats.byte_tx += count;
539
540 if (tp->t_outq.c_cc != 0)
541 (*tp->t_oproc)(tp);
542
543 return 0;
544}
545
546/*****************************************************************************
547 *
548 * bluetooth(9) functions
549 */
550
551static int
552btuart_enable(device_t self)
553{
554 struct btuart_softc *sc = device_private(self);
555 int s;
556
557 if (sc->sc_enabled)
558 return 0;
559
560 s = spltty();
561
562 sc->sc_enabled = true;
563 sc->sc_xmit = false;
564
565 splx(s);
566
567 return 0;
568}
569
570static void
571btuart_disable(device_t self)
572{
573 struct btuart_softc *sc = device_private(self);
574 int s;
575
576 if (!sc->sc_enabled)
577 return;
578
579 s = spltty();
580
581 if (sc->sc_rxp) {
582 m_freem(sc->sc_rxp);
583 sc->sc_rxp = NULL;
584 }
585
586 if (sc->sc_txp) {
587 m_freem(sc->sc_txp);
588 sc->sc_txp = NULL;
589 }
590
591 MBUFQ_DRAIN(&sc->sc_cmdq);
592 MBUFQ_DRAIN(&sc->sc_aclq);
593 MBUFQ_DRAIN(&sc->sc_scoq);
594
595 sc->sc_enabled = false;
596
597 splx(s);
598}
599
600static void
601btuart_output_cmd(device_t self, struct mbuf *m)
602{
603 struct btuart_softc *sc = device_private(self);
604 int s;
605
606 KASSERT(sc->sc_enabled);
607
608 M_SETCTX(m, NULL);
609
610 s = spltty();
611 MBUFQ_ENQUEUE(&sc->sc_cmdq, m);
612 if (!sc->sc_xmit)
613 btuartstart(sc->sc_tp);
614
615 splx(s);
616}
617
618static void
619btuart_output_acl(device_t self, struct mbuf *m)
620{
621 struct btuart_softc *sc = device_private(self);
622 int s;
623
624 KASSERT(sc->sc_enabled);
625
626 M_SETCTX(m, NULL);
627
628 s = spltty();
629 MBUFQ_ENQUEUE(&sc->sc_aclq, m);
630 if (!sc->sc_xmit)
631 btuartstart(sc->sc_tp);
632
633 splx(s);
634}
635
636static void
637btuart_output_sco(device_t self, struct mbuf *m)
638{
639 struct btuart_softc *sc = device_private(self);
640 int s;
641
642 KASSERT(sc->sc_enabled);
643
644 s = spltty();
645 MBUFQ_ENQUEUE(&sc->sc_scoq, m);
646 if (!sc->sc_xmit)
647 btuartstart(sc->sc_tp);
648
649 splx(s);
650}
651
652static void
653btuart_stats(device_t self, struct bt_stats *dest, int flush)
654{
655 struct btuart_softc *sc = device_private(self);
656 int s;
657
658 s = spltty();
659
660 memcpy(dest, &sc->sc_stats, sizeof(struct bt_stats));
661
662 if (flush)
663 memset(&sc->sc_stats, 0, sizeof(struct bt_stats));
664
665 splx(s);
666}
667