sys/netbt/bt_proto.c

   1 /* $DragonFly: src/sys/netbt/bt_proto.c,v 1.7 2008/11/01 04:22:15 sephe Exp $ */
   2 /* $OpenBSD: bt_proto.c,v 1.4 2007/06/24 20:55:27 uwe Exp $ */
   3
   4 /*
   5  * Copyright (c) 2004 Alexander Yurchenko <grange@openbsd.org>
   6  *
   7  * Permission to use, copy, modify, and distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 #include <sys/param.h>
  21 #include <sys/domain.h>
  22 #include <sys/protosw.h>
  23 #include <sys/socket.h>
  24 #include <sys/socketvar.h>
  25 #include <sys/queue.h>
  26 #include <sys/kernel.h>
  27 #include <sys/mbuf.h>
  28 #include <sys/sysctl.h>
  29 #include <sys/bus.h>
  30 #include <sys/malloc.h>
  31 #include <net/if.h>
  32 #include <net/pf/pfvar.h>
  33
  34 #include <netbt/bluetooth.h>
  35 #include <netbt/hci.h>
  36 #include <netbt/l2cap.h>
  37 #include <netbt/rfcomm.h>
  38 #include <netbt/sco.h>
  39
  40 MALLOC_DEFINE(M_BLUETOOTH, "Bluetooth", "Bluetooth system memory");
  41
  42 extern struct pr_usrreqs hci_usrreqs;
  43
  44 static int
  45 netbt_modevent(module_t mod, int type, void *data)
  46 {
  47         switch (type) {
  48         case MOD_LOAD:
  49                 break;
  50         case MOD_UNLOAD:
  51                 return EBUSY;
  52                 break;
  53         default:
  54                 break;
  55         }
  56         return 0;
  57 }
  58
  59 static moduledata_t netbt_mod = {
  60         "netbt",
  61         netbt_modevent,
  62         NULL
  63 };
  64
  65 DECLARE_MODULE(netbt, netbt_mod, SI_SUB_EXEC, SI_ORDER_ANY);
  66
  67 struct domain btdomain;
  68
  69 struct protosw btsw[] = {
  70         { /* raw HCI commands */
  71                 .pr_type = SOCK_RAW,
  72                 .pr_domain = &btdomain,
  73                 .pr_protocol = BTPROTO_HCI,
  74                 .pr_flags = (PR_ADDR | PR_ATOMIC),
  75                 .pr_input = 0,
  76                 .pr_output = 0,
  77                 .pr_ctlinput = 0,
  78                 .pr_ctloutput = hci_ctloutput,
  79                 .pr_mport = cpu0_soport,
  80                 .pr_ctlport = NULL,
  81                 .pr_init = 0,
  82                 .pr_fasttimo =  0,
  83                 .pr_slowtimo = 0,
  84                 .pr_drain = 0,
  85                 .pr_usrreqs = &hci_usrreqs
  86         },
  87         { /* HCI SCO data (audio) */
  88                 .pr_type = SOCK_SEQPACKET,
  89                 .pr_domain = &btdomain,
  90                 .pr_protocol = BTPROTO_SCO,
  91                 .pr_flags = (PR_CONNREQUIRED | PR_ATOMIC ),
  92                 .pr_input = 0,
  93                 .pr_output = 0,
  94                 .pr_ctlinput = 0,
  95                 .pr_ctloutput = sco_ctloutput,
  96                 .pr_mport = cpu0_soport,
  97                 .pr_ctlport = NULL,
  98                 .pr_init = 0,
  99                 .pr_fasttimo =  0,
 100                 .pr_slowtimo = 0,
 101                 .pr_drain = 0,
 102                 .pr_usrreqs = &sco_usrreqs
 103
 104         },
 105         { /* L2CAP Connection Oriented */
 106                 .pr_type = SOCK_SEQPACKET,
 107                 .pr_domain = &btdomain,
 108                 .pr_protocol = BTPROTO_L2CAP,
 109                 .pr_flags = (PR_CONNREQUIRED | PR_ATOMIC ),
 110                 .pr_input = 0,
 111                 .pr_output = 0,
 112                 .pr_ctlinput = 0,
 113                 .pr_ctloutput = l2cap_ctloutput,
 114                 .pr_mport = cpu0_soport,
 115                 .pr_ctlport = NULL,
 116                 .pr_init = 0,
 117                 .pr_fasttimo =  0,
 118                 .pr_slowtimo = 0,
 119                 .pr_drain = 0,
 120                 .pr_usrreqs = &l2cap_usrreqs
 121         },
 122         { /* RFCOMM */
 123                 .pr_type = SOCK_STREAM,
 124                 .pr_domain = &btdomain,
 125                 .pr_protocol = BTPROTO_RFCOMM,
 126                 .pr_flags = (PR_CONNREQUIRED | PR_WANTRCVD),
 127                 .pr_input = 0,
 128                 .pr_output = 0,
 129                 .pr_ctlinput = 0,
 130                 .pr_ctloutput = rfcomm_ctloutput,
 131                 .pr_mport = cpu0_soport,
 132                 .pr_ctlport = NULL,
 133                 .pr_init = 0,
 134                 .pr_fasttimo =  0,
 135                 .pr_slowtimo = 0,
 136                 .pr_drain = 0,
 137                 .pr_usrreqs = &rfcomm_usrreqs
 138         },
 139 };
 140
 141 static void
 142 netbt_dispose(struct mbuf* m)
 143 {
 144         ZONE_DESTROY(l2cap_pdu_pool);
 145         ZONE_DESTROY(l2cap_req_pool);
 146         ZONE_DESTROY(rfcomm_credit_pool);
 147 }
 148
 149 static void
 150 netbt_init(void)
 151 {
 152         int error = 1;
 153         do {
 154                 ZONE_CREATE(l2cap_pdu_pool, struct l2cap_pdu, "l2cap_pdu");
 155                 ZONE_CREATE(l2cap_req_pool, struct l2cap_req, "l2cap_req");
 156                 ZONE_CREATE(rfcomm_credit_pool, struct rfcomm_credit,
 157                     "rfcomm_credit");
 158                 error = 0;
 159         } while(0);
 160
 161         if (error) {
 162                 netbt_dispose(NULL);
 163                 panic("Can't create vm_zones");
 164         }
 165 }
 166
 167 struct domain btdomain = {
 168         .dom_family = AF_BLUETOOTH,
 169         .dom_name = "bluetooth",
 170         .dom_init = netbt_init,
 171         .dom_externalize = NULL,
 172         .dom_dispose = netbt_dispose,
 173         .dom_protosw = btsw,
 174         .dom_protoswNPROTOSW = &btsw[sizeof(btsw)/sizeof(btsw[0])],
 175         .dom_next = SLIST_ENTRY_INITIALIZER,
 176         .dom_rtattach = 0,
 177         .dom_rtoffset = 32,
 178         .dom_maxrtkey = sizeof(struct sockaddr_bt),
 179         .dom_ifattach = 0,
 180         .dom_ifdetach = 0,
 181 };
 182
 183 DOMAIN_SET(bt);
 184 SYSCTL_NODE(_net, OID_AUTO, bluetooth, CTLFLAG_RD, 0,
 185     "Bluetooth Protocol Family");
 186
 187 /* HCI sysctls */
 188 SYSCTL_NODE(_net_bluetooth, OID_AUTO, hci, CTLFLAG_RD, 0,
 189     "Host Controller Interface");
 190 SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, sendspace, CTLFLAG_RW, &hci_sendspace,
 191     0, "Socket Send Buffer Size");
 192 SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, recvspace, CTLFLAG_RW, &hci_recvspace,
 193     0, "Socket Receive Buffer Size");
 194 SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, acl_expiry, CTLFLAG_RW,
 195     &hci_acl_expiry, 0, "ACL Connection Expiry Time");
 196 SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, memo_expiry, CTLFLAG_RW,
 197     &hci_memo_expiry, 0, "Memo Expiry Time");
 198 SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, eventq_max, CTLFLAG_RW,
 199     &hci_eventq_max, 0, "Max Event queue length");
 200 SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, aclrxq_max, CTLFLAG_RW,
 201     &hci_aclrxq_max, 0, "Max ACL rx queue length");
 202 SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, scorxq_max, CTLFLAG_RW,
 203     &hci_scorxq_max, 0, "Max SCO rx queue length");
 204
 205 /* L2CAP sysctls */
 206 SYSCTL_NODE(_net_bluetooth, OID_AUTO, l2cap, CTLFLAG_RD, 0,
 207     "Logical Link Control & Adaptation Protocol");
 208 SYSCTL_INT(_net_bluetooth_l2cap, OID_AUTO, sendspace, CTLFLAG_RW,
 209     &l2cap_sendspace, 0, "Socket Send Buffer Size");
 210 SYSCTL_INT(_net_bluetooth_l2cap, OID_AUTO, recvspace, CTLFLAG_RW,
 211     &l2cap_recvspace, 0, "Socket Receive Buffer Size");
 212 SYSCTL_INT(_net_bluetooth_l2cap, OID_AUTO, rtx, CTLFLAG_RW,
 213     &l2cap_response_timeout, 0, "Response Timeout");
 214 SYSCTL_INT(_net_bluetooth_l2cap, OID_AUTO, ertx, CTLFLAG_RW,
 215     &l2cap_response_extended_timeout, 0, "Extended Response Timeout");
 216
 217 /* RFCOMM sysctls */
 218 SYSCTL_NODE(_net_bluetooth, OID_AUTO, rfcomm, CTLFLAG_RD, 0,
 219     "Serial Cable Emulation");
 220 SYSCTL_INT(_net_bluetooth_rfcomm, OID_AUTO, sendspace, CTLFLAG_RW,
 221     &rfcomm_sendspace, 0, "Socket Send Buffer Size");
 222 SYSCTL_INT(_net_bluetooth_rfcomm, OID_AUTO, recvspace, CTLFLAG_RW,
 223     &rfcomm_recvspace, 0, "Socket Receive Buffer Size");
 224 SYSCTL_INT(_net_bluetooth_rfcomm, OID_AUTO, mtu_default, CTLFLAG_RW,
 225     &rfcomm_mtu_default, 0, "Default MTU");
 226 SYSCTL_INT(_net_bluetooth_rfcomm, OID_AUTO, ack_timeout, CTLFLAG_RW,
 227     &rfcomm_ack_timeout, 0, "Acknowledgement Timer");
 228 SYSCTL_INT(_net_bluetooth_rfcomm, OID_AUTO, mcc_timeout, CTLFLAG_RW,
 229     &rfcomm_mcc_timeout, 0, "Response Timeout for Multiplexer Control Channel");
 230
 231 /* SCO sysctls */
 232 SYSCTL_NODE(_net_bluetooth, OID_AUTO, sco, CTLFLAG_RD, 0, "SCO data");
 233 SYSCTL_INT(_net_bluetooth_sco, OID_AUTO, sendspace, CTLFLAG_RW, &sco_sendspace,
 234     0, "Socket Send Buffer Size");
 235 SYSCTL_INT(_net_bluetooth_sco, OID_AUTO, recvspace, CTLFLAG_RW, &sco_recvspace,
 236     0, "Socket Receive Buffer Size");
 237
 238 static void
 239 netisr_netbt_setup(void *dummy __unused)
 240 {
 241         netisr_register(NETISR_BLUETOOTH, cpu0_portfn, btintr,
 242                         NETISR_FLAG_NOTMPSAFE);
 243 }
 244
 245 SYSINIT(netbt_setup, SI_BOOT2_KLD, SI_ORDER_ANY, netisr_netbt_setup, NULL);