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 #define L2CAP_BREDR_MAX_PAYLOAD         1019    /* 3-DH5 packet */
  48
  49 #define L2CAP_DISC_TIMEOUT              msecs_to_jiffies(100)
  50 #define L2CAP_DISC_REJ_TIMEOUT          msecs_to_jiffies(5000)
  51 #define L2CAP_ENC_TIMEOUT               msecs_to_jiffies(5000)
  52 #define L2CAP_CONN_TIMEOUT              msecs_to_jiffies(40000)
  53 #define L2CAP_INFO_TIMEOUT              msecs_to_jiffies(4000)
  54
  55 /* L2CAP socket address */
  56 struct sockaddr_l2 {
  57         sa_family_t     l2_family;
  58         __le16          l2_psm;
  59         bdaddr_t        l2_bdaddr;
  60         __le16          l2_cid;
  61         __u8            l2_bdaddr_type;
  62 };
  63
  64 /* L2CAP socket options */
  65 #define L2CAP_OPTIONS   0x01
  66 struct l2cap_options {
  67         __u16 omtu;
  68         __u16 imtu;
  69         __u16 flush_to;
  70         __u8  mode;
  71         __u8  fcs;
  72         __u8  max_tx;
  73         __u16 txwin_size;
  74 };
  75
  76 #define L2CAP_CONNINFO  0x02
  77 struct l2cap_conninfo {
  78         __u16 hci_handle;
  79         __u8  dev_class[3];
  80 };
  81
  82 #define L2CAP_LM        0x03
  83 #define L2CAP_LM_MASTER         0x0001
  84 #define L2CAP_LM_AUTH           0x0002
  85 #define L2CAP_LM_ENCRYPT        0x0004
  86 #define L2CAP_LM_TRUSTED        0x0008
  87 #define L2CAP_LM_RELIABLE       0x0010
  88 #define L2CAP_LM_SECURE         0x0020
  89
  90 /* L2CAP command codes */
  91 #define L2CAP_COMMAND_REJ       0x01
  92 #define L2CAP_CONN_REQ          0x02
  93 #define L2CAP_CONN_RSP          0x03
  94 #define L2CAP_CONF_REQ          0x04
  95 #define L2CAP_CONF_RSP          0x05
  96 #define L2CAP_DISCONN_REQ       0x06
  97 #define L2CAP_DISCONN_RSP       0x07
  98 #define L2CAP_ECHO_REQ          0x08
  99 #define L2CAP_ECHO_RSP          0x09
 100 #define L2CAP_INFO_REQ          0x0a
 101 #define L2CAP_INFO_RSP          0x0b
 102 #define L2CAP_CREATE_CHAN_REQ   0x0c
 103 #define L2CAP_CREATE_CHAN_RSP   0x0d
 104 #define L2CAP_MOVE_CHAN_REQ     0x0e
 105 #define L2CAP_MOVE_CHAN_RSP     0x0f
 106 #define L2CAP_MOVE_CHAN_CFM     0x10
 107 #define L2CAP_MOVE_CHAN_CFM_RSP 0x11
 108 #define L2CAP_CONN_PARAM_UPDATE_REQ     0x12
 109 #define L2CAP_CONN_PARAM_UPDATE_RSP     0x13
 110
 111 /* L2CAP extended feature mask */
 112 #define L2CAP_FEAT_FLOWCTL      0x00000001
 113 #define L2CAP_FEAT_RETRANS      0x00000002
 114 #define L2CAP_FEAT_BIDIR_QOS    0x00000004
 115 #define L2CAP_FEAT_ERTM         0x00000008
 116 #define L2CAP_FEAT_STREAMING    0x00000010
 117 #define L2CAP_FEAT_FCS          0x00000020
 118 #define L2CAP_FEAT_EXT_FLOW     0x00000040
 119 #define L2CAP_FEAT_FIXED_CHAN   0x00000080
 120 #define L2CAP_FEAT_EXT_WINDOW   0x00000100
 121 #define L2CAP_FEAT_UCD          0x00000200
 122
 123 /* L2CAP checksum option */
 124 #define L2CAP_FCS_NONE          0x00
 125 #define L2CAP_FCS_CRC16         0x01
 126
 127 /* L2CAP fixed channels */
 128 #define L2CAP_FC_L2CAP          0x02
 129 #define L2CAP_FC_A2MP           0x08
 130
 131 /* L2CAP Control Field bit masks */
 132 #define L2CAP_CTRL_SAR                  0xC000
 133 #define L2CAP_CTRL_REQSEQ               0x3F00
 134 #define L2CAP_CTRL_TXSEQ                0x007E
 135 #define L2CAP_CTRL_SUPERVISE            0x000C
 136
 137 #define L2CAP_CTRL_RETRANS              0x0080
 138 #define L2CAP_CTRL_FINAL                0x0080
 139 #define L2CAP_CTRL_POLL                 0x0010
 140 #define L2CAP_CTRL_FRAME_TYPE           0x0001 /* I- or S-Frame */
 141
 142 #define L2CAP_CTRL_TXSEQ_SHIFT          1
 143 #define L2CAP_CTRL_SUPER_SHIFT          2
 144 #define L2CAP_CTRL_POLL_SHIFT           4
 145 #define L2CAP_CTRL_FINAL_SHIFT          7
 146 #define L2CAP_CTRL_REQSEQ_SHIFT         8
 147 #define L2CAP_CTRL_SAR_SHIFT            14
 148
 149 /* L2CAP Extended Control Field bit mask */
 150 #define L2CAP_EXT_CTRL_TXSEQ            0xFFFC0000
 151 #define L2CAP_EXT_CTRL_SAR              0x00030000
 152 #define L2CAP_EXT_CTRL_SUPERVISE        0x00030000
 153 #define L2CAP_EXT_CTRL_REQSEQ           0x0000FFFC
 154
 155 #define L2CAP_EXT_CTRL_POLL             0x00040000
 156 #define L2CAP_EXT_CTRL_FINAL            0x00000002
 157 #define L2CAP_EXT_CTRL_FRAME_TYPE       0x00000001 /* I- or S-Frame */
 158
 159 #define L2CAP_EXT_CTRL_FINAL_SHIFT      1
 160 #define L2CAP_EXT_CTRL_REQSEQ_SHIFT     2
 161 #define L2CAP_EXT_CTRL_SAR_SHIFT        16
 162 #define L2CAP_EXT_CTRL_SUPER_SHIFT      16
 163 #define L2CAP_EXT_CTRL_POLL_SHIFT       18
 164 #define L2CAP_EXT_CTRL_TXSEQ_SHIFT      18
 165
 166 /* L2CAP Supervisory Function */
 167 #define L2CAP_SUPER_RR          0x00
 168 #define L2CAP_SUPER_REJ         0x01
 169 #define L2CAP_SUPER_RNR         0x02
 170 #define L2CAP_SUPER_SREJ        0x03
 171
 172 /* L2CAP Segmentation and Reassembly */
 173 #define L2CAP_SAR_UNSEGMENTED   0x00
 174 #define L2CAP_SAR_START         0x01
 175 #define L2CAP_SAR_END           0x02
 176 #define L2CAP_SAR_CONTINUE      0x03
 177
 178 /* L2CAP Command rej. reasons */
 179 #define L2CAP_REJ_NOT_UNDERSTOOD        0x0000
 180 #define L2CAP_REJ_MTU_EXCEEDED          0x0001
 181 #define L2CAP_REJ_INVALID_CID           0x0002
 182
 183 /* L2CAP structures */
 184 struct l2cap_hdr {
 185         __le16     len;
 186         __le16     cid;
 187 } __packed;
 188 #define L2CAP_HDR_SIZE          4
 189 #define L2CAP_ENH_HDR_SIZE      6
 190 #define L2CAP_EXT_HDR_SIZE      8
 191
 192 #define L2CAP_FCS_SIZE          2
 193 #define L2CAP_SDULEN_SIZE       2
 194 #define L2CAP_PSMLEN_SIZE       2
 195 #define L2CAP_ENH_CTRL_SIZE     2
 196 #define L2CAP_EXT_CTRL_SIZE     4
 197
 198 struct l2cap_cmd_hdr {
 199         __u8       code;
 200         __u8       ident;
 201         __le16     len;
 202 } __packed;
 203 #define L2CAP_CMD_HDR_SIZE      4
 204
 205 struct l2cap_cmd_rej_unk {
 206         __le16     reason;
 207 } __packed;
 208
 209 struct l2cap_cmd_rej_mtu {
 210         __le16     reason;
 211         __le16     max_mtu;
 212 } __packed;
 213
 214 struct l2cap_cmd_rej_cid {
 215         __le16     reason;
 216         __le16     scid;
 217         __le16     dcid;
 218 } __packed;
 219
 220 struct l2cap_conn_req {
 221         __le16     psm;
 222         __le16     scid;
 223 } __packed;
 224
 225 struct l2cap_conn_rsp {
 226         __le16     dcid;
 227         __le16     scid;
 228         __le16     result;
 229         __le16     status;
 230 } __packed;
 231
 232 /* channel indentifier */
 233 #define L2CAP_CID_SIGNALING     0x0001
 234 #define L2CAP_CID_CONN_LESS     0x0002
 235 #define L2CAP_CID_LE_DATA       0x0004
 236 #define L2CAP_CID_LE_SIGNALING  0x0005
 237 #define L2CAP_CID_SMP           0x0006
 238 #define L2CAP_CID_DYN_START     0x0040
 239 #define L2CAP_CID_DYN_END       0xffff
 240
 241 /* connect/create channel results */
 242 #define L2CAP_CR_SUCCESS        0x0000
 243 #define L2CAP_CR_PEND           0x0001
 244 #define L2CAP_CR_BAD_PSM        0x0002
 245 #define L2CAP_CR_SEC_BLOCK      0x0003
 246 #define L2CAP_CR_NO_MEM         0x0004
 247 #define L2CAP_CR_BAD_AMP        0x0005
 248
 249 /* connect/create channel status */
 250 #define L2CAP_CS_NO_INFO        0x0000
 251 #define L2CAP_CS_AUTHEN_PEND    0x0001
 252 #define L2CAP_CS_AUTHOR_PEND    0x0002
 253
 254 struct l2cap_conf_req {
 255         __le16     dcid;
 256         __le16     flags;
 257         __u8       data[0];
 258 } __packed;
 259
 260 struct l2cap_conf_rsp {
 261         __le16     scid;
 262         __le16     flags;
 263         __le16     result;
 264         __u8       data[0];
 265 } __packed;
 266
 267 #define L2CAP_CONF_SUCCESS      0x0000
 268 #define L2CAP_CONF_UNACCEPT     0x0001
 269 #define L2CAP_CONF_REJECT       0x0002
 270 #define L2CAP_CONF_UNKNOWN      0x0003
 271 #define L2CAP_CONF_PENDING      0x0004
 272 #define L2CAP_CONF_EFS_REJECT   0x0005
 273
 274 struct l2cap_conf_opt {
 275         __u8       type;
 276         __u8       len;
 277         __u8       val[0];
 278 } __packed;
 279 #define L2CAP_CONF_OPT_SIZE     2
 280
 281 #define L2CAP_CONF_HINT         0x80
 282 #define L2CAP_CONF_MASK         0x7f
 283
 284 #define L2CAP_CONF_MTU          0x01
 285 #define L2CAP_CONF_FLUSH_TO     0x02
 286 #define L2CAP_CONF_QOS          0x03
 287 #define L2CAP_CONF_RFC          0x04
 288 #define L2CAP_CONF_FCS          0x05
 289 #define L2CAP_CONF_EFS          0x06
 290 #define L2CAP_CONF_EWS          0x07
 291
 292 #define L2CAP_CONF_MAX_SIZE     22
 293
 294 struct l2cap_conf_rfc {
 295         __u8       mode;
 296         __u8       txwin_size;
 297         __u8       max_transmit;
 298         __le16     retrans_timeout;
 299         __le16     monitor_timeout;
 300         __le16     max_pdu_size;
 301 } __packed;
 302
 303 #define L2CAP_MODE_BASIC        0x00
 304 #define L2CAP_MODE_RETRANS      0x01
 305 #define L2CAP_MODE_FLOWCTL      0x02
 306 #define L2CAP_MODE_ERTM         0x03
 307 #define L2CAP_MODE_STREAMING    0x04
 308
 309 struct l2cap_conf_efs {
 310         __u8    id;
 311         __u8    stype;
 312         __le16  msdu;
 313         __le32  sdu_itime;
 314         __le32  acc_lat;
 315         __le32  flush_to;
 316 } __packed;
 317
 318 #define L2CAP_SERV_NOTRAFIC     0x00
 319 #define L2CAP_SERV_BESTEFFORT   0x01
 320 #define L2CAP_SERV_GUARANTEED   0x02
 321
 322 #define L2CAP_BESTEFFORT_ID     0x01
 323
 324 struct l2cap_disconn_req {
 325         __le16     dcid;
 326         __le16     scid;
 327 } __packed;
 328
 329 struct l2cap_disconn_rsp {
 330         __le16     dcid;
 331         __le16     scid;
 332 } __packed;
 333
 334 struct l2cap_info_req {
 335         __le16      type;
 336 } __packed;
 337
 338 struct l2cap_info_rsp {
 339         __le16      type;
 340         __le16      result;
 341         __u8        data[0];
 342 } __packed;
 343
 344 struct l2cap_create_chan_req {
 345         __le16      psm;
 346         __le16      scid;
 347         __u8        amp_id;
 348 } __packed;
 349
 350 struct l2cap_create_chan_rsp {
 351         __le16      dcid;
 352         __le16      scid;
 353         __le16      result;
 354         __le16      status;
 355 } __packed;
 356
 357 struct l2cap_move_chan_req {
 358         __le16      icid;
 359         __u8        dest_amp_id;
 360 } __packed;
 361
 362 struct l2cap_move_chan_rsp {
 363         __le16      icid;
 364         __le16      result;
 365 } __packed;
 366
 367 #define L2CAP_MR_SUCCESS        0x0000
 368 #define L2CAP_MR_PEND           0x0001
 369 #define L2CAP_MR_BAD_ID         0x0002
 370 #define L2CAP_MR_SAME_ID        0x0003
 371 #define L2CAP_MR_NOT_SUPP       0x0004
 372 #define L2CAP_MR_COLLISION      0x0005
 373 #define L2CAP_MR_NOT_ALLOWED    0x0006
 374
 375 struct l2cap_move_chan_cfm {
 376         __le16      icid;
 377         __le16      result;
 378 } __packed;
 379
 380 #define L2CAP_MC_CONFIRMED      0x0000
 381 #define L2CAP_MC_UNCONFIRMED    0x0001
 382
 383 struct l2cap_move_chan_cfm_rsp {
 384         __le16      icid;
 385 } __packed;
 386
 387 /* info type */
 388 #define L2CAP_IT_CL_MTU         0x0001
 389 #define L2CAP_IT_FEAT_MASK      0x0002
 390 #define L2CAP_IT_FIXED_CHAN     0x0003
 391
 392 /* info result */
 393 #define L2CAP_IR_SUCCESS        0x0000
 394 #define L2CAP_IR_NOTSUPP        0x0001
 395
 396 struct l2cap_conn_param_update_req {
 397         __le16      min;
 398         __le16      max;
 399         __le16      latency;
 400         __le16      to_multiplier;
 401 } __packed;
 402
 403 struct l2cap_conn_param_update_rsp {
 404         __le16      result;
 405 } __packed;
 406
 407 /* Connection Parameters result */
 408 #define L2CAP_CONN_PARAM_ACCEPTED       0x0000
 409 #define L2CAP_CONN_PARAM_REJECTED       0x0001
 410
 411 /* ----- L2CAP channels and connections ----- */
 412 struct l2cap_seq_list {
 413         __u16   head;
 414         __u16   tail;
 415         __u16   mask;
 416         __u16   *list;
 417 };
 418
 419 #define L2CAP_SEQ_LIST_CLEAR    0xFFFF
 420 #define L2CAP_SEQ_LIST_TAIL     0x8000
 421
 422 struct srej_list {
 423         __u16   tx_seq;
 424         struct list_head list;
 425 };
 426
 427 struct l2cap_chan {
 428         struct sock *sk;
 429
 430         struct l2cap_conn       *conn;
 431
 432         __u8            state;
 433
 434         atomic_t        refcnt;
 435
 436         __le16          psm;
 437         __u16           dcid;
 438         __u16           scid;
 439
 440         __u16           imtu;
 441         __u16           omtu;
 442         __u16           flush_to;
 443         __u8            mode;
 444         __u8            chan_type;
 445         __u8            chan_policy;
 446
 447         __le16          sport;
 448
 449         __u8            sec_level;
 450
 451         __u8            ident;
 452
 453         __u8            conf_req[64];
 454         __u8            conf_len;
 455         __u8            num_conf_req;
 456         __u8            num_conf_rsp;
 457
 458         __u8            fcs;
 459
 460         __u16           tx_win;
 461         __u16           tx_win_max;
 462         __u8            max_tx;
 463         __u16           retrans_timeout;
 464         __u16           monitor_timeout;
 465         __u16           mps;
 466
 467         __u8            tx_state;
 468         __u8            rx_state;
 469
 470         unsigned long   conf_state;
 471         unsigned long   conn_state;
 472         unsigned long   flags;
 473
 474         __u16           next_tx_seq;
 475         __u16           expected_ack_seq;
 476         __u16           expected_tx_seq;
 477         __u16           buffer_seq;
 478         __u16           buffer_seq_srej;
 479         __u16           srej_save_reqseq;
 480         __u16           last_acked_seq;
 481         __u16           frames_sent;
 482         __u16           unacked_frames;
 483         __u8            retry_count;
 484         __u16           srej_queue_next;
 485         __u8            num_acked;
 486         __u16           sdu_len;
 487         struct sk_buff  *sdu;
 488         struct sk_buff  *sdu_last_frag;
 489
 490         __u16           remote_tx_win;
 491         __u8            remote_max_tx;
 492         __u16           remote_mps;
 493
 494         __u8            local_id;
 495         __u8            local_stype;
 496         __u16           local_msdu;
 497         __u32           local_sdu_itime;
 498         __u32           local_acc_lat;
 499         __u32           local_flush_to;
 500
 501         __u8            remote_id;
 502         __u8            remote_stype;
 503         __u16           remote_msdu;
 504         __u32           remote_sdu_itime;
 505         __u32           remote_acc_lat;
 506         __u32           remote_flush_to;
 507
 508         struct delayed_work     chan_timer;
 509         struct delayed_work     retrans_timer;
 510         struct delayed_work     monitor_timer;
 511         struct delayed_work     ack_timer;
 512
 513         struct sk_buff          *tx_send_head;
 514         struct sk_buff_head     tx_q;
 515         struct sk_buff_head     srej_q;
 516         struct l2cap_seq_list   srej_list;
 517         struct l2cap_seq_list   retrans_list;
 518         struct list_head        srej_l;
 519
 520         struct list_head        list;
 521         struct list_head        global_l;
 522
 523         void                    *data;
 524         struct l2cap_ops        *ops;
 525         struct mutex            lock;
 526 };
 527
 528 struct l2cap_ops {
 529         char                    *name;
 530
 531         struct l2cap_chan       *(*new_connection) (void *data);
 532         int                     (*recv) (void *data, struct sk_buff *skb);
 533         void                    (*close) (void *data);
 534         void                    (*state_change) (void *data, int state);
 535         struct sk_buff          *(*alloc_skb) (struct l2cap_chan *chan,
 536                                                unsigned long len, int nb);
 537 };
 538
 539 struct l2cap_conn {
 540         struct hci_conn         *hcon;
 541         struct hci_chan         *hchan;
 542
 543         bdaddr_t                *dst;
 544         bdaddr_t                *src;
 545
 546         unsigned int            mtu;
 547
 548         __u32                   feat_mask;
 549         __u8                    fixed_chan_mask;
 550
 551         __u8                    info_state;
 552         __u8                    info_ident;
 553
 554         struct delayed_work     info_timer;
 555
 556         spinlock_t              lock;
 557
 558         struct sk_buff          *rx_skb;
 559         __u32                   rx_len;
 560         __u8                    tx_ident;
 561
 562         __u8                    disc_reason;
 563
 564         struct delayed_work     security_timer;
 565         struct smp_chan         *smp_chan;
 566
 567         struct list_head        chan_l;
 568         struct mutex            chan_lock;
 569 };
 570
 571 #define L2CAP_INFO_CL_MTU_REQ_SENT      0x01
 572 #define L2CAP_INFO_FEAT_MASK_REQ_SENT   0x04
 573 #define L2CAP_INFO_FEAT_MASK_REQ_DONE   0x08
 574
 575 #define L2CAP_CHAN_RAW                  1
 576 #define L2CAP_CHAN_CONN_LESS            2
 577 #define L2CAP_CHAN_CONN_ORIENTED        3
 578
 579 /* ----- L2CAP socket info ----- */
 580 #define l2cap_pi(sk) ((struct l2cap_pinfo *) sk)
 581
 582 struct l2cap_pinfo {
 583         struct bt_sock          bt;
 584         struct l2cap_chan       *chan;
 585         struct sk_buff          *rx_busy_skb;
 586 };
 587
 588 enum {
 589         CONF_REQ_SENT,
 590         CONF_INPUT_DONE,
 591         CONF_OUTPUT_DONE,
 592         CONF_MTU_DONE,
 593         CONF_MODE_DONE,
 594         CONF_CONNECT_PEND,
 595         CONF_NO_FCS_RECV,
 596         CONF_STATE2_DEVICE,
 597         CONF_EWS_RECV,
 598         CONF_LOC_CONF_PEND,
 599         CONF_REM_CONF_PEND,
 600 };
 601
 602 #define L2CAP_CONF_MAX_CONF_REQ 2
 603 #define L2CAP_CONF_MAX_CONF_RSP 2
 604
 605 enum {
 606         CONN_SREJ_SENT,
 607         CONN_WAIT_F,
 608         CONN_SREJ_ACT,
 609         CONN_SEND_PBIT,
 610         CONN_REMOTE_BUSY,
 611         CONN_LOCAL_BUSY,
 612         CONN_REJ_ACT,
 613         CONN_SEND_FBIT,
 614         CONN_RNR_SENT,
 615 };
 616
 617 /* Definitions for flags in l2cap_chan */
 618 enum {
 619         FLAG_ROLE_SWITCH,
 620         FLAG_FORCE_ACTIVE,
 621         FLAG_FORCE_RELIABLE,
 622         FLAG_FLUSHABLE,
 623         FLAG_EXT_CTRL,
 624         FLAG_EFS_ENABLE,
 625 };
 626
 627 enum {
 628         L2CAP_TX_STATE_XMIT,
 629         L2CAP_TX_STATE_WAIT_F,
 630 };
 631
 632 enum {
 633         L2CAP_RX_STATE_RECV,
 634         L2CAP_RX_STATE_SREJ_SENT,
 635 };
 636
 637 enum {
 638         L2CAP_TXSEQ_EXPECTED,
 639         L2CAP_TXSEQ_EXPECTED_SREJ,
 640         L2CAP_TXSEQ_UNEXPECTED,
 641         L2CAP_TXSEQ_UNEXPECTED_SREJ,
 642         L2CAP_TXSEQ_DUPLICATE,
 643         L2CAP_TXSEQ_DUPLICATE_SREJ,
 644         L2CAP_TXSEQ_INVALID,
 645         L2CAP_TXSEQ_INVALID_IGNORE,
 646 };
 647
 648 enum {
 649         L2CAP_EV_DATA_REQUEST,
 650         L2CAP_EV_LOCAL_BUSY_DETECTED,
 651         L2CAP_EV_LOCAL_BUSY_CLEAR,
 652         L2CAP_EV_RECV_REQSEQ_AND_FBIT,
 653         L2CAP_EV_RECV_FBIT,
 654         L2CAP_EV_RETRANS_TO,
 655         L2CAP_EV_MONITOR_TO,
 656         L2CAP_EV_EXPLICIT_POLL,
 657         L2CAP_EV_RECV_IFRAME,
 658         L2CAP_EV_RECV_RR,
 659         L2CAP_EV_RECV_REJ,
 660         L2CAP_EV_RECV_RNR,
 661         L2CAP_EV_RECV_SREJ,
 662         L2CAP_EV_RECV_FRAME,
 663 };
 664
 665 static inline void l2cap_chan_hold(struct l2cap_chan *c)
 666 {
 667         atomic_inc(&c->refcnt);
 668 }
 669
 670 static inline void l2cap_chan_put(struct l2cap_chan *c)
 671 {
 672         if (atomic_dec_and_test(&c->refcnt))
 673                 kfree(c);
 674 }
 675
 676 static inline void l2cap_chan_lock(struct l2cap_chan *chan)
 677 {
 678         mutex_lock(&chan->lock);
 679 }
 680
 681 static inline void l2cap_chan_unlock(struct l2cap_chan *chan)
 682 {
 683         mutex_unlock(&chan->lock);
 684 }
 685
 686 static inline void l2cap_set_timer(struct l2cap_chan *chan,
 687                                    struct delayed_work *work, long timeout)
 688 {
 689         BT_DBG("chan %p state %s timeout %ld", chan,
 690                state_to_string(chan->state), timeout);
 691
 692         /* If delayed work cancelled do not hold(chan)
 693            since it is already done with previous set_timer */
 694         if (!cancel_delayed_work(work))
 695                 l2cap_chan_hold(chan);
 696
 697         schedule_delayed_work(work, timeout);
 698 }
 699
 700 static inline bool l2cap_clear_timer(struct l2cap_chan *chan,
 701                                      struct delayed_work *work)
 702 {
 703         bool ret;
 704
 705         /* put(chan) if delayed work cancelled otherwise it
 706            is done in delayed work function */
 707         ret = cancel_delayed_work(work);
 708         if (ret)
 709                 l2cap_chan_put(chan);
 710
 711         return ret;
 712 }
 713
 714 #define __set_chan_timer(c, t) l2cap_set_timer(c, &c->chan_timer, (t))
 715 #define __clear_chan_timer(c) l2cap_clear_timer(c, &c->chan_timer)
 716 #define __set_retrans_timer(c) l2cap_set_timer(c, &c->retrans_timer, \
 717                 msecs_to_jiffies(L2CAP_DEFAULT_RETRANS_TO));
 718 #define __clear_retrans_timer(c) l2cap_clear_timer(c, &c->retrans_timer)
 719 #define __set_monitor_timer(c) l2cap_set_timer(c, &c->monitor_timer, \
 720                 msecs_to_jiffies(L2CAP_DEFAULT_MONITOR_TO));
 721 #define __clear_monitor_timer(c) l2cap_clear_timer(c, &c->monitor_timer)
 722 #define __set_ack_timer(c) l2cap_set_timer(c, &chan->ack_timer, \
 723                 msecs_to_jiffies(L2CAP_DEFAULT_ACK_TO));
 724 #define __clear_ack_timer(c) l2cap_clear_timer(c, &c->ack_timer)
 725
 726 static inline int __seq_offset(struct l2cap_chan *chan, __u16 seq1, __u16 seq2)
 727 {
 728         if (seq1 >= seq2)
 729                 return seq1 - seq2;
 730         else
 731                 return chan->tx_win_max + 1 - seq2 + seq1;
 732 }
 733
 734 static inline __u16 __next_seq(struct l2cap_chan *chan, __u16 seq)
 735 {
 736         return (seq + 1) % (chan->tx_win_max + 1);
 737 }
 738
 739 static inline int l2cap_tx_window_full(struct l2cap_chan *ch)
 740 {
 741         int sub;
 742
 743         sub = (ch->next_tx_seq - ch->expected_ack_seq) % 64;
 744
 745         if (sub < 0)
 746                 sub += 64;
 747
 748         return sub == ch->remote_tx_win;
 749 }
 750
 751 static inline __u16 __get_reqseq(struct l2cap_chan *chan, __u32 ctrl)
 752 {
 753         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 754                 return (ctrl & L2CAP_EXT_CTRL_REQSEQ) >>
 755                                                 L2CAP_EXT_CTRL_REQSEQ_SHIFT;
 756         else
 757                 return (ctrl & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT;
 758 }
 759
 760 static inline __u32 __set_reqseq(struct l2cap_chan *chan, __u32 reqseq)
 761 {
 762         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 763                 return (reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT) &
 764                                                         L2CAP_EXT_CTRL_REQSEQ;
 765         else
 766                 return (reqseq << L2CAP_CTRL_REQSEQ_SHIFT) & L2CAP_CTRL_REQSEQ;
 767 }
 768
 769 static inline __u16 __get_txseq(struct l2cap_chan *chan, __u32 ctrl)
 770 {
 771         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 772                 return (ctrl & L2CAP_EXT_CTRL_TXSEQ) >>
 773                                                 L2CAP_EXT_CTRL_TXSEQ_SHIFT;
 774         else
 775                 return (ctrl & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT;
 776 }
 777
 778 static inline __u32 __set_txseq(struct l2cap_chan *chan, __u32 txseq)
 779 {
 780         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 781                 return (txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT) &
 782                                                         L2CAP_EXT_CTRL_TXSEQ;
 783         else
 784                 return (txseq << L2CAP_CTRL_TXSEQ_SHIFT) & L2CAP_CTRL_TXSEQ;
 785 }
 786
 787 static inline bool __is_sframe(struct l2cap_chan *chan, __u32 ctrl)
 788 {
 789         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 790                 return ctrl & L2CAP_EXT_CTRL_FRAME_TYPE;
 791         else
 792                 return ctrl & L2CAP_CTRL_FRAME_TYPE;
 793 }
 794
 795 static inline __u32 __set_sframe(struct l2cap_chan *chan)
 796 {
 797         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 798                 return L2CAP_EXT_CTRL_FRAME_TYPE;
 799         else
 800                 return L2CAP_CTRL_FRAME_TYPE;
 801 }
 802
 803 static inline __u8 __get_ctrl_sar(struct l2cap_chan *chan, __u32 ctrl)
 804 {
 805         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 806                 return (ctrl & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT;
 807         else
 808                 return (ctrl & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT;
 809 }
 810
 811 static inline __u32 __set_ctrl_sar(struct l2cap_chan *chan, __u32 sar)
 812 {
 813         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 814                 return (sar << L2CAP_EXT_CTRL_SAR_SHIFT) & L2CAP_EXT_CTRL_SAR;
 815         else
 816                 return (sar << L2CAP_CTRL_SAR_SHIFT) & L2CAP_CTRL_SAR;
 817 }
 818
 819 static inline bool __is_sar_start(struct l2cap_chan *chan, __u32 ctrl)
 820 {
 821         return __get_ctrl_sar(chan, ctrl) == L2CAP_SAR_START;
 822 }
 823
 824 static inline __u32 __get_sar_mask(struct l2cap_chan *chan)
 825 {
 826         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 827                 return L2CAP_EXT_CTRL_SAR;
 828         else
 829                 return L2CAP_CTRL_SAR;
 830 }
 831
 832 static inline __u8 __get_ctrl_super(struct l2cap_chan *chan, __u32 ctrl)
 833 {
 834         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 835                 return (ctrl & L2CAP_EXT_CTRL_SUPERVISE) >>
 836                                                 L2CAP_EXT_CTRL_SUPER_SHIFT;
 837         else
 838                 return (ctrl & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT;
 839 }
 840
 841 static inline __u32 __set_ctrl_super(struct l2cap_chan *chan, __u32 super)
 842 {
 843         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 844                 return (super << L2CAP_EXT_CTRL_SUPER_SHIFT) &
 845                                                 L2CAP_EXT_CTRL_SUPERVISE;
 846         else
 847                 return (super << L2CAP_CTRL_SUPER_SHIFT) &
 848                                                         L2CAP_CTRL_SUPERVISE;
 849 }
 850
 851 static inline __u32 __set_ctrl_final(struct l2cap_chan *chan)
 852 {
 853         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 854                 return L2CAP_EXT_CTRL_FINAL;
 855         else
 856                 return L2CAP_CTRL_FINAL;
 857 }
 858
 859 static inline bool __is_ctrl_final(struct l2cap_chan *chan, __u32 ctrl)
 860 {
 861         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 862                 return ctrl & L2CAP_EXT_CTRL_FINAL;
 863         else
 864                 return ctrl & L2CAP_CTRL_FINAL;
 865 }
 866
 867 static inline __u32 __set_ctrl_poll(struct l2cap_chan *chan)
 868 {
 869         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 870                 return L2CAP_EXT_CTRL_POLL;
 871         else
 872                 return L2CAP_CTRL_POLL;
 873 }
 874
 875 static inline bool __is_ctrl_poll(struct l2cap_chan *chan, __u32 ctrl)
 876 {
 877         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 878                 return ctrl & L2CAP_EXT_CTRL_POLL;
 879         else
 880                 return ctrl & L2CAP_CTRL_POLL;
 881 }
 882
 883 static inline __u32 __get_control(struct l2cap_chan *chan, void *p)
 884 {
 885         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 886                 return get_unaligned_le32(p);
 887         else
 888                 return get_unaligned_le16(p);
 889 }
 890
 891 static inline void __put_control(struct l2cap_chan *chan, __u32 control,
 892                                                                 void *p)
 893 {
 894         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 895                 return put_unaligned_le32(control, p);
 896         else
 897                 return put_unaligned_le16(control, p);
 898 }
 899
 900 static inline __u8 __ctrl_size(struct l2cap_chan *chan)
 901 {
 902         if (test_bit(FLAG_EXT_CTRL, &chan->flags))
 903                 return L2CAP_EXT_HDR_SIZE - L2CAP_HDR_SIZE;
 904         else
 905                 return L2CAP_ENH_HDR_SIZE - L2CAP_HDR_SIZE;
 906 }
 907
 908 extern bool disable_ertm;
 909
 910 int l2cap_init_sockets(void);
 911 void l2cap_cleanup_sockets(void);
 912
 913 void __l2cap_connect_rsp_defer(struct l2cap_chan *chan);
 914 int __l2cap_wait_ack(struct sock *sk);
 915
 916 int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm);
 917 int l2cap_add_scid(struct l2cap_chan *chan,  __u16 scid);
 918
 919 struct l2cap_chan *l2cap_chan_create(void);
 920 void l2cap_chan_close(struct l2cap_chan *chan, int reason);
 921 void l2cap_chan_destroy(struct l2cap_chan *chan);
 922 int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid,
 923                        bdaddr_t *dst, u8 dst_type);
 924 int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len,
 925                                                                 u32 priority);
 926 void l2cap_chan_busy(struct l2cap_chan *chan, int busy);
 927 int l2cap_chan_check_security(struct l2cap_chan *chan);
 928 void l2cap_chan_set_defaults(struct l2cap_chan *chan);
 929
 930 #endif /* __L2CAP_H */