drivers/bluetooth/hci_h4.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 /*
  26  * Bluetooth HCI UART(H4) protocol.
  27  *
  28  * $Id: hci_h4.c,v 1.3 2002/09/09 01:17:32 maxk Exp $
  29  */
  30 #define VERSION "1.2"
  31
  32 #include <linux/config.h>
  33 #include <linux/module.h>
  34
  35 #include <linux/kernel.h>
  36 #include <linux/init.h>
  37 #include <linux/sched.h>
  38 #include <linux/types.h>
  39 #include <linux/fcntl.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/ptrace.h>
  42 #include <linux/poll.h>
  43
  44 #include <linux/slab.h>
  45 #include <linux/tty.h>
  46 #include <linux/errno.h>
  47 #include <linux/string.h>
  48 #include <linux/signal.h>
  49 #include <linux/ioctl.h>
  50 #include <linux/skbuff.h>
  51
  52 #include <net/bluetooth/bluetooth.h>
  53 #include <net/bluetooth/hci_core.h>
  54 #include "hci_uart.h"
  55 #include "hci_h4.h"
  56
  57 #ifndef CONFIG_BT_HCIUART_DEBUG
  58 #undef  BT_DBG
  59 #define BT_DBG( A... )
  60 #undef  BT_DMP
  61 #define BT_DMP( A... )
  62 #endif
  63
  64 /* Initialize protocol */
  65 static int h4_open(struct hci_uart *hu)
  66 {
  67         struct h4_struct *h4;
  68
  69         BT_DBG("hu %p", hu);
  70
  71         h4 = kmalloc(sizeof(*h4), GFP_ATOMIC);
  72         if (!h4)
  73                 return -ENOMEM;
  74         memset(h4, 0, sizeof(*h4));
  75
  76         skb_queue_head_init(&h4->txq);
  77
  78         hu->priv = h4;
  79         return 0;
  80 }
  81
  82 /* Flush protocol data */
  83 static int h4_flush(struct hci_uart *hu)
  84 {
  85         struct h4_struct *h4 = hu->priv;
  86
  87         BT_DBG("hu %p", hu);
  88         skb_queue_purge(&h4->txq);
  89         return 0;
  90 }
  91
  92 /* Close protocol */
  93 static int h4_close(struct hci_uart *hu)
  94 {
  95         struct h4_struct *h4 = hu->priv;
  96         hu->priv = NULL;
  97
  98         BT_DBG("hu %p", hu);
  99
 100         skb_queue_purge(&h4->txq);
 101         if (h4->rx_skb)
 102                 kfree_skb(h4->rx_skb);
 103
 104         hu->priv = NULL;
 105         kfree(h4);
 106         return 0;
 107 }
 108
 109 /* Enqueue frame for transmittion (padding, crc, etc) */
 110 static int h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
 111 {
 112         struct h4_struct *h4 = hu->priv;
 113
 114         BT_DBG("hu %p skb %p", hu, skb);
 115
 116         /* Prepend skb with frame type */
 117         memcpy(skb_push(skb, 1), &skb->pkt_type, 1);
 118         skb_queue_tail(&h4->txq, skb);
 119         return 0;
 120 }
 121
 122 static inline int h4_check_data_len(struct h4_struct *h4, int len)
 123 {
 124         register int room = skb_tailroom(h4->rx_skb);
 125
 126         BT_DBG("len %d room %d", len, room);
 127         if (!len) {
 128                 BT_DMP(h4->rx_skb->data, h4->rx_skb->len);
 129                 hci_recv_frame(h4->rx_skb);
 130         } else if (len > room) {
 131                 BT_ERR("Data length is too large");
 132                 kfree_skb(h4->rx_skb);
 133         } else {
 134                 h4->rx_state = H4_W4_DATA;
 135                 h4->rx_count = len;
 136                 return len;
 137         }
 138
 139         h4->rx_state = H4_W4_PACKET_TYPE;
 140         h4->rx_skb   = NULL;
 141         h4->rx_count = 0;
 142         return 0;
 143 }
 144
 145 /* Recv data */
 146 static int h4_recv(struct hci_uart *hu, void *data, int count)
 147 {
 148         struct h4_struct *h4 = hu->priv;
 149         register char *ptr;
 150         struct hci_event_hdr *eh;
 151         struct hci_acl_hdr   *ah;
 152         struct hci_sco_hdr   *sh;
 153         register int len, type, dlen;
 154
 155         BT_DBG("hu %p count %d rx_state %ld rx_count %ld",
 156                         hu, count, h4->rx_state, h4->rx_count);
 157
 158         ptr = data;
 159         while (count) {
 160                 if (h4->rx_count) {
 161                         len = min_t(unsigned int, h4->rx_count, count);
 162                         memcpy(skb_put(h4->rx_skb, len), ptr, len);
 163                         h4->rx_count -= len; count -= len; ptr += len;
 164
 165                         if (h4->rx_count)
 166                                 continue;
 167
 168                         switch (h4->rx_state) {
 169                         case H4_W4_DATA:
 170                                 BT_DBG("Complete data");
 171
 172                                 BT_DMP(h4->rx_skb->data, h4->rx_skb->len);
 173
 174                                 hci_recv_frame(h4->rx_skb);
 175
 176                                 h4->rx_state = H4_W4_PACKET_TYPE;
 177                                 h4->rx_skb = NULL;
 178                                 continue;
 179
 180                         case H4_W4_EVENT_HDR:
 181                                 eh = (struct hci_event_hdr *) h4->rx_skb->data;
 182
 183                                 BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
 184
 185                                 h4_check_data_len(h4, eh->plen);
 186                                 continue;
 187
 188                         case H4_W4_ACL_HDR:
 189                                 ah = (struct hci_acl_hdr *) h4->rx_skb->data;
 190                                 dlen = __le16_to_cpu(ah->dlen);
 191
 192                                 BT_DBG("ACL header: dlen %d", dlen);
 193
 194                                 h4_check_data_len(h4, dlen);
 195                                 continue;
 196
 197                         case H4_W4_SCO_HDR:
 198                                 sh = (struct hci_sco_hdr *) h4->rx_skb->data;
 199
 200                                 BT_DBG("SCO header: dlen %d", sh->dlen);
 201
 202                                 h4_check_data_len(h4, sh->dlen);
 203                                 continue;
 204                         }
 205                 }
 206
 207                 /* H4_W4_PACKET_TYPE */
 208                 switch (*ptr) {
 209                 case HCI_EVENT_PKT:
 210                         BT_DBG("Event packet");
 211                         h4->rx_state = H4_W4_EVENT_HDR;
 212                         h4->rx_count = HCI_EVENT_HDR_SIZE;
 213                         type = HCI_EVENT_PKT;
 214                         break;
 215
 216                 case HCI_ACLDATA_PKT:
 217                         BT_DBG("ACL packet");
 218                         h4->rx_state = H4_W4_ACL_HDR;
 219                         h4->rx_count = HCI_ACL_HDR_SIZE;
 220                         type = HCI_ACLDATA_PKT;
 221                         break;
 222
 223                 case HCI_SCODATA_PKT:
 224                         BT_DBG("SCO packet");
 225                         h4->rx_state = H4_W4_SCO_HDR;
 226                         h4->rx_count = HCI_SCO_HDR_SIZE;
 227                         type = HCI_SCODATA_PKT;
 228                         break;
 229
 230                 default:
 231                         BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
 232                         hu->hdev->stat.err_rx++;
 233                         ptr++; count--;
 234                         continue;
 235                 };
 236                 ptr++; count--;
 237
 238                 /* Allocate packet */
 239                 h4->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
 240                 if (!h4->rx_skb) {
 241                         BT_ERR("Can't allocate mem for new packet");
 242                         h4->rx_state = H4_W4_PACKET_TYPE;
 243                         h4->rx_count = 0;
 244                         return 0;
 245                 }
 246                 h4->rx_skb->dev = (void *) hu->hdev;
 247                 h4->rx_skb->pkt_type = type;
 248         }
 249         return count;
 250 }
 251
 252 static struct sk_buff *h4_dequeue(struct hci_uart *hu)
 253 {
 254         struct h4_struct *h4 = hu->priv;
 255         return skb_dequeue(&h4->txq);
 256 }
 257
 258 static struct hci_uart_proto h4p = {
 259         .id      = HCI_UART_H4,
 260         .open    = h4_open,
 261         .close   = h4_close,
 262         .recv    = h4_recv,
 263         .enqueue = h4_enqueue,
 264         .dequeue = h4_dequeue,
 265         .flush   = h4_flush,
 266 };
 267
 268 int h4_init(void)
 269 {
 270         int err = hci_uart_register_proto(&h4p);
 271         if (!err)
 272                 BT_INFO("HCI H4 protocol initialized");
 273         else
 274                 BT_ERR("HCI H4 protocol registration failed");
 275
 276         return err;
 277 }
 278
 279 int h4_deinit(void)
 280 {
 281         return hci_uart_unregister_proto(&h4p);
 282 }