/* $NetBSD: btsco.c,v 1.43 2024/07/05 04:31:50 rin Exp $ */
/*-
* Copyright (c) 2006 Itronix Inc.
* All rights reserved.
*
* Written by Iain Hibbert for Itronix Inc.
*
* 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.
* 3. The name of Itronix Inc. may not be used to endorse
* or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``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 ITRONIX INC. 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: btsco.c,v 1.43 2024/07/05 04:31:50 rin Exp $");
#include <sys/param.h>
#include <sys/audioio.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/kernel.h>
#include <sys/queue.h>
#include <sys/kmem.h>
#include <sys/mbuf.h>
#include <sys/proc.h>
#include <sys/socketvar.h>
#include <sys/systm.h>
#include <sys/intr.h>
#include <prop/proplib.h>
#include <netbt/bluetooth.h>
#include <netbt/rfcomm.h>
#include <netbt/sco.h>
#include <dev/audio/audio_if.h>
#include <dev/bluetooth/btdev.h>
#include <dev/bluetooth/btsco.h>
#undef DPRINTF
#undef DPRINTFN
#ifdef BTSCO_DEBUG
int btsco_debug = BTSCO_DEBUG;
#define DPRINTF(...) do { \
if (btsco_debug) { \
printf("%s: ", __func__); \
printf(__VA_ARGS__); \
} \
} while (/* CONSTCOND */0)
#define DPRINTFN(n, ...) do { \
if (btsco_debug > (n)) { \
printf("%s: ", __func__); \
printf(__VA_ARGS__); \
} \
} while (/* CONSTCOND */0)
#else
#define DPRINTF(...)
#define DPRINTFN(...)
#endif
/*****************************************************************************
*
* Bluetooth SCO Audio device
*/
/* btsco softc */
struct btsco_softc {
uint16_t sc_flags;
const char *sc_name; /* our device_xname */
device_t sc_audio; /* MI audio device */
void *sc_intr; /* interrupt cookie */
kcondvar_t sc_connect; /* connect wait */
kmutex_t sc_lock; /* for audio */
/* Bluetooth */
bdaddr_t sc_laddr; /* local address */
bdaddr_t sc_raddr; /* remote address */
uint16_t sc_state; /* link state */
struct sco_pcb *sc_sco; /* SCO handle */
struct sco_pcb *sc_sco_l; /* SCO listen handle */
uint16_t sc_mtu; /* SCO mtu */
uint8_t sc_channel; /* RFCOMM channel */
int sc_err; /* stored error */
/* Receive */
int sc_rx_want; /* bytes wanted */
uint8_t *sc_rx_block; /* receive block */
void (*sc_rx_intr)(void *); /* callback */
void *sc_rx_intrarg; /* callback arg */
struct mbuf *sc_rx_mbuf; /* leftover mbuf */
/* Transmit */
int sc_tx_size; /* bytes to send */
int sc_tx_pending; /* packets pending */
uint8_t *sc_tx_block; /* transmit block */
void (*sc_tx_intr)(void *); /* callback */
void *sc_tx_intrarg; /* callback arg */
void *sc_tx_buf; /* transmit buffer */
int sc_tx_refcnt; /* buffer refcnt */
/* mixer data */
int sc_vgs; /* speaker volume */
int sc_vgm; /* mic volume */
};
/* sc_state */
#define BTSCO_CLOSED 0
#define BTSCO_WAIT_CONNECT 1
#define BTSCO_OPEN 2
/* sc_flags */
#define BTSCO_LISTEN (1 << 1)
/* autoconf(9) glue */
static int btsco_match(device_t, cfdata_t, void *);
static void btsco_attach(device_t, device_t, void *);
static int btsco_detach(device_t, int);
CFATTACH_DECL_NEW(btsco, sizeof(struct btsco_softc),
btsco_match, btsco_attach, btsco_detach, NULL);
/* audio(9) glue */
static int btsco_open(void *, int);
static void btsco_close(void *);
static int btsco_query_format(void *, audio_format_query_t *);
static int btsco_set_format(void *, int,
const audio_params_t *, const audio_params_t *,
audio_filter_reg_t *, audio_filter_reg_t *);
static int btsco_round_blocksize(void *, int, int, const audio_params_t *);
static int btsco_start_output(void *, void *, int, void (*)(void *), void *);
static int btsco_start_input(void *, void *, int, void (*)(void *), void *);
static int btsco_halt_output(void *);
static int btsco_halt_input(void *);
static int btsco_getdev(void *, struct audio_device *);
static int btsco_set_port(void *, mixer_ctrl_t *);
static int btsco_get_port(void *, mixer_ctrl_t *);
static int btsco_query_devinfo(void *, mixer_devinfo_t *);
static void *btsco_allocm(void *, int, size_t);
static void btsco_freem(void *, void *, size_t);
static int btsco_get_props(void *);
static int btsco_dev_ioctl(void *, u_long, void *, int, struct lwp *);
static void btsco_get_locks(void *, kmutex_t **, kmutex_t **);
static const struct audio_hw_if btsco_if = {
.open = btsco_open,
.close = btsco_close,
.query_format = btsco_query_format,
.set_format = btsco_set_format,
.round_blocksize = btsco_round_blocksize,
.start_output = btsco_start_output,
.start_input = btsco_start_input,
.halt_output = btsco_halt_output,
.halt_input = btsco_halt_input,
.getdev = btsco_getdev,
.set_port = btsco_set_port,
.get_port = btsco_get_port,
.query_devinfo = btsco_query_devinfo,
.allocm = btsco_allocm,
.freem = btsco_freem,
.get_props = btsco_get_props,
.dev_ioctl = btsco_dev_ioctl,
.get_locks = btsco_get_locks,
};
static const struct audio_device btsco_device = {
"Bluetooth Audio",
"",
"btsco"
};
/* Voice_Setting == 0x0060: 8000Hz, mono, 16-bit, slinear_le */
static const struct audio_format btsco_format = {
.mode = AUMODE_PLAY | AUMODE_RECORD,
.encoding = AUDIO_ENCODING_SLINEAR_LE,
.validbits = 16,
.precision = 16,
.channels = 1,
.channel_mask = AUFMT_MONAURAL,
.frequency_type = 1,
.frequency = { 8000 },
};
/* bluetooth(9) glue for SCO */
static void btsco_sco_connecting(void *);
static void btsco_sco_connected(void *);
static void btsco_sco_disconnected(void *, int);
static void *btsco_sco_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *);
static void btsco_sco_complete(void *, int);
static void btsco_sco_linkmode(void *, int);
static void btsco_sco_input(void *, struct mbuf *);
static const struct btproto btsco_sco_proto = {
btsco_sco_connecting,
btsco_sco_connected,
btsco_sco_disconnected,
btsco_sco_newconn,
btsco_sco_complete,
btsco_sco_linkmode,
btsco_sco_input,
};
/*****************************************************************************
*
* btsco definitions
*/
/*
* btsco mixer class
*/
#define BTSCO_VGS 0
#define BTSCO_VGM 1
#define BTSCO_INPUT_CLASS 2
#define BTSCO_OUTPUT_CLASS 3
/* connect timeout */
#define BTSCO_TIMEOUT (30 * hz)
/* misc btsco functions */
static void btsco_extfree(struct mbuf *, void *, size_t, void *);
static void btsco_intr(void *);
/*****************************************************************************
*
* btsco autoconf(9) routines
*/
static int
btsco_match(device_t self, cfdata_t cfdata, void *aux)
{
prop_dictionary_t dict = aux;
prop_object_t obj;
obj = prop_dictionary_get(dict, BTDEVservice);
if (prop_string_equals_string(obj, "HSET"))
return 1;
if (prop_string_equals_string(obj, "HF"))
return 1;
return 0;
}
static void
btsco_attach(device_t parent, device_t self, void *aux)
{
struct btsco_softc *sc = device_private(self);
prop_dictionary_t dict = aux;
prop_object_t obj;
/*
* Init softc
*/
sc->sc_vgs = 200;
sc->sc_vgm = 200;
sc->sc_state = BTSCO_CLOSED;
sc->sc_name = device_xname(self);
cv_init(&sc->sc_connect, "connect");
mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
/*
* copy in our configuration info
*/
obj = prop_dictionary_get(dict, BTDEVladdr);
bdaddr_copy(&sc->sc_laddr, prop_data_value(obj));
obj = prop_dictionary_get(dict, BTDEVraddr);
bdaddr_copy(&sc->sc_raddr, prop_data_value(obj));
obj = prop_dictionary_get(dict, BTDEVservice);
if (prop_string_equals_string(obj, "HF")) {
sc->sc_flags |= BTSCO_LISTEN;
aprint_verbose(" listen mode");
}
obj = prop_dictionary_get(dict, BTSCOchannel);
if (prop_object_type(obj) != PROP_TYPE_NUMBER
|| prop_number_signed_value(obj) < RFCOMM_CHANNEL_MIN
|| prop_number_signed_value(obj) > RFCOMM_CHANNEL_MAX) {
aprint_error(" invalid %s", BTSCOchannel);
return;
}
sc->sc_channel = prop_number_signed_value(obj);
aprint_verbose(" channel %d", sc->sc_channel);
aprint_normal("\n");
DPRINTF("sc=%p\n", sc);
/*
* set up transmit interrupt
*/
sc->sc_intr = softint_establish(SOFTINT_NET, btsco_intr, sc);
if (sc->sc_intr == NULL) {
aprint_error_dev(self, "softint_establish failed\n");
return;
}
/*
* attach audio device
*/
sc->sc_audio = audio_attach_mi(&btsco_if, sc, self);
if (sc->sc_audio == NULL) {
aprint_error_dev(self, "audio_attach_mi failed\n");
return;
}
pmf_device_register(self, NULL, NULL);
}
static int
btsco_detach(device_t self, int flags)
{
struct btsco_softc *sc = device_private(self);
DPRINTF("sc=%p\n", sc);
pmf_device_deregister(self);
mutex_enter(bt_lock);
if (sc->sc_sco != NULL) {
DPRINTF("sc_sco=%p\n", sc->sc_sco);
sco_disconnect_pcb(sc->sc_sco, 0);
sco_detach_pcb(&sc->sc_sco);
sc->sc_sco = NULL;
}
if (sc->sc_sco_l != NULL) {
DPRINTF("sc_sco_l=%p\n", sc->sc_sco_l);
sco_detach_pcb(&sc->sc_sco_l);
sc->sc_sco_l = NULL;
}
mutex_exit(bt_lock);
if (sc->sc_audio != NULL) {
DPRINTF("sc_audio=%p\n", sc->sc_audio);
config_detach(sc->sc_audio, flags);
sc->sc_audio = NULL;
}
if (sc->sc_intr != NULL) {
softint_disestablish(sc->sc_intr);
sc->sc_intr = NULL;
}
mutex_enter(bt_lock);
m_freem(sc->sc_rx_mbuf);
sc->sc_rx_mbuf = NULL;
mutex_exit(bt_lock);
if (sc->sc_tx_refcnt > 0) {
aprint_error_dev(self, "tx_refcnt=%d!\n", sc->sc_tx_refcnt);
if ((flags & DETACH_FORCE) == 0)
return EAGAIN;
}
cv_destroy(&sc->sc_connect);
mutex_destroy(&sc->sc_lock);
return 0;
}
/*****************************************************************************
*
* bluetooth(9) methods for SCO
*
* All these are called from Bluetooth Protocol code, in a soft
* interrupt context at IPL_SOFTNET.
*/
static void
btsco_sco_connecting(void *arg)
{
/* struct btsco_softc *sc = arg; */
/* dont care */
}
static void
btsco_sco_connected(void *arg)
{
struct btsco_softc *sc = arg;
DPRINTF("%s\n", sc->sc_name);
KASSERT(sc->sc_sco != NULL);
KASSERT(sc->sc_state == BTSCO_WAIT_CONNECT);
/*
* If we are listening, no more need
*/
if (sc->sc_sco_l != NULL)
sco_detach_pcb(&sc->sc_sco_l);
sc->sc_state = BTSCO_OPEN;
cv_broadcast(&sc->sc_connect);
}
static void
btsco_sco_disconnected(void *arg, int err)
{
struct btsco_softc *sc = arg;
DPRINTF("%s sc_state %d\n", sc->sc_name, sc->sc_state);
KASSERT(sc->sc_sco != NULL);
sc->sc_err = err;
sco_detach_pcb(&sc->sc_sco);
switch (sc->sc_state) {
case BTSCO_CLOSED: /* dont think this can happen */
break;
case BTSCO_WAIT_CONNECT: /* connect failed */
cv_broadcast(&sc->sc_connect);
break;
case BTSCO_OPEN: /* link lost */
/*
* If IO is in progress, tell the audio driver that it
* has completed so that when it tries to send more, we
* can indicate an error.
*/
mutex_enter(bt_lock);
if (sc->sc_tx_pending > 0) {
sc->sc_tx_pending = 0;
(*sc->sc_tx_intr)(sc->sc_tx_intrarg);
}
if (sc->sc_rx_want > 0) {
sc->sc_rx_want = 0;
(*sc->sc_rx_intr)(sc->sc_rx_intrarg);
}
mutex_exit(bt_lock);
break;
default:
UNKNOWN(sc->sc_state);
}
sc->sc_state = BTSCO_CLOSED;
}
static void *
btsco_sco_newconn(void *arg, struct sockaddr_bt *laddr,
struct sockaddr_bt *raddr)
{
struct btsco_softc *sc = arg;
DPRINTF("%s\n", sc->sc_name);
if (bdaddr_same(&raddr->bt_bdaddr, &sc->sc_raddr) == 0
|| sc->sc_state != BTSCO_WAIT_CONNECT
|| sc->sc_sco != NULL)
return NULL;
sco_attach_pcb(&sc->sc_sco, &btsco_sco_proto, sc);
return sc->sc_sco;
}
static void
btsco_sco_complete(void *arg, int count)
{
struct btsco_softc *sc = arg;
DPRINTFN(10, "%s count %d\n", sc->sc_name, count);
if (sc->sc_tx_pending > 0) {
sc->sc_tx_pending -= count;
if (sc->sc_tx_pending == 0)
(*sc->sc_tx_intr)(sc->sc_tx_intrarg);
}
}
static void
btsco_sco_linkmode(void *arg, int new)
{
/* struct btsco_softc *sc = arg; */
/* dont care */
}
static void
btsco_sco_input(void *arg, struct mbuf *m)
{
struct btsco_softc *sc = arg;
int len;
DPRINTFN(10, "%s len=%d\n", sc->sc_name, m->m_pkthdr.len);
if (sc->sc_rx_want == 0) {
m_freem(m);
} else {
KASSERT(sc->sc_rx_intr != NULL);
KASSERT(sc->sc_rx_block != NULL);
len = MIN(sc->sc_rx_want, m->m_pkthdr.len);
m_copydata(m, 0, len, sc->sc_rx_block);
sc->sc_rx_want -= len;
sc->sc_rx_block += len;
if (len > m->m_pkthdr.len) {
m_freem(sc->sc_rx_mbuf);
m_adj(m, len);
sc->sc_rx_mbuf = m;
} else {
m_freem(m);
}
if (sc->sc_rx_want == 0)
(*sc->sc_rx_intr)(sc->sc_rx_intrarg);
}
}
/*****************************************************************************
*
* audio(9) methods
*
*/
static int
btsco_open(void *hdl, int flags)
{
struct sockaddr_bt sa;
struct btsco_softc *sc = hdl;
struct sockopt sopt;
int err, timo;
DPRINTF("%s flags 0x%x\n", sc->sc_name, flags);
/* flags FREAD & FWRITE? */
if (sc->sc_sco != NULL || sc->sc_sco_l != NULL)
return EIO;
KASSERT(mutex_owned(bt_lock));
memset(&sa, 0, sizeof(sa));
sa.bt_len = sizeof(sa);
sa.bt_family = AF_BLUETOOTH;
bdaddr_copy(&sa.bt_bdaddr, &sc->sc_laddr);
if (sc->sc_flags & BTSCO_LISTEN) {
err = sco_attach_pcb(&sc->sc_sco_l, &btsco_sco_proto, sc);
if (err)
goto done;
err = sco_bind_pcb(sc->sc_sco_l, &sa);
if (err) {
sco_detach_pcb(&sc->sc_sco_l);
goto done;
}
err = sco_listen_pcb(sc->sc_sco_l);
if (err) {
sco_detach_pcb(&sc->sc_sco_l);
goto done;
}
timo = 0; /* no timeout */
} else {
err = sco_attach_pcb(&sc->sc_sco, &btsco_sco_proto, sc);
if (err)
goto done;
err = sco_bind_pcb(sc->sc_sco, &sa);
if (err) {
sco_detach_pcb(&sc->sc_sco);
goto done;
}
bdaddr_copy(&sa.bt_bdaddr, &sc->sc_raddr);
err = sco_connect_pcb(sc->sc_sco, &sa);
if (err) {
sco_detach_pcb(&sc->sc_sco);
goto done;
}
timo = BTSCO_TIMEOUT;
}
sc->sc_state = BTSCO_WAIT_CONNECT;
while (err == 0 && sc->sc_state == BTSCO_WAIT_CONNECT)
err = cv_timedwait_sig(&sc->sc_connect, bt_lock, timo);
switch (sc->sc_state) {
case BTSCO_CLOSED: /* disconnected */
err = sc->sc_err;
/* FALLTHROUGH */
case BTSCO_WAIT_CONNECT: /* error */
if (sc->sc_sco != NULL)
sco_detach_pcb(&sc->sc_sco);
if (sc->sc_sco_l != NULL)
sco_detach_pcb(&sc->sc_sco_l);
break;
case BTSCO_OPEN: /* hurrah */
sockopt_init(&sopt, BTPROTO_SCO, SO_SCO_MTU, 0);
(void)sco_getopt(sc->sc_sco, &sopt);
(void)sockopt_get(&sopt, &sc->sc_mtu, sizeof(sc->sc_mtu));
sockopt_destroy(&sopt);
break;
default:
UNKNOWN(sc->sc_state);
break;
}
done:
DPRINTF("done err=%d, sc_state=%d, sc_mtu=%d\n",
err, sc->sc_state, sc->sc_mtu);
return err;
}
static void
btsco_close(void *hdl)
{
struct btsco_softc *sc = hdl;
DPRINTF("%s\n", sc->sc_name);
KASSERT(mutex_owned(bt_lock));
if (sc->sc_sco != NULL) {
sco_disconnect_pcb(sc->sc_sco, 0);
sco_detach_pcb(&sc->sc_sco);
}
if (sc->sc_sco_l != NULL) {
sco_detach_pcb(&sc->sc_sco_l);
}
m_freem(sc->sc_rx_mbuf);
sc->sc_rx_mbuf = NULL;
sc->sc_rx_want = 0;
sc->sc_rx_block = NULL;
sc->sc_rx_intr = NULL;
sc->sc_rx_intrarg = NULL;
sc->sc_tx_size = 0;
sc->sc_tx_block = NULL;
sc->sc_tx_pending = 0;
sc->sc_tx_intr = NULL;
sc->sc_tx_intrarg = NULL;
}
static int
btsco_query_format(void *hdl, audio_format_query_t *afp)
{
return audio_query_format(&btsco_format, 1, afp);
}
static int
btsco_set_format(void *hdl, int setmode,
const audio_params_t *play, const audio_params_t *rec,
audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
/* We have only one format so nothing to do here. */
return 0;
}
/*
* If we have an MTU value to use, round the blocksize to that.
*/
static int
btsco_round_blocksize(void *hdl, int bs, int mode,
const audio_params_t *param)
{
struct btsco_softc *sc = hdl;
if (sc->sc_mtu > 0) {
bs = (bs / sc->sc_mtu) * sc->sc_mtu;
if (bs == 0)
bs = sc->sc_mtu;
}
DPRINTF("%s mode=0x%x, bs=%d, sc_mtu=%d\n",
sc->sc_name, mode, bs, sc->sc_mtu);
return bs;
}
/*
* Start Output
*
* We dont want to be calling the network stack with bt_lock held
* so make a note of what is to be sent, and schedule an interrupt to
* bundle it up and queue it.
*/
static int
btsco_start_output(void *hdl, void *block, int blksize,
void (*intr)(void *), void *intrarg)
{
struct btsco_softc *sc = hdl;
DPRINTFN(5, "%s blksize %d\n", sc->sc_name, blksize);
if (sc->sc_sco == NULL)
return ENOTCONN; /* connection lost */
sc->sc_tx_block = block;
sc->sc_tx_pending = 0;
sc->sc_tx_size = blksize;
sc->sc_tx_intr = intr;
sc->sc_tx_intrarg = intrarg;
kpreempt_disable();
softint_schedule(sc->sc_intr);
kpreempt_enable();
return 0;
}
/*
* Start Input
*
* When the SCO link is up, we are getting data in any case, so all we do
* is note what we want and where to put it and let the sco_input routine
* fill in the data.
*
* If there was any leftover data that didnt fit in the last block, retry
* it now.
*/
static int
btsco_start_input(void *hdl, void *block, int blksize,
void (*intr)(void *), void *intrarg)
{
struct btsco_softc *sc = hdl;
struct mbuf *m;
DPRINTFN(5, "%s blksize %d\n", sc->sc_name, blksize);
if (sc->sc_sco == NULL)
return ENOTCONN;
sc->sc_rx_want = blksize;
sc->sc_rx_block = block;
sc->sc_rx_intr = intr;
sc->sc_rx_intrarg = intrarg;
if (sc->sc_rx_mbuf != NULL) {
m = sc->sc_rx_mbuf;
sc->sc_rx_mbuf = NULL;
btsco_sco_input(sc, m);
}
return 0;
}
/*
* Halt Output
*
* This doesnt really halt the output, but it will look
* that way to the audio driver. The current block will
* still be transmitted.
*/
static int
btsco_halt_output(void *hdl)
{
struct btsco_softc *sc = hdl;
DPRINTFN(5, "%s\n", sc->sc_name);
sc->sc_tx_size = 0;
sc->sc_tx_block = NULL;
sc->sc_tx_pending = 0;
sc->sc_tx_intr = NULL;
sc->sc_tx_intrarg = NULL;
return 0;
}
/*
* Halt Input
*
* This doesnt really halt the input, but it will look
* that way to the audio driver. Incoming data will be
* discarded.
*/
static int
btsco_halt_input(void *hdl)
{
struct btsco_softc *sc = hdl;
DPRINTFN(5, "%s\n", sc->sc_name);
sc->sc_rx_want = 0;
sc->sc_rx_block = NULL;
sc->sc_rx_intr = NULL;
sc->sc_rx_intrarg = NULL;
m_freem(sc->sc_rx_mbuf);
sc->sc_rx_mbuf = NULL;
return 0;
}
static int
btsco_getdev(void *hdl, struct audio_device *ret)
{
*ret = btsco_device;
return 0;
}
static int
btsco_set_port(void *hdl, mixer_ctrl_t *mc)
{
struct btsco_softc *sc = hdl;
int err = 0;
DPRINTF("%s dev %d type %d\n", sc->sc_name, mc->dev, mc->type);
switch (mc->dev) {
case BTSCO_VGS:
if (mc->type != AUDIO_MIXER_VALUE ||
mc->un.value.num_channels != 1) {
err = EINVAL;
break;
}
sc->sc_vgs = mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
break;
case BTSCO_VGM:
if (mc->type != AUDIO_MIXER_VALUE ||
mc->un.value.num_channels != 1) {
err = EINVAL;
break;
}
sc->sc_vgm = mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
break;
default:
err = EINVAL;
break;
}
return err;
}
static int
btsco_get_port(void *hdl, mixer_ctrl_t *mc)
{
struct btsco_softc *sc = hdl;
int err = 0;
DPRINTF("%s dev %d\n", sc->sc_name, mc->dev);
switch (mc->dev) {
case BTSCO_VGS:
mc->type = AUDIO_MIXER_VALUE;
mc->un.value.num_channels = 1;
mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_vgs;
break;
case BTSCO_VGM:
mc->type = AUDIO_MIXER_VALUE;
mc->un.value.num_channels = 1;
mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_vgm;
break;
default:
err = EINVAL;
break;
}
return err;
}
static int
btsco_query_devinfo(void *hdl, mixer_devinfo_t *di)
{
/* struct btsco_softc *sc = hdl; */
int err = 0;
switch(di->index) {
case BTSCO_VGS:
di->mixer_class = BTSCO_INPUT_CLASS;
di->next = di->prev = AUDIO_MIXER_LAST;
strcpy(di->label.name, AudioNspeaker);
di->type = AUDIO_MIXER_VALUE;
strcpy(di->un.v.units.name, AudioNvolume);
di->un.v.num_channels = 1;
di->un.v.delta = BTSCO_DELTA;
break;
case BTSCO_VGM:
di->mixer_class = BTSCO_INPUT_CLASS;
di->next = di->prev = AUDIO_MIXER_LAST;
strcpy(di->label.name, AudioNmicrophone);
di->type = AUDIO_MIXER_VALUE;
strcpy(di->un.v.units.name, AudioNvolume);
di->un.v.num_channels = 1;
di->un.v.delta = BTSCO_DELTA;
break;
case BTSCO_INPUT_CLASS:
di->mixer_class = BTSCO_INPUT_CLASS;
di->next = di->prev = AUDIO_MIXER_LAST;
strcpy(di->label.name, AudioCinputs);
di->type = AUDIO_MIXER_CLASS;
break;
default:
err = ENXIO;
break;
}
return err;
}
/*
* Allocate Ring Buffers.
*/
static void *
btsco_allocm(void *hdl, int direction, size_t size)
{
struct btsco_softc *sc = hdl;
void *addr;
DPRINTF("%s: size %zd direction %d\n", sc->sc_name, size, direction);
addr = kmem_alloc(size, KM_SLEEP);
if (direction == AUMODE_PLAY) {
sc->sc_tx_buf = addr;
sc->sc_tx_refcnt = 0;
}
return addr;
}
/*
* Free Ring Buffers.
*
* Because we used external memory for the tx mbufs, we dont
* want to free the memory until all the mbufs are done with
*
* Just to be sure, dont free if something is still pending.
* This would be a memory leak but at least there is a warning..
*/
static void
btsco_freem(void *hdl, void *addr, size_t size)
{
struct btsco_softc *sc = hdl;
int count = hz / 2;
if (addr == sc->sc_tx_buf) {
DPRINTF("%s: tx_refcnt=%d\n", sc->sc_name, sc->sc_tx_refcnt);
sc->sc_tx_buf = NULL;
while (sc->sc_tx_refcnt> 0 && count-- > 0)
kpause("drain", false, 1, NULL);
if (sc->sc_tx_refcnt > 0) {
aprint_error("%s: ring buffer unreleased!\n", sc->sc_name);
return;
}
}
kmem_free(addr, size);
}
static int
btsco_get_props(void *hdl)
{
return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE |
AUDIO_PROP_FULLDUPLEX;
}
static void
btsco_get_locks(void *hdl, kmutex_t **intr, kmutex_t **thread)
{
struct btsco_softc *sc = hdl;
*thread = &sc->sc_lock;
*intr = bt_lock;
}
/*
* Handle private ioctl. We pass information out about how to talk
* to the device and mixer.
*/
static int
btsco_dev_ioctl(void *hdl, u_long cmd, void *addr, int flag,
struct lwp *l)
{
struct btsco_softc *sc = hdl;
struct btsco_info *bi = (struct btsco_info *)addr;
int err = 0;
DPRINTF("%s cmd 0x%lx flag %d\n", sc->sc_name, cmd, flag);
switch (cmd) {
case BTSCO_GETINFO:
memset(bi, 0, sizeof(*bi));
bdaddr_copy(&bi->laddr, &sc->sc_laddr);
bdaddr_copy(&bi->raddr, &sc->sc_raddr);
bi->channel = sc->sc_channel;
bi->vgs = BTSCO_VGS;
bi->vgm = BTSCO_VGM;
break;
default:
err = EPASSTHROUGH;
break;
}
return err;
}
/*****************************************************************************
*
* misc btsco functions
*
*/
/*
* Our transmit interrupt. This is triggered when a new block is to be
* sent. We send mtu sized chunks of the block as mbufs with external
* storage to sco_send_pcb()
*/
static void
btsco_intr(void *arg)
{
struct btsco_softc *sc = arg;
struct mbuf *m;
uint8_t *block;
int mlen, size;
DPRINTFN(10, "%s block %p size %d\n",
sc->sc_name, sc->sc_tx_block, sc->sc_tx_size);
if (sc->sc_sco == NULL)
return; /* connection is lost */
mutex_enter(bt_lock);
block = sc->sc_tx_block;
size = sc->sc_tx_size;
sc->sc_tx_block = NULL;
sc->sc_tx_size = 0;
while (size > 0) {
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL)
break;
mlen = MIN(sc->sc_mtu, size);
/* I think M_DEVBUF is true but not relevant */
MEXTADD(m, block, mlen, M_DEVBUF, btsco_extfree, sc);
if ((m->m_flags & M_EXT) == 0) {
m_free(m);
break;
}
sc->sc_tx_refcnt++;
m->m_pkthdr.len = m->m_len = mlen;
sc->sc_tx_pending++;
if (sco_send_pcb(sc->sc_sco, m) > 0) {
sc->sc_tx_pending--;
break;
}
block += mlen;
size -= mlen;
}
mutex_exit(bt_lock);
}
/*
* Release the mbuf, we keep a reference count on the tx buffer so
* that we dont release it before its free.
*/
static void
btsco_extfree(struct mbuf *m, void *addr, size_t size,
void *arg)
{
struct btsco_softc *sc = arg;
if (m != NULL)
pool_cache_put(mb_cache, m);
sc->sc_tx_refcnt--;
}
