/*      $NetBSD: btuart.c,v 1.32 2024/07/05 04:31:50 rin Exp $  */

/*-
* Copyright (c) 2006, 2007 KIYOHARA Takashi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: btuart.c,v 1.32 2024/07/05 04:31:50 rin Exp $");

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/kauth.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/proc.h>
#include <sys/syslimits.h>
#include <sys/systm.h>
#include <sys/tty.h>

#include <sys/bus.h>
#include <sys/intr.h>

#include <netbt/bluetooth.h>
#include <netbt/hci.h>

#include "ioconf.h"

struct btuart_softc {
       device_t        sc_dev;
       struct tty *    sc_tp;          /* tty pointer */

       bool            sc_enabled;     /* device is enabled */
       struct hci_unit *sc_unit;       /* Bluetooth HCI handle */
       struct bt_stats sc_stats;

       int             sc_state;       /* receive state */
       int             sc_want;        /* how much we want */
       struct mbuf *   sc_rxp;         /* incoming packet */

       bool            sc_xmit;        /* transmit is active */
       struct mbuf *   sc_txp;         /* outgoing packet */

       /* transmit queues */
       MBUFQ_HEAD()    sc_cmdq;
       MBUFQ_HEAD()    sc_aclq;
       MBUFQ_HEAD()    sc_scoq;
};

/* sc_state */
#define BTUART_RECV_PKT_TYPE    0       /* packet type */
#define BTUART_RECV_ACL_HDR     1       /* acl header */
#define BTUART_RECV_SCO_HDR     2       /* sco header */
#define BTUART_RECV_EVENT_HDR   3       /* event header */
#define BTUART_RECV_ACL_DATA    4       /* acl packet data */
#define BTUART_RECV_SCO_DATA    5       /* sco packet data */
#define BTUART_RECV_EVENT_DATA  6       /* event packet data */

static int btuart_match(device_t, cfdata_t, void *);
static void btuart_attach(device_t, device_t, void *);
static int btuart_detach(device_t, int);

static int btuartopen(dev_t, struct tty *);
static int btuartclose(struct tty *, int);
static int btuartioctl(struct tty *, u_long, void *, int, struct lwp *);
static int btuartinput(int, struct tty *);
static int btuartstart(struct tty *);

static int btuart_enable(device_t);
static void btuart_disable(device_t);
static void btuart_output_cmd(device_t, struct mbuf *);
static void btuart_output_acl(device_t, struct mbuf *);
static void btuart_output_sco(device_t, struct mbuf *);
static void btuart_stats(device_t, struct bt_stats *, int);

/*
* It doesn't need to be exported, as only btuartattach() uses it,
* but there's no "official" way to make it static.
*/
CFATTACH_DECL_NEW(btuart, sizeof(struct btuart_softc),
   btuart_match, btuart_attach, btuart_detach, NULL);

static struct linesw btuart_disc = {
       .l_name =       "btuart",
       .l_open =       btuartopen,
       .l_close =      btuartclose,
       .l_read =       ttyerrio,
       .l_write =      ttyerrio,
       .l_ioctl =      btuartioctl,
       .l_rint =       btuartinput,
       .l_start =      btuartstart,
       .l_modem =      ttymodem,
       .l_poll =       ttyerrpoll,
};

static const struct hci_if btuart_hci = {
       .enable =       btuart_enable,
       .disable =      btuart_disable,
       .output_cmd =   btuart_output_cmd,
       .output_acl =   btuart_output_acl,
       .output_sco =   btuart_output_sco,
       .get_stats =    btuart_stats,
       .ipl =          IPL_TTY,
};

/*****************************************************************************
*
*      autoconf(9) functions
*/

/*
* pseudo-device attach routine.
*/
void
btuartattach(int num __unused)
{
       int error;

       error = ttyldisc_attach(&btuart_disc);
       if (error) {
               aprint_error("%s: unable to register line discipline, "
                   "error = %d\n", btuart_cd.cd_name, error);

               return;
       }

       error = config_cfattach_attach(btuart_cd.cd_name, &btuart_ca);
       if (error) {
               aprint_error("%s: unable to register cfattach, error = %d\n",
                   btuart_cd.cd_name, error);

               config_cfdriver_detach(&btuart_cd);
               (void) ttyldisc_detach(&btuart_disc);
       }
}

/*
* Autoconf match routine.
*/
static int
btuart_match(device_t self __unused, cfdata_t cfdata __unused,
            void *arg __unused)
{

       /* pseudo-device; always present */
       return 1;
}

/*
* Autoconf attach routine.
* Called by config_attach_pseudo(9) when we open the line discipline.
*/
static void
btuart_attach(device_t parent __unused, device_t self, void *aux __unused)
{
       struct btuart_softc *sc = device_private(self);

       sc->sc_dev = self;

       MBUFQ_INIT(&sc->sc_cmdq);
       MBUFQ_INIT(&sc->sc_aclq);
       MBUFQ_INIT(&sc->sc_scoq);

       /* Attach Bluetooth unit */
       sc->sc_unit = hci_attach_pcb(&btuart_hci, self, 0);
       if (sc->sc_unit == NULL)
               aprint_error_dev(self, "HCI attach failed\n");
}

/*
* Autoconf detach routine.
* Called when we close the line discipline.
*/
static int
btuart_detach(device_t self, int flags __unused)
{
       struct btuart_softc *sc = device_private(self);

       btuart_disable(self);

       if (sc->sc_unit) {
               hci_detach_pcb(sc->sc_unit);
               sc->sc_unit = NULL;
       }

       return 0;
}

/*****************************************************************************
*
*      Line discipline functions.
*/

static int
btuartopen(dev_t devno __unused, struct tty *tp)
{
       struct btuart_softc *sc;
       device_t dev;
       cfdata_t cfdata;
       struct lwp *l = curlwp;         /* XXX */
       int error, unit, s;

       error = kauth_authorize_device(l->l_cred, KAUTH_DEVICE_BLUETOOTH_BTUART,
           KAUTH_ARG(KAUTH_REQ_DEVICE_BLUETOOTH_BTUART_ADD), NULL, NULL, NULL);
       if (error)
               return (error);

       s = spltty();

       if (tp->t_linesw == &btuart_disc) {
               sc = tp->t_sc;
               if (sc != NULL) {
                       splx(s);
                       return EBUSY;
               }
       }

       cfdata = malloc(sizeof(struct cfdata), M_DEVBUF, M_WAITOK);
       for (unit = 0; unit < btuart_cd.cd_ndevs; unit++)
               if (device_lookup(&btuart_cd, unit) == NULL)
                       break;

       cfdata->cf_name = btuart_cd.cd_name;
       cfdata->cf_atname = btuart_cd.cd_name;
       cfdata->cf_unit = unit;
       cfdata->cf_fstate = FSTATE_STAR;

       dev = config_attach_pseudo(cfdata);
       if (dev == NULL) {
               free(cfdata, M_DEVBUF);
               splx(s);
               return EIO;
       }
       sc = device_private(dev);

       aprint_normal_dev(dev, "major %llu minor %llu\n",
           (unsigned long long)major(tp->t_dev),
           (unsigned long long)minor(tp->t_dev));

       sc->sc_tp = tp;
       tp->t_sc = sc;

       ttylock(tp);
       ttyflush(tp, FREAD | FWRITE);
       ttyunlock(tp);

       splx(s);

       return 0;
}

static int
btuartclose(struct tty *tp, int flag __unused)
{
       struct btuart_softc *sc = tp->t_sc;
       cfdata_t cfdata;
       int s;

       s = spltty();

       ttylock(tp);
       ttyflush(tp, FREAD | FWRITE);
       ttyunlock(tp);  /* XXX */

       ttyldisc_release(tp->t_linesw);
       tp->t_linesw = ttyldisc_default();

       if (sc != NULL) {
               tp->t_sc = NULL;
               if (sc->sc_tp == tp) {
                       cfdata = device_cfdata(sc->sc_dev);
                       config_detach(sc->sc_dev, 0);
                       free(cfdata, M_DEVBUF);
               }
       }

       splx(s);

       return 0;
}

static int
btuartioctl(struct tty *tp, u_long cmd, void *data __unused,
   int flag __unused, struct lwp *l __unused)
{
       struct btuart_softc *sc = tp->t_sc;
       int error;

       /*
        * XXX
        * This function can be called without KERNEL_LOCK when caller's
        * struct cdevsw is set D_MPSAFE. Is KERNEL_LOCK required?
        */

       if (sc == NULL || tp != sc->sc_tp)
               return EPASSTHROUGH;

       switch(cmd) {
       default:
               error = EPASSTHROUGH;
               break;
       }

       return error;
}

static int
btuartinput(int c, struct tty *tp)
{
       struct btuart_softc *sc = tp->t_sc;
       struct mbuf *m = sc->sc_rxp;
       int space = 0;

       if (!sc->sc_enabled)
               return 0;

       c &= TTY_CHARMASK;

       /* If we already started a packet, find the trailing end of it. */
       if (m) {
               while (m->m_next)
                       m = m->m_next;

               space = M_TRAILINGSPACE(m);
       }

       if (space == 0) {
               if (m == NULL) {
                       /* new packet */
                       MGETHDR(m, M_DONTWAIT, MT_DATA);
                       if (m == NULL) {
                               aprint_error_dev(sc->sc_dev, "out of memory\n");
                               sc->sc_stats.err_rx++;
                               return 0;       /* (lost sync) */
                       }

                       sc->sc_rxp = m;
                       m->m_pkthdr.len = m->m_len = 0;
                       space = MHLEN;

                       sc->sc_state = BTUART_RECV_PKT_TYPE;
                       sc->sc_want = 1;
               } else {
                       /* extend mbuf */
                       MGET(m->m_next, M_DONTWAIT, MT_DATA);
                       if (m->m_next == NULL) {
                               aprint_error_dev(sc->sc_dev, "out of memory\n");
                               sc->sc_stats.err_rx++;
                               return 0;       /* (lost sync) */
                       }

                       m = m->m_next;
                       m->m_len = 0;
                       space = MLEN;

                       if (sc->sc_want > MINCLSIZE) {
                               MCLGET(m, M_DONTWAIT);
                               if (m->m_flags & M_EXT)
                                       space = MCLBYTES;
                       }
               }
       }

       mtod(m, uint8_t *)[m->m_len++] = c;
       sc->sc_rxp->m_pkthdr.len++;
       sc->sc_stats.byte_rx++;

       sc->sc_want--;
       if (sc->sc_want > 0)
               return 0;       /* want more */

       switch (sc->sc_state) {
       case BTUART_RECV_PKT_TYPE:      /* Got packet type */

               switch (c) {
               case HCI_ACL_DATA_PKT:
                       sc->sc_state = BTUART_RECV_ACL_HDR;
                       sc->sc_want = sizeof(hci_acldata_hdr_t) - 1;
                       break;

               case HCI_SCO_DATA_PKT:
                       sc->sc_state = BTUART_RECV_SCO_HDR;
                       sc->sc_want = sizeof(hci_scodata_hdr_t) - 1;
                       break;

               case HCI_EVENT_PKT:
                       sc->sc_state = BTUART_RECV_EVENT_HDR;
                       sc->sc_want = sizeof(hci_event_hdr_t) - 1;
                       break;

               default:
                       aprint_error_dev(sc->sc_dev,
                           "Unknown packet type=%#x!\n", c);
                       sc->sc_stats.err_rx++;
                       m_freem(sc->sc_rxp);
                       sc->sc_rxp = NULL;
                       return 0;       /* (lost sync) */
               }

               break;

       /*
        * we assume (correctly of course :) that the packet headers all fit
        * into a single pkthdr mbuf
        */
       case BTUART_RECV_ACL_HDR:       /* Got ACL Header */
               sc->sc_state = BTUART_RECV_ACL_DATA;
               sc->sc_want = mtod(m, hci_acldata_hdr_t *)->length;
               sc->sc_want = le16toh(sc->sc_want);
               break;

       case BTUART_RECV_SCO_HDR:       /* Got SCO Header */
               sc->sc_state = BTUART_RECV_SCO_DATA;
               sc->sc_want =  mtod(m, hci_scodata_hdr_t *)->length;
               break;

       case BTUART_RECV_EVENT_HDR:     /* Got Event Header */
               sc->sc_state = BTUART_RECV_EVENT_DATA;
               sc->sc_want =  mtod(m, hci_event_hdr_t *)->length;
               break;

       case BTUART_RECV_ACL_DATA:      /* ACL Packet Complete */
               if (!hci_input_acl(sc->sc_unit, sc->sc_rxp))
                       sc->sc_stats.err_rx++;

               sc->sc_stats.acl_rx++;
               sc->sc_rxp = m = NULL;
               break;

       case BTUART_RECV_SCO_DATA:      /* SCO Packet Complete */
               if (!hci_input_sco(sc->sc_unit, sc->sc_rxp))
                       sc->sc_stats.err_rx++;

               sc->sc_stats.sco_rx++;
               sc->sc_rxp = m = NULL;
               break;

       case BTUART_RECV_EVENT_DATA:    /* Event Packet Complete */
               if (!hci_input_event(sc->sc_unit, sc->sc_rxp))
                       sc->sc_stats.err_rx++;

               sc->sc_stats.evt_rx++;
               sc->sc_rxp = m = NULL;
               break;

       default:
               panic("%s: invalid state %d!\n",
                   device_xname(sc->sc_dev), sc->sc_state);
       }

       return 0;
}

static int
btuartstart(struct tty *tp)
{
       struct btuart_softc *sc = tp->t_sc;
       struct mbuf *m;
       int count, rlen;
       uint8_t *rptr;

       if (!sc->sc_enabled)
               return 0;

       m = sc->sc_txp;
       if (m == NULL) {
               if (MBUFQ_FIRST(&sc->sc_cmdq)) {
                       MBUFQ_DEQUEUE(&sc->sc_cmdq, m);
                       sc->sc_stats.cmd_tx++;
               } else if (MBUFQ_FIRST(&sc->sc_scoq)) {
                       MBUFQ_DEQUEUE(&sc->sc_scoq, m);
                       sc->sc_stats.sco_tx++;
               } else if (MBUFQ_FIRST(&sc->sc_aclq)) {
                       MBUFQ_DEQUEUE(&sc->sc_aclq, m);
                       sc->sc_stats.acl_tx++;
               } else {
                       sc->sc_xmit = false;
                       return 0; /* no more to send */
               }

               sc->sc_txp = m;
               sc->sc_xmit = true;
       }

       count = 0;
       rlen = 0;
       rptr = mtod(m, uint8_t *);

       for(;;) {
               if (rlen >= m->m_len) {
                       m = m->m_next;
                       if (m == NULL) {
                               m = sc->sc_txp;
                               sc->sc_txp = NULL;

                               if (M_GETCTX(m, void *) == NULL)
                                       m_freem(m);
                               else if (!hci_complete_sco(sc->sc_unit, m))
                                       sc->sc_stats.err_tx++;

                               break;
                       }

                       rlen = 0;
                       rptr = mtod(m, uint8_t *);
                       continue;
               }

               if (putc(*rptr++, &tp->t_outq) < 0) {
                       m_adj(m, rlen);
                       break;
               }
               rlen++;
               count++;
       }

       sc->sc_stats.byte_tx += count;

       if (tp->t_outq.c_cc != 0 && tp->t_oproc != NULL)
               (*tp->t_oproc)(tp);

       return 0;
}

/*****************************************************************************
*
*      bluetooth(9) functions
*/

static int
btuart_enable(device_t self)
{
       struct btuart_softc *sc = device_private(self);
       int s;

       if (sc->sc_enabled)
               return 0;

       s = spltty();

       sc->sc_enabled = true;
       sc->sc_xmit = false;

       splx(s);

       return 0;
}

static void
btuart_disable(device_t self)
{
       struct btuart_softc *sc = device_private(self);
       int s;

       if (!sc->sc_enabled)
               return;

       s = spltty();

       m_freem(sc->sc_rxp);
       sc->sc_rxp = NULL;

       m_freem(sc->sc_txp);
       sc->sc_txp = NULL;

       MBUFQ_DRAIN(&sc->sc_cmdq);
       MBUFQ_DRAIN(&sc->sc_aclq);
       MBUFQ_DRAIN(&sc->sc_scoq);

       sc->sc_enabled = false;

       splx(s);
}

static void
btuart_output_cmd(device_t self, struct mbuf *m)
{
       struct btuart_softc *sc = device_private(self);
       int s;

       KASSERT(sc->sc_enabled);

       M_SETCTX(m, NULL);

       s = spltty();
       MBUFQ_ENQUEUE(&sc->sc_cmdq, m);
       if (!sc->sc_xmit)
               btuartstart(sc->sc_tp);

       splx(s);
}

static void
btuart_output_acl(device_t self, struct mbuf *m)
{
       struct btuart_softc *sc = device_private(self);
       int s;

       KASSERT(sc->sc_enabled);

       M_SETCTX(m, NULL);

       s = spltty();
       MBUFQ_ENQUEUE(&sc->sc_aclq, m);
       if (!sc->sc_xmit)
               btuartstart(sc->sc_tp);

       splx(s);
}

static void
btuart_output_sco(device_t self, struct mbuf *m)
{
       struct btuart_softc *sc = device_private(self);
       int s;

       KASSERT(sc->sc_enabled);

       s = spltty();
       MBUFQ_ENQUEUE(&sc->sc_scoq, m);
       if (!sc->sc_xmit)
               btuartstart(sc->sc_tp);

       splx(s);
}

static void
btuart_stats(device_t self, struct bt_stats *dest, int flush)
{
       struct btuart_softc *sc = device_private(self);
       int s;

       s = spltty();

       memcpy(dest, &sc->sc_stats, sizeof(struct bt_stats));

       if (flush)
               memset(&sc->sc_stats, 0, sizeof(struct bt_stats));

       splx(s);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.