include/net/bluetooth/l2cap.h

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4    Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>
   5    Copyright (C) 2010 Google Inc.
   6
   7    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License version 2 as
  11    published by the Free Software Foundation;
  12
  13    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  14    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  16    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  17    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  18    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  19    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  20    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21
  22    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  23    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  24    SOFTWARE IS DISCLAIMED.
  25 */
  26
  27 #ifndef __L2CAP_H
  28 #define __L2CAP_H
  29
  30 #include <asm/unaligned.h>
  31
  32 /* L2CAP defaults */
  33 #define L2CAP_DEFAULT_MTU               672
  34 #define L2CAP_DEFAULT_MIN_MTU           48
  35 #define L2CAP_DEFAULT_FLUSH_TO          0xffff
  36 #define L2CAP_DEFAULT_TX_WINDOW         63
  37 #define L2CAP_DEFAULT_EXT_WINDOW        0x3FFF
  38 #define L2CAP_DEFAULT_MAX_TX            3
  39 #define L2CAP_DEFAULT_RETRANS_TO        2000    /* 2 seconds */
  40 #define L2CAP_DEFAULT_MONITOR_TO        12000   /* 12 seconds */
  41 #define L2CAP_DEFAULT_MAX_PDU_SIZE      1009    /* Sized for 3-DH5 packet */
  42 #define L2CAP_DEFAULT_ACK_TO            200
  43 #define L2CAP_LE_DEFAULT_MTU            23
  44 #define L2CAP_DEFAULT_MAX_SDU_SIZE      0xFFFF
  45 #define L2CAP_DEFAULT_SDU_ITIME         0xFFFFFFFF
  46 #define L2CAP_DEFAULT_ACC_LAT           0xFFFFFFFF
  47
  48 #define L2CAP_CONN_TIMEOUT      (40000) /* 40 seconds */
  49 #define L2CAP_INFO_TIMEOUT      (4000)  /*  4 seconds */
  50
  51 /* L2CAP socket address */
  52 struct sockaddr_l2 {
  53         sa_family_t     l2_family;
  54         __le16          l2_psm;
  55         bdaddr_t        l2_bdaddr;
  56         __le16          l2_cid;
  57 };
  58
  59 /* L2CAP socket options */
  60 #define L2CAP_OPTIONS   0x01
  61 struct l2cap_options {
  62         __u16 omtu;
  63         __u16 imtu;
  64         __u16 flush_to;
  65         __u8  mode;
  66         __u8  fcs;
  67         __u8  max_tx;
  68         __u16 txwin_size;
  69 };
  70
  71 #define L2CAP_CONNINFO  0x02
  72 struct l2cap_conninfo {
  73         __u16 hci_handle;
  74         __u8  dev_class[3];
  75 };
  76
  77 #define L2CAP_LM        0x03
  78 #define L2CAP_LM_MASTER         0x0001
  79 #define L2CAP_LM_AUTH           0x0002
  80 #define L2CAP_LM_ENCRYPT        0x0004
  81 #define L2CAP_LM_TRUSTED        0x0008
  82 #define L2CAP_LM_RELIABLE       0x0010
  83 #define L2CAP_LM_SECURE         0x0020
  84
  85 /* L2CAP command codes */
  86 #define L2CAP_COMMAND_REJ       0x01
  87 #define L2CAP_CONN_REQ          0x02
  88 #define L2CAP_CONN_RSP          0x03
  89 #define L2CAP_CONF_REQ          0x04
  90 #define L2CAP_CONF_RSP          0x05
  91 #define L2CAP_DISCONN_REQ       0x06
  92 #define L2CAP_DISCONN_RSP       0x07
  93 #define L2CAP_ECHO_REQ          0x08
  94 #define L2CAP_ECHO_RSP          0x09
  95 #define L2CAP_INFO_REQ          0x0a
  96 #define L2CAP_INFO_RSP          0x0b
  97 #define L2CAP_CONN_PARAM_UPDATE_REQ     0x12
  98 #define L2CAP_CONN_PARAM_UPDATE_RSP     0x13
  99
 100 /* L2CAP extended feature mask */
 101 #define L2CAP_FEAT_FLOWCTL      0x00000001
 102 #define L2CAP_FEAT_RETRANS      0x00000002
 103 #define L2CAP_FEAT_BIDIR_QOS    0x00000004
 104 #define L2CAP_FEAT_ERTM         0x00000008
 105 #define L2CAP_FEAT_STREAMING    0x00000010
 106 #define L2CAP_FEAT_FCS          0x00000020
 107 #define L2CAP_FEAT_EXT_FLOW     0x00000040
 108 #define L2CAP_FEAT_FIXED_CHAN   0x00000080
 109 #define L2CAP_FEAT_EXT_WINDOW   0x00000100
 110 #define L2CAP_FEAT_UCD          0x00000200
 111
 112 /* L2CAP checksum option */
 113 #define L2CAP_FCS_NONE          0x00
 114 #define L2CAP_FCS_CRC16         0x01
 115
 116 /* L2CAP Control Field bit masks */
 117 #define L2CAP_CTRL_SAR                  0xC000
 118 #define L2CAP_CTRL_REQSEQ               0x3F00
 119 #define L2CAP_CTRL_TXSEQ                0x007E
 120 #define L2CAP_CTRL_SUPERVISE            0x000C
 121
 122 #define L2CAP_CTRL_RETRANS              0x0080
 123 #define L2CAP_CTRL_FINAL                0x0080
 124 #define L2CAP_CTRL_POLL                 0x0010
 125 #define L2CAP_CTRL_FRAME_TYPE           0x0001 /* I- or S-Frame */
 126
 127 #define L2CAP_CTRL_TXSEQ_SHIFT          1
 128 #define L2CAP_CTRL_SUPER_SHIFT          2
 129 #define L2CAP_CTRL_REQSEQ_SHIFT         8
 130 #define L2CAP_CTRL_SAR_SHIFT            14
 131
 132 /* L2CAP Extended Control Field bit mask */
 133 #define L2CAP_EXT_CTRL_TXSEQ            0xFFFC0000
 134 #define L2CAP_EXT_CTRL_SAR              0x00030000
 135 #define L2CAP_EXT_CTRL_SUPERVISE        0x00030000
 136 #define L2CAP_EXT_CTRL_REQSEQ           0x0000FFFC
 137
 138 #define L2CAP_EXT_CTRL_POLL             0x00040000
 139 #define L2CAP_EXT_CTRL_FINAL            0x00000002
 140 #define L2CAP_EXT_CTRL_FRAME_TYPE       0x00000001 /* I- or S-Frame */
 141
 142 #define L2CAP_EXT_CTRL_REQSEQ_SHIFT     2
 143 #define L2CAP_EXT_CTRL_SAR_SHIFT        16
 144 #define L2CAP_EXT_CTRL_SUPER_SHIFT      16
 145 #define L2CAP_EXT_CTRL_TXSEQ_SHIFT      18
 146
 147 /* L2CAP Supervisory Function */
 148 #define L2CAP_SUPER_RR          0x00
 149 #define L2CAP_SUPER_REJ         0x01
 150 #define L2CAP_SUPER_RNR         0x02
 151 #define L2CAP_SUPER_SREJ        0x03
 152
 153 /* L2CAP Segmentation and Reassembly */
 154 #define L2CAP_SAR_UNSEGMENTED   0x00
 155 #define L2CAP_SAR_START         0x01
 156 #define L2CAP_SAR_END           0x02
 157 #define L2CAP_SAR_CONTINUE      0x03
 158
 159 /* L2CAP Command rej. reasons */
 160 #define L2CAP_REJ_NOT_UNDERSTOOD        0x0000
 161 #define L2CAP_REJ_MTU_EXCEEDED          0x0001
 162 #define L2CAP_REJ_INVALID_CID           0x0002
 163
 164 /* L2CAP structures */
 165 struct l2cap_hdr {
 166         __le16     len;
 167         __le16     cid;
 168 } __packed;
 169 #define L2CAP_HDR_SIZE          4
 170 #define L2CAP_ENH_HDR_SIZE      6
 171 #define L2CAP_EXT_HDR_SIZE      8
 172
 173 #define L2CAP_FCS_SIZE          2
 174 #define L2CAP_SDULEN_SIZE       2
 175 #define L2CAP_PSMLEN_SIZE       2
 176
 177 struct l2cap_cmd_hdr {
 178         __u8       code;
 179         __u8       ident;
 180         __le16     len;
 181 } __packed;
 182 #define L2CAP_CMD_HDR_SIZE      4
 183
 184 struct l2cap_cmd_rej_unk {
 185         __le16     reason;
 186 } __packed;
 187
 188 struct l2cap_cmd_rej_mtu {
 189         __le16     reason;
 190         __le16     max_mtu;
 191 } __packed;
 192
 193 struct l2cap_cmd_rej_cid {
 194         __le16     reason;
 195         __le16     scid;
 196         __le16     dcid;
 197 } __packed;
 198
 199 struct l2cap_conn_req {
 200         __le16     psm;
 201         __le16     scid;
 202 } __packed;
 203
 204 struct l2cap_conn_rsp {
 205         __le16     dcid;
 206         __le16     scid;
 207         __le16     result;
 208         __le16     status;
 209 } __packed;
 210
 211 /* channel indentifier */
 212 #define L2CAP_CID_SIGNALING     0x0001
 213 #define L2CAP_CID_CONN_LESS     0x0002
 214 #define L2CAP_CID_LE_DATA       0x0004
 215 #define L2CAP_CID_LE_SIGNALING  0x0005
 216 #define L2CAP_CID_SMP           0x0006
 217 #define L2CAP_CID_DYN_START     0x0040
 218 #define L2CAP_CID_DYN_END       0xffff
 219
 220 /* connect result */
 221 #define L2CAP_CR_SUCCESS        0x0000
 222 #define L2CAP_CR_PEND           0x0001
 223 #define L2CAP_CR_BAD_PSM        0x0002
 224 #define L2CAP_CR_SEC_BLOCK      0x0003
 225 #define L2CAP_CR_NO_MEM         0x0004
 226
 227 /* connect status */
 228 #define L2CAP_CS_NO_INFO        0x0000
 229 #define L2CAP_CS_AUTHEN_PEND    0x0001
 230 #define L2CAP_CS_AUTHOR_PEND    0x0002
 231
 232 struct l2cap_conf_req {
 233         __le16     dcid;
 234         __le16     flags;
 235         __u8       data[0];
 236 } __packed;
 237
 238 struct l2cap_conf_rsp {
 239         __le16     scid;
 240         __le16     flags;
 241         __le16     result;
 242         __u8       data[0];
 243 } __packed;
 244
 245 #define L2CAP_CONF_SUCCESS      0x0000
 246 #define L2CAP_CONF_UNACCEPT     0x0001
 247 #define L2CAP_CONF_REJECT       0x0002
 248 #define L2CAP_CONF_UNKNOWN      0x0003
 249 #define L2CAP_CONF_PENDING      0x0004
 250 #define L2CAP_CONF_EFS_REJECT   0x0005
 251
 252 struct l2cap_conf_opt {
 253         __u8       type;
 254         __u8       len;
 255         __u8       val[0];
 256 } __packed;
 257 #define L2CAP_CONF_OPT_SIZE     2
 258
 259 #define L2CAP_CONF_HINT         0x80
 260 #define L2CAP_CONF_MASK         0x7f
 261
 262 #define L2CAP_CONF_MTU          0x01
 263 #define L2CAP_CONF_FLUSH_TO     0x02
 264 #define L2CAP_CONF_QOS          0x03
 265 #define L2CAP_CONF_RFC          0x04
 266 #define L2CAP_CONF_FCS          0x05
 267 #define L2CAP_CONF_EFS          0x06
 268 #define L2CAP_CONF_EWS          0x07
 269
 270 #define L2CAP_CONF_MAX_SIZE     22
 271
 272 struct l2cap_conf_rfc {
 273         __u8       mode;
 274         __u8       txwin_size;
 275         __u8       max_transmit;
 276         __le16     retrans_timeout;
 277         __le16     monitor_timeout;
 278         __le16     max_pdu_size;
 279 } __packed;
 280
 281 #define L2CAP_MODE_BASIC        0x00
 282 #define L2CAP_MODE_RETRANS      0x01
 283 #define L2CAP_MODE_FLOWCTL      0x02
 284 #define L2CAP_MODE_ERTM         0x03
 285 #define L2CAP_MODE_STREAMING    0x04
 286
 287 struct l2cap_conf_efs {
 288         __u8    id;
 289         __u8    stype;
 290         __le16  msdu;
 291         __le32  sdu_itime;
 292         __le32  acc_lat;
 293         __le32  flush_to;
 294 } __packed;
 295
 296 #define L2CAP_SERV_NOTRAFIC     0x00
 297 #define L2CAP_SERV_BESTEFFORT   0x01
 298 #define L2CAP_SERV_GUARANTEED   0x02
 299
 300 #define L2CAP_BESTEFFORT_ID     0x01
 301
 302 struct l2cap_disconn_req {
 303         __le16     dcid;
 304         __le16     scid;
 305 } __packed;
 306
 307 struct l2cap_disconn_rsp {
 308         __le16     dcid;
 309         __le16     scid;
 310 } __packed;
 311
 312 struct l2cap_info_req {
 313         __le16      type;
 314 } __packed;
 315
 316 struct l2cap_info_rsp {
 317         __le16      type;
 318         __le16      result;
 319         __u8        data[0];
 320 } __packed;
 321
 322 /* info type */
 323 #define L2CAP_IT_CL_MTU         0x0001
 324 #define L2CAP_IT_FEAT_MASK      0x0002
 325 #define L2CAP_IT_FIXED_CHAN     0x0003
 326
 327 /* info result */
 328 #define L2CAP_IR_SUCCESS        0x0000
 329 #define L2CAP_IR_NOTSUPP        0x0001
 330
 331 struct l2cap_conn_param_update_req {
 332         __le16      min;
 333         __le16      max;
 334         __le16      latency;
 335         __le16      to_multiplier;
 336 } __packed;
 337
 338 struct l2cap_conn_param_update_rsp {
 339         __le16      result;
 340 } __packed;
 341
 342 /* Connection Parameters result */
 343 #define L2CAP_CONN_PARAM_ACCEPTED       0x0000
 344 #define L2CAP_CONN_PARAM_REJECTED       0x0001
 345
 346 /* ----- L2CAP channels and connections ----- */
 347 struct srej_list {
 348         __u16   tx_seq;
 349         struct list_head list;
 350 };
 351
 352 struct l2cap_chan {
 353         struct sock *sk;
 354
 355         struct l2cap_conn       *conn;
 356
 357         __u8            state;
 358
 359         atomic_t        refcnt;
 360
 361         __le16          psm;
 362         __u16           dcid;
 363         __u16           scid;
 364
 365         __u16           imtu;
 366         __u16           omtu;
 367         __u16           flush_to;
 368         __u8            mode;
 369         __u8            chan_type;
 370
 371         __le16          sport;
 372
 373         __u8            sec_level;
 374
 375         __u8            ident;
 376
 377         __u8            conf_req[64];
 378         __u8            conf_len;
 379         __u8            num_conf_req;
 380         __u8            num_conf_rsp;
 381
 382         __u8            fcs;
 383
 384         __u16           tx_win;
 385         __u16           tx_win_max;
 386         __u8            max_tx;
 387         __u16           retrans_timeout;
 388         __u16           monitor_timeout;
 389         __u16           mps;
 390
 391         unsigned long   conf_state;
 392         unsigned long   conn_state;
 393         unsigned long   flags;
 394
 395         __u16           next_tx_seq;
 396         __u16           expected_ack_seq;
 397         __u16           expected_tx_seq;
 398         __u16           buffer_seq;
 399         __u16           buffer_seq_srej;
 400         __u16           srej_save_reqseq;
 401         __u16           frames_sent;
 402         __u16           unacked_frames;
 403         __u8            retry_count;
 404         __u8            num_acked;
 405         __u16           sdu_len;
 406         struct sk_buff  *sdu;
 407         struct sk_buff  *sdu_last_frag;
 408
 409         __u16           remote_tx_win;
 410         __u8            remote_max_tx;
 411         __u16           remote_mps;
 412
 413         __u8            local_id;
 414         __u8            local_stype;
 415         __u16           local_msdu;
 416         __u32           local_sdu_itime;
 417         __u32           local_acc_lat;
 418         __u32           local_flush_to;
 419
 420         __u8            remote_id;
 421         __u8            remote_stype;
 422         __u16           remote_msdu;
 423         __u32           remote_sdu_itime;
 424         __u32           remote_acc_lat;
 425         __u32           remote_flush_to;
 426
 427         struct timer_list       chan_timer;
 428         struct timer_list       retrans_timer;
 429         struct timer_list       monitor_timer;
 430         struct timer_list       ack_timer;
 431         struct sk_buff          *tx_send_head;
 432         struct sk_buff_head     tx_q;
 433         struct sk_buff_head     srej_q;
 434         struct list_head        srej_l;
 435
 436         struct list_head list;
 437         struct list_head global_l;
 438
 439         void            *data;
 440         struct l2cap_ops *ops;
 441 };
 442
 443 struct l2cap_ops {
 444         char            *name;
 445
 446         struct l2cap_chan       *(*new_connection) (void *data);
 447         int                     (*recv) (void *data, struct sk_buff *skb);
 448         void                    (*close) (void *data);
 449         void                    (*state_change) (void *data, int state);
 450 };
 451
 452 struct l2cap_conn {
 453         struct hci_conn *hcon;
 454         struct hci_chan *hchan;
 455
 456         bdaddr_t        *dst;
 457         bdaddr_t        *src;
 458
 459         unsigned int    mtu;
 460
 461         __u32           feat_mask;
 462
 463         __u8            info_state;
 464         __u8            info_ident;
 465
 466         struct timer_list info_timer;
 467
 468         spinlock_t      lock;
 469
 470         struct sk_buff *rx_skb;
 471         __u32           rx_len;
 472         __u8            tx_ident;
 473
 474         __u8            disc_reason;
 475
 476         struct timer_list security_timer;
 477         struct smp_chan *smp_chan;
 478
 479         struct list_head chan_l;
 480         rwlock_t        chan_lock;
 481 };
 482
 483 #define L2CAP_INFO_CL_MTU_REQ_SENT      0x01
 484 #define L2CAP_INFO_FEAT_MASK_REQ_SENT   0x04
 485 #define L2CAP_INFO_FEAT_MASK_REQ_DONE   0x08
 486
 487 #define L2CAP_CHAN_RAW                  1
 488 #define L2CAP_CHAN_CONN_LESS            2
 489 #define L2CAP_CHAN_CONN_ORIENTED        3
 490
 491 /* ----- L2CAP socket info ----- */
 492 #define l2cap_pi(sk) ((struct l2cap_pinfo *) sk)
 493
 494 struct l2cap_pinfo {
 495         struct bt_sock  bt;
 496         struct l2cap_chan       *chan;
 497         struct sk_buff  *rx_busy_skb;
 498 };
 499
 500 enum {
 501         CONF_REQ_SENT,
 502         CONF_INPUT_DONE,
 503         CONF_OUTPUT_DONE,
 504         CONF_MTU_DONE,
 505         CONF_MODE_DONE,
 506         CONF_CONNECT_PEND,
 507         CONF_NO_FCS_RECV,
 508         CONF_STATE2_DEVICE,
 509         CONF_EWS_RECV,
 510         CONF_LOC_CONF_PEND,
 511         CONF_REM_CONF_PEND,
 512 };
 513
 514 #define L2CAP_CONF_MAX_CONF_REQ 2
 515 #define L2CAP_CONF_MAX_CONF_RSP 2
 516
 517 enum {
 518         CONN_SREJ_SENT,
 519         CONN_WAIT_F,
 520         CONN_SREJ_ACT,
 521         CONN_SEND_PBIT,
 522         CONN_REMOTE_BUSY,
 523         CONN_LOCAL_BUSY,
 524         CONN_REJ_ACT,
 525         CONN_SEND_FBIT,
 526         CONN_RNR_SENT,
 527 };
 528
 529 /* Definitions for flags in l2cap_chan */
 530 enum {
 531         FLAG_ROLE_SWITCH,
 532         FLAG_FORCE_ACTIVE,
 533         FLAG_FORCE_RELIABLE,
 534         FLAG_FLUSHABLE,
 535         FLAG_EXT_CTRL,
 536         FLAG_EFS_ENABLE,
 537 };
 538
 539 #define __set_chan_timer(c, t) l2cap_set_timer(c, &c->chan_timer, (t))
 540 #define __clear_chan_timer(c) l2cap_clear_timer(c, &c->chan_timer)
 541 #define __set_retrans_timer(c) l2cap_set_timer(c, &c->retrans_timer, \
 542                 L2CAP_DEFAULT_RETRANS_TO);
 543 #define __clear_retrans_timer(c) l2cap_clear_timer(c, &c->retrans_timer)
 544 #define __set_monitor_timer(c) l2cap_set_timer(c, &c->monitor_timer, \
 545                 L2CAP_DEFAULT_MONITOR_TO);
 546 #define __clear_monitor_timer(c) l2cap_clear_timer(c, &c->monitor_timer)
 547 #define __set_ack_timer(c) l2cap_set_timer(c, &chan->ack_timer, \
 548                 L2CAP_DEFAULT_ACK_TO);
 549 #define __clear_ack_timer(c) l2cap_clear_timer(c, &c->ack_timer)
 550
 551 static inline int __seq_offset(struct l2cap_chan *chan, __u16 seq1, __u16 seq2)
 552 {
 553         int offset;
 554
 555         offset = (seq1 - seq2) % (chan->tx_win_max + 1);
 556         if (offset < 0)
 557                 offset += (chan->tx_win_max + 1);
 558
 559         return offset;
 560 }
 561
 562 static inline __u16 __next_seq(struct l2cap_chan *chan, __u16 seq)
 563 {
 564         return (seq + 1) % (chan->tx_win_max + 1);
 565 }
 566
 567 static inline int l2cap_tx_window_full(struct l2cap_chan *ch)
 568 {
 569         int sub;
 570
 571         sub = (ch->next_tx_seq - ch->expected_ack_seq) % 64;
 572
 573         if (sub < 0)
 574                 sub += 64;
 575
 576         return sub == ch->remote_tx_win;
 577 }
 578
 579 static inline __u16 __get_reqseq(struct l2cap_chan *chan, __u32 ctrl)
 580 {
 581         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 582                 return (ctrl & L2CAP_EXT_CTRL_REQSEQ) >>
 583                                                 L2CAP_EXT_CTRL_REQSEQ_SHIFT;
 584         else
 585                 return (ctrl & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT;
 586 }
 587
 588 static inline __u32 __set_reqseq(struct l2cap_chan *chan, __u32 reqseq)
 589 {
 590         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 591                 return (reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT) &
 592                                                         L2CAP_EXT_CTRL_REQSEQ;
 593         else
 594                 return (reqseq << L2CAP_CTRL_REQSEQ_SHIFT) & L2CAP_CTRL_REQSEQ;
 595 }
 596
 597 static inline __u16 __get_txseq(struct l2cap_chan *chan, __u32 ctrl)
 598 {
 599         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 600                 return (ctrl & L2CAP_EXT_CTRL_TXSEQ) >>
 601                                                 L2CAP_EXT_CTRL_TXSEQ_SHIFT;
 602         else
 603                 return (ctrl & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT;
 604 }
 605
 606 static inline __u32 __set_txseq(struct l2cap_chan *chan, __u32 txseq)
 607 {
 608         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 609                 return (txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT) &
 610                                                         L2CAP_EXT_CTRL_TXSEQ;
 611         else
 612                 return (txseq << L2CAP_CTRL_TXSEQ_SHIFT) & L2CAP_CTRL_TXSEQ;
 613 }
 614
 615 static inline bool __is_sframe(struct l2cap_chan *chan, __u32 ctrl)
 616 {
 617         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 618                 return ctrl & L2CAP_EXT_CTRL_FRAME_TYPE;
 619         else
 620                 return ctrl & L2CAP_CTRL_FRAME_TYPE;
 621 }
 622
 623 static inline __u32 __set_sframe(struct l2cap_chan *chan)
 624 {
 625         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 626                 return L2CAP_EXT_CTRL_FRAME_TYPE;
 627         else
 628                 return L2CAP_CTRL_FRAME_TYPE;
 629 }
 630
 631 static inline __u8 __get_ctrl_sar(struct l2cap_chan *chan, __u32 ctrl)
 632 {
 633         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 634                 return (ctrl & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT;
 635         else
 636                 return (ctrl & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT;
 637 }
 638
 639 static inline __u32 __set_ctrl_sar(struct l2cap_chan *chan, __u32 sar)
 640 {
 641         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 642                 return (sar << L2CAP_EXT_CTRL_SAR_SHIFT) & L2CAP_EXT_CTRL_SAR;
 643         else
 644                 return (sar << L2CAP_CTRL_SAR_SHIFT) & L2CAP_CTRL_SAR;
 645 }
 646
 647 static inline bool __is_sar_start(struct l2cap_chan *chan, __u32 ctrl)
 648 {
 649         return __get_ctrl_sar(chan, ctrl) == L2CAP_SAR_START;
 650 }
 651
 652 static inline __u32 __get_sar_mask(struct l2cap_chan *chan)
 653 {
 654         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 655                 return L2CAP_EXT_CTRL_SAR;
 656         else
 657                 return L2CAP_CTRL_SAR;
 658 }
 659
 660 static inline __u8 __get_ctrl_super(struct l2cap_chan *chan, __u32 ctrl)
 661 {
 662         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 663                 return (ctrl & L2CAP_EXT_CTRL_SUPERVISE) >>
 664                                                 L2CAP_EXT_CTRL_SUPER_SHIFT;
 665         else
 666                 return (ctrl & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT;
 667 }
 668
 669 static inline __u32 __set_ctrl_super(struct l2cap_chan *chan, __u32 super)
 670 {
 671         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 672                 return (super << L2CAP_EXT_CTRL_SUPER_SHIFT) &
 673                                                 L2CAP_EXT_CTRL_SUPERVISE;
 674         else
 675                 return (super << L2CAP_CTRL_SUPER_SHIFT) &
 676                                                         L2CAP_CTRL_SUPERVISE;
 677 }
 678
 679 static inline __u32 __set_ctrl_final(struct l2cap_chan *chan)
 680 {
 681         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 682                 return L2CAP_EXT_CTRL_FINAL;
 683         else
 684                 return L2CAP_CTRL_FINAL;
 685 }
 686
 687 static inline bool __is_ctrl_final(struct l2cap_chan *chan, __u32 ctrl)
 688 {
 689         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 690                 return ctrl & L2CAP_EXT_CTRL_FINAL;
 691         else
 692                 return ctrl & L2CAP_CTRL_FINAL;
 693 }
 694
 695 static inline __u32 __set_ctrl_poll(struct l2cap_chan *chan)
 696 {
 697         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 698                 return L2CAP_EXT_CTRL_POLL;
 699         else
 700                 return L2CAP_CTRL_POLL;
 701 }
 702
 703 static inline bool __is_ctrl_poll(struct l2cap_chan *chan, __u32 ctrl)
 704 {
 705         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 706                 return ctrl & L2CAP_EXT_CTRL_POLL;
 707         else
 708                 return ctrl & L2CAP_CTRL_POLL;
 709 }
 710
 711 static inline __u32 __get_control(struct l2cap_chan *chan, void *p)
 712 {
 713         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 714                 return get_unaligned_le32(p);
 715         else
 716                 return get_unaligned_le16(p);
 717 }
 718
 719 static inline void __put_control(struct l2cap_chan *chan, __u32 control,
 720                                                                 void *p)
 721 {
 722         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 723                 return put_unaligned_le32(control, p);
 724         else
 725                 return put_unaligned_le16(control, p);
 726 }
 727
 728 static inline __u8 __ctrl_size(struct l2cap_chan *chan)
 729 {
 730         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 731                 return L2CAP_EXT_HDR_SIZE - L2CAP_HDR_SIZE;
 732         else
 733                 return L2CAP_ENH_HDR_SIZE - L2CAP_HDR_SIZE;
 734 }
 735
 736 extern int disable_ertm;
 737 extern int enable_hs;
 738
 739 int l2cap_init_sockets(void);
 740 void l2cap_cleanup_sockets(void);
 741
 742 void __l2cap_connect_rsp_defer(struct l2cap_chan *chan);
 743 int __l2cap_wait_ack(struct sock *sk);
 744
 745 int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm);
 746 int l2cap_add_scid(struct l2cap_chan *chan,  __u16 scid);
 747
 748 struct l2cap_chan *l2cap_chan_create(struct sock *sk);
 749 void l2cap_chan_close(struct l2cap_chan *chan, int reason);
 750 void l2cap_chan_destroy(struct l2cap_chan *chan);
 751 int l2cap_chan_connect(struct l2cap_chan *chan);
 752 int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len,
 753                                                                 u32 priority);
 754 void l2cap_chan_busy(struct l2cap_chan *chan, int busy);
 755
 756 #endif /* __L2CAP_H */