LXR linux/drivers/bluetooth/hci

   1/*
   2 *  Texas Instruments' Bluetooth HCILL UART protocol
   3 *
   4 *  HCILL (HCI Low Level) is a Texas Instruments' power management
   5 *  protocol extension to H4.
   6 *
   7 *  Copyright (C) 2007 Texas Instruments, Inc.
   8 *
   9 *  Written by Ohad Ben-Cohen <ohad@bencohen.org>
  10 *
  11 *  Acknowledgements:
  12 *  This file is based on hci_h4.c, which was written
  13 *  by Maxim Krasnyansky and Marcel Holtmann.
  14 *
  15 *  This program is free software; you can redistribute it and/or modify
  16 *  it under the terms of the GNU General Public License version 2
  17 *  as published by the Free Software Foundation
  18 *
  19 *  This program is distributed in the hope that it will be useful,
  20 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 *  GNU General Public License for more details.
  23 *
  24 *  You should have received a copy of the GNU General Public License
  25 *  along with this program; if not, write to the Free Software
  26 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27 *
  28 */
  29
  30#include <linux/module.h>
  31#include <linux/kernel.h>
  32
  33#include <linux/init.h>
  34#include <linux/sched.h>
  35#include <linux/types.h>
  36#include <linux/fcntl.h>
  37#include <linux/interrupt.h>
  38#include <linux/ptrace.h>
  39#include <linux/poll.h>
  40
  41#include <linux/slab.h>
  42#include <linux/tty.h>
  43#include <linux/errno.h>
  44#include <linux/string.h>
  45#include <linux/signal.h>
  46#include <linux/ioctl.h>
  47#include <linux/skbuff.h>
  48
  49#include <net/bluetooth/bluetooth.h>
  50#include <net/bluetooth/hci_core.h>
  51
  52#include "hci_uart.h"
  53
  54/* HCILL commands */
  55#define HCILL_GO_TO_SLEEP_IND   0x30
  56#define HCILL_GO_TO_SLEEP_ACK   0x31
  57#define HCILL_WAKE_UP_IND       0x32
  58#define HCILL_WAKE_UP_ACK       0x33
  59
  60/* HCILL receiver States */
  61#define HCILL_W4_PACKET_TYPE    0
  62#define HCILL_W4_EVENT_HDR      1
  63#define HCILL_W4_ACL_HDR        2
  64#define HCILL_W4_SCO_HDR        3
  65#define HCILL_W4_DATA           4
  66
  67/* HCILL states */
  68enum hcill_states_e {
  69        HCILL_ASLEEP,
  70        HCILL_ASLEEP_TO_AWAKE,
  71        HCILL_AWAKE,
  72        HCILL_AWAKE_TO_ASLEEP
  73};
  74
  75struct hcill_cmd {
  76        u8 cmd;
  77} __packed;
  78
  79struct ll_struct {
  80        unsigned long rx_state;
  81        unsigned long rx_count;
  82        struct sk_buff *rx_skb;
  83        struct sk_buff_head txq;
  84        spinlock_t hcill_lock;          /* HCILL state lock     */
  85        unsigned long hcill_state;      /* HCILL power state    */
  86        struct sk_buff_head tx_wait_q;  /* HCILL wait queue     */
  87};
  88
  89/*
  90 * Builds and sends an HCILL command packet.
  91 * These are very simple packets with only 1 cmd byte
  92 */
  93static int send_hcill_cmd(u8 cmd, struct hci_uart *hu)
  94{
  95        int err = 0;
  96        struct sk_buff *skb = NULL;
  97        struct ll_struct *ll = hu->priv;
  98        struct hcill_cmd *hcill_packet;
  99
 100        BT_DBG("hu %p cmd 0x%x", hu, cmd);
 101
 102        /* allocate packet */
 103        skb = bt_skb_alloc(1, GFP_ATOMIC);
 104        if (!skb) {
 105                BT_ERR("cannot allocate memory for HCILL packet");
 106                err = -ENOMEM;
 107                goto out;
 108        }
 109
 110        /* prepare packet */
 111        hcill_packet = (struct hcill_cmd *) skb_put(skb, 1);
 112        hcill_packet->cmd = cmd;
 113        skb->dev = (void *) hu->hdev;
 114
 115        /* send packet */
 116        skb_queue_tail(&ll->txq, skb);
 117out:
 118        return err;
 119}
 120
 121/* Initialize protocol */
 122static int ll_open(struct hci_uart *hu)
 123{
 124        struct ll_struct *ll;
 125
 126        BT_DBG("hu %p", hu);
 127
 128        ll = kzalloc(sizeof(*ll), GFP_ATOMIC);
 129        if (!ll)
 130                return -ENOMEM;
 131
 132        skb_queue_head_init(&ll->txq);
 133        skb_queue_head_init(&ll->tx_wait_q);
 134        spin_lock_init(&ll->hcill_lock);
 135
 136        ll->hcill_state = HCILL_AWAKE;
 137
 138        hu->priv = ll;
 139
 140        return 0;
 141}
 142
 143/* Flush protocol data */
 144static int ll_flush(struct hci_uart *hu)
 145{
 146        struct ll_struct *ll = hu->priv;
 147
 148        BT_DBG("hu %p", hu);
 149
 150        skb_queue_purge(&ll->tx_wait_q);
 151        skb_queue_purge(&ll->txq);
 152
 153        return 0;
 154}
 155
 156/* Close protocol */
 157static int ll_close(struct hci_uart *hu)
 158{
 159        struct ll_struct *ll = hu->priv;
 160
 161        BT_DBG("hu %p", hu);
 162
 163        skb_queue_purge(&ll->tx_wait_q);
 164        skb_queue_purge(&ll->txq);
 165
 166        kfree_skb(ll->rx_skb);
 167
 168        hu->priv = NULL;
 169
 170        kfree(ll);
 171
 172        return 0;
 173}
 174
 175/*
 176 * internal function, which does common work of the device wake up process:
 177 * 1. places all pending packets (waiting in tx_wait_q list) in txq list.
 178 * 2. changes internal state to HCILL_AWAKE.
 179 * Note: assumes that hcill_lock spinlock is taken,
 180 * shouldn't be called otherwise!
 181 */
 182static void __ll_do_awake(struct ll_struct *ll)
 183{
 184        struct sk_buff *skb = NULL;
 185
 186        while ((skb = skb_dequeue(&ll->tx_wait_q)))
 187                skb_queue_tail(&ll->txq, skb);
 188
 189        ll->hcill_state = HCILL_AWAKE;
 190}
 191
 192/*
 193 * Called upon a wake-up-indication from the device
 194 */
 195static void ll_device_want_to_wakeup(struct hci_uart *hu)
 196{
 197        unsigned long flags;
 198        struct ll_struct *ll = hu->priv;
 199
 200        BT_DBG("hu %p", hu);
 201
 202        /* lock hcill state */
 203        spin_lock_irqsave(&ll->hcill_lock, flags);
 204
 205        switch (ll->hcill_state) {
 206        case HCILL_ASLEEP_TO_AWAKE:
 207                /*
 208                 * This state means that both the host and the BRF chip
 209                 * have simultaneously sent a wake-up-indication packet.
 210                 * Traditionaly, in this case, receiving a wake-up-indication
 211                 * was enough and an additional wake-up-ack wasn't needed.
 212                 * This has changed with the BRF6350, which does require an
 213                 * explicit wake-up-ack. Other BRF versions, which do not
 214                 * require an explicit ack here, do accept it, thus it is
 215                 * perfectly safe to always send one.
 216                 */
 217                BT_DBG("dual wake-up-indication");
 218                /* deliberate fall-through - do not add break */
 219        case HCILL_ASLEEP:
 220                /* acknowledge device wake up */
 221                if (send_hcill_cmd(HCILL_WAKE_UP_ACK, hu) < 0) {
 222                        BT_ERR("cannot acknowledge device wake up");
 223                        goto out;
 224                }
 225                break;
 226        default:
 227                /* any other state is illegal */
 228                BT_ERR("received HCILL_WAKE_UP_IND in state %ld", ll->hcill_state);
 229                break;
 230        }
 231
 232        /* send pending packets and change state to HCILL_AWAKE */
 233        __ll_do_awake(ll);
 234
 235out:
 236        spin_unlock_irqrestore(&ll->hcill_lock, flags);
 237
 238        /* actually send the packets */
 239        hci_uart_tx_wakeup(hu);
 240}
 241
 242/*
 243 * Called upon a sleep-indication from the device
 244 */
 245static void ll_device_want_to_sleep(struct hci_uart *hu)
 246{
 247        unsigned long flags;
 248        struct ll_struct *ll = hu->priv;
 249
 250        BT_DBG("hu %p", hu);
 251
 252        /* lock hcill state */
 253        spin_lock_irqsave(&ll->hcill_lock, flags);
 254
 255        /* sanity check */
 256        if (ll->hcill_state != HCILL_AWAKE)
 257                BT_ERR("ERR: HCILL_GO_TO_SLEEP_IND in state %ld", ll->hcill_state);
 258
 259        /* acknowledge device sleep */
 260        if (send_hcill_cmd(HCILL_GO_TO_SLEEP_ACK, hu) < 0) {
 261                BT_ERR("cannot acknowledge device sleep");
 262                goto out;
 263        }
 264
 265        /* update state */
 266        ll->hcill_state = HCILL_ASLEEP;
 267
 268out:
 269        spin_unlock_irqrestore(&ll->hcill_lock, flags);
 270
 271        /* actually send the sleep ack packet */
 272        hci_uart_tx_wakeup(hu);
 273}
 274
 275/*
 276 * Called upon wake-up-acknowledgement from the device
 277 */
 278static void ll_device_woke_up(struct hci_uart *hu)
 279{
 280        unsigned long flags;
 281        struct ll_struct *ll = hu->priv;
 282
 283        BT_DBG("hu %p", hu);
 284
 285        /* lock hcill state */
 286        spin_lock_irqsave(&ll->hcill_lock, flags);
 287
 288        /* sanity check */
 289        if (ll->hcill_state != HCILL_ASLEEP_TO_AWAKE)
 290                BT_ERR("received HCILL_WAKE_UP_ACK in state %ld", ll->hcill_state);
 291
 292        /* send pending packets and change state to HCILL_AWAKE */
 293        __ll_do_awake(ll);
 294
 295        spin_unlock_irqrestore(&ll->hcill_lock, flags);
 296
 297        /* actually send the packets */
 298        hci_uart_tx_wakeup(hu);
 299}
 300
 301/* Enqueue frame for transmittion (padding, crc, etc) */
 302/* may be called from two simultaneous tasklets */
 303static int ll_enqueue(struct hci_uart *hu, struct sk_buff *skb)
 304{
 305        unsigned long flags = 0;
 306        struct ll_struct *ll = hu->priv;
 307
 308        BT_DBG("hu %p skb %p", hu, skb);
 309
 310        /* Prepend skb with frame type */
 311        memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 312
 313        /* lock hcill state */
 314        spin_lock_irqsave(&ll->hcill_lock, flags);
 315
 316        /* act according to current state */
 317        switch (ll->hcill_state) {
 318        case HCILL_AWAKE:
 319                BT_DBG("device awake, sending normally");
 320                skb_queue_tail(&ll->txq, skb);
 321                break;
 322        case HCILL_ASLEEP:
 323                BT_DBG("device asleep, waking up and queueing packet");
 324                /* save packet for later */
 325                skb_queue_tail(&ll->tx_wait_q, skb);
 326                /* awake device */
 327                if (send_hcill_cmd(HCILL_WAKE_UP_IND, hu) < 0) {
 328                        BT_ERR("cannot wake up device");
 329                        break;
 330                }
 331                ll->hcill_state = HCILL_ASLEEP_TO_AWAKE;
 332                break;
 333        case HCILL_ASLEEP_TO_AWAKE:
 334                BT_DBG("device waking up, queueing packet");
 335                /* transient state; just keep packet for later */
 336                skb_queue_tail(&ll->tx_wait_q, skb);
 337                break;
 338        default:
 339                BT_ERR("illegal hcill state: %ld (losing packet)", ll->hcill_state);
 340                kfree_skb(skb);
 341                break;
 342        }
 343
 344        spin_unlock_irqrestore(&ll->hcill_lock, flags);
 345
 346        return 0;
 347}
 348
 349static inline int ll_check_data_len(struct ll_struct *ll, int len)
 350{
 351        register int room = skb_tailroom(ll->rx_skb);
 352
 353        BT_DBG("len %d room %d", len, room);
 354
 355        if (!len) {
 356                hci_recv_frame(ll->rx_skb);
 357        } else if (len > room) {
 358                BT_ERR("Data length is too large");
 359                kfree_skb(ll->rx_skb);
 360        } else {
 361                ll->rx_state = HCILL_W4_DATA;
 362                ll->rx_count = len;
 363                return len;
 364        }
 365
 366        ll->rx_state = HCILL_W4_PACKET_TYPE;
 367        ll->rx_skb   = NULL;
 368        ll->rx_count = 0;
 369
 370        return 0;
 371}
 372
 373/* Recv data */
 374static int ll_recv(struct hci_uart *hu, void *data, int count)
 375{
 376        struct ll_struct *ll = hu->priv;
 377        register char *ptr;
 378        struct hci_event_hdr *eh;
 379        struct hci_acl_hdr   *ah;
 380        struct hci_sco_hdr   *sh;
 381        register int len, type, dlen;
 382
 383        BT_DBG("hu %p count %d rx_state %ld rx_count %ld", hu, count, ll->rx_state, ll->rx_count);
 384
 385        ptr = data;
 386        while (count) {
 387                if (ll->rx_count) {
 388                        len = min_t(unsigned int, ll->rx_count, count);
 389                        memcpy(skb_put(ll->rx_skb, len), ptr, len);
 390                        ll->rx_count -= len; count -= len; ptr += len;
 391
 392                        if (ll->rx_count)
 393                                continue;
 394
 395                        switch (ll->rx_state) {
 396                        case HCILL_W4_DATA:
 397                                BT_DBG("Complete data");
 398                                hci_recv_frame(ll->rx_skb);
 399
 400                                ll->rx_state = HCILL_W4_PACKET_TYPE;
 401                                ll->rx_skb = NULL;
 402                                continue;
 403
 404                        case HCILL_W4_EVENT_HDR:
 405                                eh = hci_event_hdr(ll->rx_skb);
 406
 407                                BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
 408
 409                                ll_check_data_len(ll, eh->plen);
 410                                continue;
 411
 412                        case HCILL_W4_ACL_HDR:
 413                                ah = hci_acl_hdr(ll->rx_skb);
 414                                dlen = __le16_to_cpu(ah->dlen);
 415
 416                                BT_DBG("ACL header: dlen %d", dlen);
 417
 418                                ll_check_data_len(ll, dlen);
 419                                continue;
 420
 421                        case HCILL_W4_SCO_HDR:
 422                                sh = hci_sco_hdr(ll->rx_skb);
 423
 424                                BT_DBG("SCO header: dlen %d", sh->dlen);
 425
 426                                ll_check_data_len(ll, sh->dlen);
 427                                continue;
 428                        }
 429                }
 430
 431                /* HCILL_W4_PACKET_TYPE */
 432                switch (*ptr) {
 433                case HCI_EVENT_PKT:
 434                        BT_DBG("Event packet");
 435                        ll->rx_state = HCILL_W4_EVENT_HDR;
 436                        ll->rx_count = HCI_EVENT_HDR_SIZE;
 437                        type = HCI_EVENT_PKT;
 438                        break;
 439
 440                case HCI_ACLDATA_PKT:
 441                        BT_DBG("ACL packet");
 442                        ll->rx_state = HCILL_W4_ACL_HDR;
 443                        ll->rx_count = HCI_ACL_HDR_SIZE;
 444                        type = HCI_ACLDATA_PKT;
 445                        break;
 446
 447                case HCI_SCODATA_PKT:
 448                        BT_DBG("SCO packet");
 449                        ll->rx_state = HCILL_W4_SCO_HDR;
 450                        ll->rx_count = HCI_SCO_HDR_SIZE;
 451                        type = HCI_SCODATA_PKT;
 452                        break;
 453
 454                /* HCILL signals */
 455                case HCILL_GO_TO_SLEEP_IND:
 456                        BT_DBG("HCILL_GO_TO_SLEEP_IND packet");
 457                        ll_device_want_to_sleep(hu);
 458                        ptr++; count--;
 459                        continue;
 460
 461                case HCILL_GO_TO_SLEEP_ACK:
 462                        /* shouldn't happen */
 463                        BT_ERR("received HCILL_GO_TO_SLEEP_ACK (in state %ld)", ll->hcill_state);
 464                        ptr++; count--;
 465                        continue;
 466
 467                case HCILL_WAKE_UP_IND:
 468                        BT_DBG("HCILL_WAKE_UP_IND packet");
 469                        ll_device_want_to_wakeup(hu);
 470                        ptr++; count--;
 471                        continue;
 472
 473                case HCILL_WAKE_UP_ACK:
 474                        BT_DBG("HCILL_WAKE_UP_ACK packet");
 475                        ll_device_woke_up(hu);
 476                        ptr++; count--;
 477                        continue;
 478
 479                default:
 480                        BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
 481                        hu->hdev->stat.err_rx++;
 482                        ptr++; count--;
 483                        continue;
 484                };
 485
 486                ptr++; count--;
 487
 488                /* Allocate packet */
 489                ll->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
 490                if (!ll->rx_skb) {
 491                        BT_ERR("Can't allocate mem for new packet");
 492                        ll->rx_state = HCILL_W4_PACKET_TYPE;
 493                        ll->rx_count = 0;
 494                        return -ENOMEM;
 495                }
 496
 497                ll->rx_skb->dev = (void *) hu->hdev;
 498                bt_cb(ll->rx_skb)->pkt_type = type;
 499        }
 500
 501        return count;
 502}
 503
 504static struct sk_buff *ll_dequeue(struct hci_uart *hu)
 505{
 506        struct ll_struct *ll = hu->priv;
 507        return skb_dequeue(&ll->txq);
 508}
 509
 510static struct hci_uart_proto llp = {
 511        .id             = HCI_UART_LL,
 512        .open           = ll_open,
 513        .close          = ll_close,
 514        .recv           = ll_recv,
 515        .enqueue        = ll_enqueue,
 516        .dequeue        = ll_dequeue,
 517        .flush          = ll_flush,
 518};
 519
 520int __init ll_init(void)
 521{
 522        int err = hci_uart_register_proto(&llp);
 523
 524        if (!err)
 525                BT_INFO("HCILL protocol initialized");
 526        else
 527                BT_ERR("HCILL protocol registration failed");
 528
 529        return err;
 530}
 531
 532int __exit ll_deinit(void)
 533{
 534        return hci_uart_unregister_proto(&llp);
 535}
 536