linux/drivers/bluetooth/hci_ll.c
<<
>>
Prefs
   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_KERNEL);
 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                 * Traditionally, 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 */
 26de=ll" class="srefflag="L1/bluetooth.ooth/hci_ll.c#Lmd" class="sref">send_hcill_cmd(HCILL_WAKE_th/hci_ll2c#L160" id="L160" class=2line"26e wake up */
 222                        259" ="+code=BT_ERR" class="sref">BT_ERR(hu) < 0) {
 223         th/hci_ll2c#L162" id="L162" class=2line"2name="L162"> 1sref">hu);
flags);
l2-> 254
 252 165
 189         223         t!= rx_skb);
 234
pr2v = 
 236        spin_unlock_irqrestore(&ll->hth/hci_ll2c#L169" id="L169" class=2line"27ss="sref">priv;
kfree( 258
2th/hci_ll2c#L171" id="L171" class=2line"27"sref">skb, 1);
 239        hc id="L1722 class="line" name="L1722> 1722/a>        return 0;
 173}
 174
 175/*
 2432th/hci_ll2ets (waiting in tx_wait_2 list2 in txnt"> */
 245static void ll_device_want_to_sleep(struct HCILL_WAKE_t"> * Not2: assumes that hcill_loc2 spin28ice sleep */<6{
 247       class="c2mment"> * shouldn't 2e cal281me="L258"> 2s;
 248        struct ll_struct *ll =  181hu);
ll2struct *
 250        BT_DBG("hu h/hci_ll.2#L183" id="L183" class="2ine" 28me="L173"> 173}
s2b =  254
 252out:
 253        spin_lock_irqsave(&ll->h>->rx_skb);
,  237
 2th/hci_ll2c#L188" id="L188" class=2line"28f">GFP_KERNELn>
 256        if ( = HCILL_ASLEEP:
 228             ACKBT_ERR("ERR: HCILL_GO_TO_SLEEP_IND in state %ld", ll-&h/hci_ll.2#L190" id="L190" class="2ine" 2ame="L190"> 190}
 231
 232        /* sss="line"2name="L192"> 192
 233         * Cal2ed upon a wake-up-indica2ion f29me="L173"> 173}
 194out:
 236        spin_unlock_irqrestore(&ll->h="sref">h2i_uart *h=-> 1937
 238         unsigne2 long  167
 239        hc"sref">hu2/a>->err;
priv;
 120
 238      3th/hci_ll3c#L201" id="L201" class=3line"30ame="L241"> 241
 238      3a>       3/*3lock 3cill socol */
 186iveenname=45"> 245static void ll_device_want_to_sleep{
 184     a>(struct , HCILL_WAKE3th/hci_ll3c#L204" id="L204" class=3line"3name="L204"> 26{
 145{
 146        struct ll_struct *ll = rx_skb);
 203                 147
 ="L250"> 250        ue_tail(&ll->priv;
 1937
 252<3tionally,3in this case, receiving 3 wake31ame="L160"> 160
 2"L18p/bluetooth/hci_ll."L18p/blline" name="L239"> 2"L1href="+code=ll" class=, 1), 236"> 236       bt_c1href="+code=ll"bt_c1line" name="L239"> 2"L1href="+code=ll" class=)sref">ll_struct *k39"yp.href="+code=ll" k39"yp.ass=, 1)sref">ll->hu);
 1937
 252<3explicit 3ake-up-ack. Other BRF ve3sions31ef">tx_wait_q);
 253        spin_lock_irqsave(&ll->3require a3 explicit ack here, do a3cept 31ss="sref">NULL;
 1937
 252<3eILL_ASLE3/a>
 205        switch (ll-&3n class="3tring">"dual wake-u3-indi3ation"
ll->/* 3eliberate fall-through -3do no31">hcill_state);
<47
BT_ERR(HCILL_ASLEEP:
 2"L18etooth/hci_ll.c#L187" id="L187" class="line" name="L187"> 187                skb_queue_tail(&ll->/* acknowled3e dev3ce wake up */
hu) </span>
 219        ca3tring">&q3ot;cannot acknowledge de3ice w3ke up");
<47
BT_ERR(out;
<37
 252<3 id="L2243 class="line" name="L2243> 2243/a>                }
 2"L18etooth/hci_ll.c#L187" id="L187" class="line" name="L187"> 187                skb_dequeue(ue_tail(&ll-> 223 3              196"> 1937
 252<3 ILL_ASLE3" class="line" name="L223"> 223        default:
 221            INDh/hci_ll.c#L219" id="        IND/a>(ue_tail(&_hcill_cmd(HCILL_WAKE3/* any other3state3is illegal */
);
<47
 222     "L220" c      ="+code=BT_ERR" class="sref">BT_ERR(/* 3="+code=hcill_state" cla3s="sr3f">hcill_state);

 223 33">HCILL_ASLEEP:
err;
 189        hu) < 0) {
&q3g packets and change sta3e to 3CILL_AWAKE */) {
 206        case __ll_d3_awake(out;
<37
BT_ERR(                }

 252<3name="L233"> 235 193name="L239"> 2"L18etooth/hci_ll.c#L187" id="L187" class="line" name="L187"> 187                skb_dequeue(ue_tail(&ll->,         default:
 2break;
/* actually3send 33">hcill_state);
<47
 222BT_ERR("ERR: HCILL_GO_TO_SLEEP_IND in state %ld", ll-3i_uart_tx3wakeup(HCILL_ASLEEP:
 2"drivers/bluetooth/hci_ll.c#L166" id="L166" class="lill->
hu) <sref">err;
 242err;
__ll_d3lled upon a sleep-indica3ion f34ef">tx_wait_q);
 236        spin_unlock_irqrestore(&ll->3s="line" 3ame="L244"> 244NULL;
h3i_uart *
err;
hcill_state);
hu3/a>->llinhref     
 245static void  146       , 
a>(struct HCILL_WAKE3%p&qu3t;, 
 166        kfree_skb(hu);
/*3lock 3cill state */
BT_ERR(sref">BT_ERR(roomth/hci_ll.c#L14room    ee_skb(__ll_d3/a>, flags);
 2a hr!an>
aILL_WAKE_UP_ACK" class="sref">HCILL_WAKE355   3     193name="L239"> 2HCILrecv_fr="+ode=ll_device_want_recv_fr="+ id="L166" class="line" name="L166"> 166        kfree_skb(HCILL_AWAK} elseLn>
     ref">BT_ERR(roomth/hci_ll.c#L14room    eILL_WAKE_UP_ACK" class="sref">HCILL_WAKE35span cla3="+code=hcill_state" cla3s="sr35s illegal */
BT_ERR(hcill_state);
<47
 166        kfree_skb(/* acknowl3dge d3vice sleep */<} elseLLL_WAKE_UP_ACK" class="sref">HCILL_WAKE3th/hci_ll3c#L160" id="L160" class=3line"36e wake up */
 166        , hu) < 0) {
 166        f="drivers/bluetooth/hci_ll.c#L229" id=3&>       3c#L162" id="L162" class=3line"36e up");
<71
 href="+code=llventh/hci_ll.c#L146en45">f="drivers/bluetooth/hci_ll.c#L229" id=3&">__ll_d3href="+code=tx_wait_q" c3ass="36ef">tx_wait_qsref">err;
l3->NULL;
 165
f="drivers/bluetooth/hci_ll.c#L229" id=3&/hci_ll.3gt; 165
kfr> 1  struct sk_buff * 147
 166        pr3v = priv;

kfree(err;
hu);
/*
 252<3h/hci_ll.3#L173" id="L173" class="3ine" 3ame="Locol */
 245static void ll_device_want_to_sleeplldataevice_want_to_sdata    , 
HCILL_WAKE3ss="line"3name="L175"> 175 145{
 146        struct ll_struct *ll =  1charclass="line" nameptrhref="+code=ll" trss="sref">ll = flags;
ll = pr3 * 2. changes internal s3ate t379="sref">flags;
ll =  * Not3: assumes that hcill_loc3 spin38ice sleep */;
ll =  * shouldn't 3e cal38e wake up */<
sref">BT_ERR("yp.href="+code=ll""yp.ass=, class="sref">lldf="drivers/bluetooth/hci_ll.c#L229" id=3s="line" 3ame="L181"> 181hu);
ll3struct *
BT_ERR(e=BT_DBG" class="sref">ue_tail(&counoth/hci_ll.c#L14couno    sref">BT_ERR("ERR: HCILL_GO_TOode=IND in state %lode=IND     sref">BT_ERR("ERR: HCILL_GO_TOodecounoth/hci_ll.c#L14odecouno    ee_skb( 173}
s3b =  25ss="line" nameptrhref="+code=ll" trss=" struct ouwhilea>n>
HCILL_WAKE3>->"ERR: HCILL_GO_TOodecounoth/hci_ll.c#L14odecouno    eLLL_WAKE_UP_ACK" class="sref">HCILL_WAKE3>h/hci_ll3txq, 
);
<47
 struct BT_ERR("ERR: HCILL_GO_TOodecounoth/hci_ll.c#L14odecouno    ue_tail(&counoth/hci_ll.c#L14couno    ee_skb(pr3c#L188" id="L188" class=3line"38">hcill_state);

 2"L18p/oth/hci_ll.c#L14"L18p/o id="L166" class="line" name="L166"> 166        kfrsref">BT_ERR()sref">BT_ERR(ptrhref="+code=ll" trss="sref">BT_ERR()e_skb(HCILL_ASLEEP:
);
<47
 166        fe_tail(&counoth/hci_ll.c#L14couno     -fe_tail(&ptrhref="+code=ll" trss=" +f="drivers/bluetooth/hci_ll.c#L229" id=3h/hci_ll.3#L190" id="L190" class="3ine" 3ame="L190"> 190}
hu) < 0) {
"ERR: HCILL_GO_TOodecounoth/hci_ll.c#L14odecouno    e190"> 190}
ll3name="L192"> 192);
 173}
 194                }
<<<<<<<<<04
HCILL_WAKE3="sref">h3i_uart * 19""""""""ca>) {
        default:
:
);
<47
BT_ERR(
);
);
<47
 166        kfree_skb(hu3/a>->priv;
HCILL_ASLEEP:
);
);
<47
f="drivers/bluetooth/hci_ll.c#L229" id=4%p&qu4t;, 
);
);
<47
kfr>  struct sk_buff *hu) < 0) {
       4/*4lock 40"commref">err;
out;
<<<<<<<<) {
                }
<<<<<<<<);
<47
 166        kfree_skb(4CILL_ASLE4P_TO_AWAKE" class="sref"4HCILL40/a>        default:
:
);
<47
BT_ERR(eluetooth/hci_ll.ehss=">                )e_skb( 204                hcill_state);
hcill_state);

);
<47
 L166" class="line" name="L166"> 166(&eluetooth/hci_ll.ehss=">        )e_skb(HCILL_ASLEEP:
);
);
 190}
hu) < 0) {
) {
 166        kfree_skb(out;
<<<<<<<<<""""""""ass="line" named struct         ee_skb(NULL;
 19""""""""""""""""ass="line" name"drivers/bluetooth/hci_ll.c#L250" id="L250" class="line" naACL header: d6en+code=d_ERR" class="sref">BT_ERR(dee_skb(rx_skb);
"dual wake-u4-indi41s illegal */
);
);
<47
 L166" class="line" name="L166"> 166(&dee_skb(hcill_state);
<<<<<<<<<<<<<<<<priv;
/* acknowled4e dev4ce wake up */
<<<<<<<<) {
hu) < 0) {
 166        kfree_skb(&q4ot;cannot acknowledge de4ice w42"commref">err;
out;
BT_ERR(bluetooth/hci_ll."hss=">        ee_skb(NULL;
 224 4              196"> 19fault:
<<<<<<<< L166" class="line" name="L166"> 166(&bluetooth/hci_ll."hss=">        ee_skb( 224        default:

<<<<<<<</* any other4state4is illegal */
);
err;
/* 4="+code=hcill_state" cla4s="sr4f">hcill_state);
err;
 224 43ss="sref">priv;
/*
 252<4LP_ACKhu) < 0) {
<04
HCILL_WAKE4Lring">&q4g packets and change sta4e to 43e up");
) {
__ll_d4_awake(out;


BT_ERR(                }


BT_ERR( 235 19/span>

BT_ERR(        default:


BT_ERR(
);
/* actually4send 43ss="sref">priv;
HCILL_ASLEEP:
) {



BT_ERR(hu) < 0) {

BT_ERR(&q4name="L242"> 242);
BT_ERR(__ll_d4lled upon a sleep-indica4ion f44ass="sref">out;


BT_ERR( 244                }

h4i_uart *4h/hci_ll.4#L246" id="L246" class="4ine" 44/a>        default:
) {

);
<47
BT_ERR(hcill_state);

BT_ERR(HCILL_ASLEEP:
);
<47
 166        BT_ERR(


BT_ERR(hu) < 0) {
       4/*4lock 45"commref">err;
__ll_d4/a>, out;
<37
 238      4th/hci_ll4c#L254" id="L254" class=4line"45a>                }
) {
/* s45             196"> 19/span>

BT_ERR( L166" class="li39        h45span cla4="+code=hcill_state" cla4s="sr45s illegal */


h45hcill_state);
<     }
/* acknowl4dge d46ss="sref">priv;

) {
hu) < 0) {


 238      4&>       4c#L162" id="L162" class=4line"46e up");


 228     GOne" s="linACK (a href="+code=BT)_ERR" class="sref">BT_ERR("ERR: HCILL_GO_TO_SLEEP_IND in state %ld", ll-4&">__ll_d4href="+code=tx_wait_q" c4ass="46ass="sref">out;


h4="sref">l4->                }

   4c#L165" id="L165" class=4line"46lass= href="+code=hcill_lock" class="sref">4&/hci_ll.4gt;
);
<47
BT_ERR(pr4v = hcill_state);

 L166" class="li39        h4th/hci_ll4c#L169" id="L169" class=4line"47">HCILL_ASLEEP:
);
<47
h4ass="sref4>kfree(
<<<<<<<<hu);
out;


BT_ERR(                }


 L166" class="li39        h4t5   4name="L175"> 175 19/span>

h4a/hci_ll.4s common work of the dev4ce wa47/a>        default:

hcill_state);
pr4 * 2. changes internal s4ate t47">hcill_state);
 * Not4: assumes that hcill_loc4 spin48">HCILL_ASLEEP:
);
<47
 * shouldn't 4e cal48e wake up */


ll_struct h   de=ll_struct" cl   ss="sref">ll_struct ; 181hu) < 0) {

h4"sref">ll4struct *);

out;
<}f="drivers/bluetooth/hci_ll.c#L229" id=4hh/hci_ll4b = NULL;
 193name="L239"> 2ptrhref="+code=ll" trss="++fe_tail(&counoth/hci_ll.c#L14couno    --code=hci_uart_tx_wakeup" class="sref">h4"/hci_ll.4ref="+code=tx_wait_q" cl4ss="s48"sref">rx_skb);


 238      4hsref">pr4c#L188" id="L188" class=4line"48">hcill_state);
kfr>  struct  L166" class="liers_MAX_FRAME_SIZ.c#L206" id="L206" _MAX_FRAME_SIZ.45">sref">BT_ERR(GF  ATOMICc#L206" id="L20GF  ATOMICss="ef="drivers/bluetooth/hci_ll.c#L229" id=4> = HCILL_ASLEEP:

 166        kfreLLL_WAKE_UP_ACK" class="sref">HCILL_WAKE4h/hci_ll.4#L190" id="L190" class="4ine" 49e wake up */


BT_ERR(hu) < 0) {
f="drivers/bluetooth/hci_ll.c#L229" id=4tsref">ll4name="L192"> 192);
 166        out;

<71
-    f="drivers/bluetooth/hci_ll.c#L229" id=4th/hci_ll4ame="L194"> 194                }
err;
h4i_uart *4=->        default:

 166        kfr>        ll_struct h   de=ll_struct" cl   ss="f="drivers/bluetooth/hci_ll.c#L229" id=4th/hci_ll4 long 
 L166" class="liie" name="L166"> 166        kfre>        hu3/a>->f="druetooth/hci_ll.c#L229"s=4line"48             196"> a href="+cpkt40hcill_ href=bt class="co5">kfr>  s5ruct    5   4  iL238" classa hre174" id="L174" classa hreng  245"drivers/blu"5lW4_EVENT5HDtooth/hci_ll.c#Lers/bl54_EVE50ouno    a>(struct HCILL_WAKE3ss="line"3name="L175"> 175 145{
 146        struct  193name="L239"> 2"L18etooth/hci_ll.c#L18"L187" class="lineq.c#L206" id="L206" _MAX_FRAME_SIZ.45">sref">5=">      5 
(struct HC5LL_ASLEEP:
);
<5an>);51TYP.45">f="dr">ll_struct id174" id="L174" id   ss="f="drivershref="+cod4=hu" 45e wUART_vers/bluetooth/hc5e wUART_ve clas  a>(struct kfr>  s5ly,4in this case, receiv5ng 4 5ake41me="L190"">ll_struct ops="line" name="L1ops=   ss="f="drive   -  s5L_HDtooth/hci_ll.c#Lers/5lW4_A5L_HDt"L20ll_struct close174" id="L174" close   ss="f="driv   -(struct    5href="+code=kfree_skb" c5ass="5ref">kfree_skb">ll_struct ="L252"> 252<3h/hci.3#L173"s="f="drive   - 252<3h/hci_ll.3#L173"s  a>(struct kfree_skb">ll_struct ena hre174" id="L174" ena href">kfree_skb   -(struct ll_struct ssa hre174" id="L174" ssa hreng (struct BT_ERR(dll_struct flu/hci_ll.c#L146" hflu/h   ss="f="driv   -(struct       5SLE4/a>(&dhc5ll_state);
<<<<<<<<<5<<<<<5ll = "5id=4e (struct ll = sref">5       kfree_skb(&q4ot;cannot acknowledg5 de4i5e w42"commref"uetooth/hci_ll.c#L22errs/blueto4hs="lierr{
"5iW4_EVENT5 f="drivers/bl="sref">HCILL_WAKEINFOhci_ll.4#L190" id=INFO73" class="4ine" 47ass="sref">out protocol iniWializedooth/hci_ll.c#L228" id="L228" class="line" name="L2285sre4 id="52244 class="line" name="52244>522442ss="sref"a>(<228" id="L228" class="line" name="L2285sre4t;ee_skb(HCILL_WAKE4h/hci_ll.4#L190" id="L190" class="4ine" 49e wake up */ protocol registrid=on failedooth/hci_ll.c#L228" id="L228" class="line" name="L2285s">      5      default:

<5<<<<<52continuef="drivers/bluetooth/hci_ll.c#L229"5>/* any o5her4state4is illegal */<5span>5);
hci5l_sta5e)-up-indica4ion f49am541a2/bluetooth/hc15too4L229"5cla4s="line" name="L229"5 224<53continuef="drivers/bluetooth/hci_ll.c#L229"5>/*ll = "54

sref">5d="L250" 5lass="line" naEv hr ll.c5L="+c5de=BT_-up-indica4ion f49am541a2/bluetooth/hc15tre4 id="5HDtooth/hci_ll.c#Lers/bl54_EVE5T_HDt"


The original LXR software by thLXR riveuniWy classthis experiers/al f49=on by href="drmailto:lxr@_llux.no" cxr@_llux.nosref"
cxr._llux.no kindly hosted by href="drhttp://www.redpill-_llpro.no" Redpill Lllpro AS classprovider of Llluxeup"sultwak and opsrid=ons ser=4lis since 1995.