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 #include <linux/atomic.h>
  32
  33 /* L2CAP defaults */
  34 #define L2CAP_DEFAULT_MTU               672
  35 #define L2CAP_DEFAULT_MIN_MTU           48
  36 #define L2CAP_DEFAULT_FLUSH_TO          0xFFFF
  37 #define L2CAP_EFS_DEFAULT_FLUSH_TO      0xFFFFFFFF
  38 #define L2CAP_DEFAULT_TX_WINDOW         63
  39 #define L2CAP_DEFAULT_EXT_WINDOW        0x3FFF
  40 #define L2CAP_DEFAULT_MAX_TX            3
  41 #define L2CAP_DEFAULT_RETRANS_TO        2000    /* 2 seconds */
  42 #define L2CAP_DEFAULT_MONITOR_TO        12000   /* 12 seconds */
  43 #define L2CAP_DEFAULT_MAX_PDU_SIZE      1492    /* Sized for AMP packet */
  44 #define L2CAP_DEFAULT_ACK_TO            200
  45 #define L2CAP_DEFAULT_MAX_SDU_SIZE      0xFFFF
  46 #define L2CAP_DEFAULT_SDU_ITIME         0xFFFFFFFF
  47 #define L2CAP_DEFAULT_ACC_LAT           0xFFFFFFFF
  48 #define L2CAP_BREDR_MAX_PAYLOAD         1019    /* 3-DH5 packet */
  49 #define L2CAP_LE_MIN_MTU                23
  50 #define L2CAP_ECRED_CONN_SCID_MAX       5
  51
  52 #define L2CAP_DISC_TIMEOUT              msecs_to_jiffies(100)
  53 #define L2CAP_DISC_REJ_TIMEOUT          msecs_to_jiffies(5000)
  54 #define L2CAP_ENC_TIMEOUT               msecs_to_jiffies(5000)
  55 #define L2CAP_CONN_TIMEOUT              msecs_to_jiffies(40000)
  56 #define L2CAP_INFO_TIMEOUT              msecs_to_jiffies(4000)
  57 #define L2CAP_MOVE_TIMEOUT              msecs_to_jiffies(4000)
  58 #define L2CAP_MOVE_ERTX_TIMEOUT         msecs_to_jiffies(60000)
  59 #define L2CAP_WAIT_ACK_POLL_PERIOD      msecs_to_jiffies(200)
  60 #define L2CAP_WAIT_ACK_TIMEOUT          msecs_to_jiffies(10000)
  61
  62 /* L2CAP socket address */
  63 struct sockaddr_l2 {
  64         sa_family_t     l2_family;
  65         __le16          l2_psm;
  66         bdaddr_t        l2_bdaddr;
  67         __le16          l2_cid;
  68         __u8            l2_bdaddr_type;
  69 };
  70
  71 /* L2CAP socket options */
  72 #define L2CAP_OPTIONS   0x01
  73 struct l2cap_options {
  74         __u16 omtu;
  75         __u16 imtu;
  76         __u16 flush_to;
  77         __u8  mode;
  78         __u8  fcs;
  79         __u8  max_tx;
  80         __u16 txwin_size;
  81 };
  82
  83 #define L2CAP_CONNINFO  0x02
  84 struct l2cap_conninfo {
  85         __u16 hci_handle;
  86         __u8  dev_class[3];
  87 };
  88
  89 #define L2CAP_LM        0x03
  90 #define L2CAP_LM_MASTER         0x0001
  91 #define L2CAP_LM_AUTH           0x0002
  92 #define L2CAP_LM_ENCRYPT        0x0004
  93 #define L2CAP_LM_TRUSTED        0x0008
  94 #define L2CAP_LM_RELIABLE       0x0010
  95 #define L2CAP_LM_SECURE         0x0020
  96 #define L2CAP_LM_FIPS           0x0040
  97
  98 /* L2CAP command codes */
  99 #define L2CAP_COMMAND_REJ       0x01
 100 #define L2CAP_CONN_REQ          0x02
 101 #define L2CAP_CONN_RSP          0x03
 102 #define L2CAP_CONF_REQ          0x04
 103 #define L2CAP_CONF_RSP          0x05
 104 #define L2CAP_DISCONN_REQ       0x06
 105 #define L2CAP_DISCONN_RSP       0x07
 106 #define L2CAP_ECHO_REQ          0x08
 107 #define L2CAP_ECHO_RSP          0x09
 108 #define L2CAP_INFO_REQ          0x0a
 109 #define L2CAP_INFO_RSP          0x0b
 110 #define L2CAP_CONN_PARAM_UPDATE_REQ     0x12
 111 #define L2CAP_CONN_PARAM_UPDATE_RSP     0x13
 112 #define L2CAP_LE_CONN_REQ       0x14
 113 #define L2CAP_LE_CONN_RSP       0x15
 114 #define L2CAP_LE_CREDITS        0x16
 115 #define L2CAP_ECRED_CONN_REQ    0x17
 116 #define L2CAP_ECRED_CONN_RSP    0x18
 117 #define L2CAP_ECRED_RECONF_REQ  0x19
 118 #define L2CAP_ECRED_RECONF_RSP  0x1a
 119
 120 /* L2CAP extended feature mask */
 121 #define L2CAP_FEAT_FLOWCTL      0x00000001
 122 #define L2CAP_FEAT_RETRANS      0x00000002
 123 #define L2CAP_FEAT_BIDIR_QOS    0x00000004
 124 #define L2CAP_FEAT_ERTM         0x00000008
 125 #define L2CAP_FEAT_STREAMING    0x00000010
 126 #define L2CAP_FEAT_FCS          0x00000020
 127 #define L2CAP_FEAT_EXT_FLOW     0x00000040
 128 #define L2CAP_FEAT_FIXED_CHAN   0x00000080
 129 #define L2CAP_FEAT_EXT_WINDOW   0x00000100
 130 #define L2CAP_FEAT_UCD          0x00000200
 131
 132 /* L2CAP checksum option */
 133 #define L2CAP_FCS_NONE          0x00
 134 #define L2CAP_FCS_CRC16         0x01
 135
 136 /* L2CAP fixed channels */
 137 #define L2CAP_FC_SIG_BREDR      0x02
 138 #define L2CAP_FC_CONNLESS       0x04
 139 #define L2CAP_FC_ATT            0x10
 140 #define L2CAP_FC_SIG_LE         0x20
 141 #define L2CAP_FC_SMP_LE         0x40
 142 #define L2CAP_FC_SMP_BREDR      0x80
 143
 144 /* L2CAP Control Field bit masks */
 145 #define L2CAP_CTRL_SAR                  0xC000
 146 #define L2CAP_CTRL_REQSEQ               0x3F00
 147 #define L2CAP_CTRL_TXSEQ                0x007E
 148 #define L2CAP_CTRL_SUPERVISE            0x000C
 149
 150 #define L2CAP_CTRL_RETRANS              0x0080
 151 #define L2CAP_CTRL_FINAL                0x0080
 152 #define L2CAP_CTRL_POLL                 0x0010
 153 #define L2CAP_CTRL_FRAME_TYPE           0x0001 /* I- or S-Frame */
 154
 155 #define L2CAP_CTRL_TXSEQ_SHIFT          1
 156 #define L2CAP_CTRL_SUPER_SHIFT          2
 157 #define L2CAP_CTRL_POLL_SHIFT           4
 158 #define L2CAP_CTRL_FINAL_SHIFT          7
 159 #define L2CAP_CTRL_REQSEQ_SHIFT         8
 160 #define L2CAP_CTRL_SAR_SHIFT            14
 161
 162 /* L2CAP Extended Control Field bit mask */
 163 #define L2CAP_EXT_CTRL_TXSEQ            0xFFFC0000
 164 #define L2CAP_EXT_CTRL_SAR              0x00030000
 165 #define L2CAP_EXT_CTRL_SUPERVISE        0x00030000
 166 #define L2CAP_EXT_CTRL_REQSEQ           0x0000FFFC
 167
 168 #define L2CAP_EXT_CTRL_POLL             0x00040000
 169 #define L2CAP_EXT_CTRL_FINAL            0x00000002
 170 #define L2CAP_EXT_CTRL_FRAME_TYPE       0x00000001 /* I- or S-Frame */
 171
 172 #define L2CAP_EXT_CTRL_FINAL_SHIFT      1
 173 #define L2CAP_EXT_CTRL_REQSEQ_SHIFT     2
 174 #define L2CAP_EXT_CTRL_SAR_SHIFT        16
 175 #define L2CAP_EXT_CTRL_SUPER_SHIFT      16
 176 #define L2CAP_EXT_CTRL_POLL_SHIFT       18
 177 #define L2CAP_EXT_CTRL_TXSEQ_SHIFT      18
 178
 179 /* L2CAP Supervisory Function */
 180 #define L2CAP_SUPER_RR          0x00
 181 #define L2CAP_SUPER_REJ         0x01
 182 #define L2CAP_SUPER_RNR         0x02
 183 #define L2CAP_SUPER_SREJ        0x03
 184
 185 /* L2CAP Segmentation and Reassembly */
 186 #define L2CAP_SAR_UNSEGMENTED   0x00
 187 #define L2CAP_SAR_START         0x01
 188 #define L2CAP_SAR_END           0x02
 189 #define L2CAP_SAR_CONTINUE      0x03
 190
 191 /* L2CAP Command rej. reasons */
 192 #define L2CAP_REJ_NOT_UNDERSTOOD        0x0000
 193 #define L2CAP_REJ_MTU_EXCEEDED          0x0001
 194 #define L2CAP_REJ_INVALID_CID           0x0002
 195
 196 /* L2CAP structures */
 197 struct l2cap_hdr {
 198         __le16     len;
 199         __le16     cid;
 200 } __packed;
 201 #define L2CAP_LEN_SIZE          2
 202 #define L2CAP_HDR_SIZE          4
 203 #define L2CAP_ENH_HDR_SIZE      6
 204 #define L2CAP_EXT_HDR_SIZE      8
 205
 206 #define L2CAP_FCS_SIZE          2
 207 #define L2CAP_SDULEN_SIZE       2
 208 #define L2CAP_PSMLEN_SIZE       2
 209 #define L2CAP_ENH_CTRL_SIZE     2
 210 #define L2CAP_EXT_CTRL_SIZE     4
 211
 212 struct l2cap_cmd_hdr {
 213         __u8       code;
 214         __u8       ident;
 215         __le16     len;
 216 } __packed;
 217 #define L2CAP_CMD_HDR_SIZE      4
 218
 219 struct l2cap_cmd_rej_unk {
 220         __le16     reason;
 221 } __packed;
 222
 223 struct l2cap_cmd_rej_mtu {
 224         __le16     reason;
 225         __le16     max_mtu;
 226 } __packed;
 227
 228 struct l2cap_cmd_rej_cid {
 229         __le16     reason;
 230         __le16     scid;
 231         __le16     dcid;
 232 } __packed;
 233
 234 struct l2cap_conn_req {
 235         __le16     psm;
 236         __le16     scid;
 237 } __packed;
 238
 239 struct l2cap_conn_rsp {
 240         __le16     dcid;
 241         __le16     scid;
 242         __le16     result;
 243         __le16     status;
 244 } __packed;
 245
 246 /* protocol/service multiplexer (PSM) */
 247 #define L2CAP_PSM_SDP           0x0001
 248 #define L2CAP_PSM_RFCOMM        0x0003
 249 #define L2CAP_PSM_3DSP          0x0021
 250 #define L2CAP_PSM_IPSP          0x0023 /* 6LoWPAN */
 251
 252 #define L2CAP_PSM_DYN_START     0x1001
 253 #define L2CAP_PSM_DYN_END       0xffff
 254 #define L2CAP_PSM_AUTO_END      0x10ff
 255 #define L2CAP_PSM_LE_DYN_START  0x0080
 256 #define L2CAP_PSM_LE_DYN_END    0x00ff
 257
 258 /* channel identifier */
 259 #define L2CAP_CID_SIGNALING     0x0001
 260 #define L2CAP_CID_CONN_LESS     0x0002
 261 #define L2CAP_CID_ATT           0x0004
 262 #define L2CAP_CID_LE_SIGNALING  0x0005
 263 #define L2CAP_CID_SMP           0x0006
 264 #define L2CAP_CID_SMP_BREDR     0x0007
 265 #define L2CAP_CID_DYN_START     0x0040
 266 #define L2CAP_CID_DYN_END       0xffff
 267 #define L2CAP_CID_LE_DYN_END    0x007f
 268
 269 /* connect/create channel results */
 270 #define L2CAP_CR_SUCCESS        0x0000
 271 #define L2CAP_CR_PEND           0x0001
 272 #define L2CAP_CR_BAD_PSM        0x0002
 273 #define L2CAP_CR_SEC_BLOCK      0x0003
 274 #define L2CAP_CR_NO_MEM         0x0004
 275 #define L2CAP_CR_INVALID_SCID   0x0006
 276 #define L2CAP_CR_SCID_IN_USE    0x0007
 277
 278 /* credit based connect results */
 279 #define L2CAP_CR_LE_SUCCESS             0x0000
 280 #define L2CAP_CR_LE_BAD_PSM             0x0002
 281 #define L2CAP_CR_LE_NO_MEM              0x0004
 282 #define L2CAP_CR_LE_AUTHENTICATION      0x0005
 283 #define L2CAP_CR_LE_AUTHORIZATION       0x0006
 284 #define L2CAP_CR_LE_BAD_KEY_SIZE        0x0007
 285 #define L2CAP_CR_LE_ENCRYPTION          0x0008
 286 #define L2CAP_CR_LE_INVALID_SCID        0x0009
 287 #define L2CAP_CR_LE_SCID_IN_USE         0X000A
 288 #define L2CAP_CR_LE_UNACCEPT_PARAMS     0X000B
 289 #define L2CAP_CR_LE_INVALID_PARAMS      0X000C
 290
 291 /* connect/create channel status */
 292 #define L2CAP_CS_NO_INFO        0x0000
 293 #define L2CAP_CS_AUTHEN_PEND    0x0001
 294 #define L2CAP_CS_AUTHOR_PEND    0x0002
 295
 296 struct l2cap_conf_req {
 297         __le16     dcid;
 298         __le16     flags;
 299         __u8       data[];
 300 } __packed;
 301
 302 struct l2cap_conf_rsp {
 303         __le16     scid;
 304         __le16     flags;
 305         __le16     result;
 306         __u8       data[];
 307 } __packed;
 308
 309 #define L2CAP_CONF_SUCCESS      0x0000
 310 #define L2CAP_CONF_UNACCEPT     0x0001
 311 #define L2CAP_CONF_REJECT       0x0002
 312 #define L2CAP_CONF_UNKNOWN      0x0003
 313 #define L2CAP_CONF_PENDING      0x0004
 314 #define L2CAP_CONF_EFS_REJECT   0x0005
 315
 316 /* configuration req/rsp continuation flag */
 317 #define L2CAP_CONF_FLAG_CONTINUATION    0x0001
 318
 319 struct l2cap_conf_opt {
 320         __u8       type;
 321         __u8       len;
 322         __u8       val[];
 323 } __packed;
 324 #define L2CAP_CONF_OPT_SIZE     2
 325
 326 #define L2CAP_CONF_HINT         0x80
 327 #define L2CAP_CONF_MASK         0x7f
 328
 329 #define L2CAP_CONF_MTU          0x01
 330 #define L2CAP_CONF_FLUSH_TO     0x02
 331 #define L2CAP_CONF_QOS          0x03
 332 #define L2CAP_CONF_RFC          0x04
 333 #define L2CAP_CONF_FCS          0x05
 334 #define L2CAP_CONF_EFS          0x06
 335 #define L2CAP_CONF_EWS          0x07
 336
 337 #define L2CAP_CONF_MAX_SIZE     22
 338
 339 struct l2cap_conf_rfc {
 340         __u8       mode;
 341         __u8       txwin_size;
 342         __u8       max_transmit;
 343         __le16     retrans_timeout;
 344         __le16     monitor_timeout;
 345         __le16     max_pdu_size;
 346 } __packed;
 347
 348 #define L2CAP_MODE_BASIC        0x00
 349 #define L2CAP_MODE_RETRANS      0x01
 350 #define L2CAP_MODE_FLOWCTL      0x02
 351 #define L2CAP_MODE_ERTM         0x03
 352 #define L2CAP_MODE_STREAMING    0x04
 353
 354 /* Unlike the above this one doesn't actually map to anything that would
 355  * ever be sent over the air. Therefore, use a value that's unlikely to
 356  * ever be used in the BR/EDR configuration phase.
 357  */
 358 #define L2CAP_MODE_LE_FLOWCTL   0x80
 359 #define L2CAP_MODE_EXT_FLOWCTL  0x81
 360
 361 struct l2cap_conf_efs {
 362         __u8    id;
 363         __u8    stype;
 364         __le16  msdu;
 365         __le32  sdu_itime;
 366         __le32  acc_lat;
 367         __le32  flush_to;
 368 } __packed;
 369
 370 #define L2CAP_SERV_NOTRAFIC     0x00
 371 #define L2CAP_SERV_BESTEFFORT   0x01
 372 #define L2CAP_SERV_GUARANTEED   0x02
 373
 374 #define L2CAP_BESTEFFORT_ID     0x01
 375
 376 struct l2cap_disconn_req {
 377         __le16     dcid;
 378         __le16     scid;
 379 } __packed;
 380
 381 struct l2cap_disconn_rsp {
 382         __le16     dcid;
 383         __le16     scid;
 384 } __packed;
 385
 386 struct l2cap_info_req {
 387         __le16      type;
 388 } __packed;
 389
 390 struct l2cap_info_rsp {
 391         __le16      type;
 392         __le16      result;
 393         __u8        data[];
 394 } __packed;
 395
 396 #define L2CAP_MR_SUCCESS        0x0000
 397 #define L2CAP_MR_PEND           0x0001
 398 #define L2CAP_MR_BAD_ID         0x0002
 399 #define L2CAP_MR_SAME_ID        0x0003
 400 #define L2CAP_MR_NOT_SUPP       0x0004
 401 #define L2CAP_MR_COLLISION      0x0005
 402 #define L2CAP_MR_NOT_ALLOWED    0x0006
 403
 404 struct l2cap_move_chan_cfm {
 405         __le16      icid;
 406         __le16      result;
 407 } __packed;
 408
 409 #define L2CAP_MC_CONFIRMED      0x0000
 410 #define L2CAP_MC_UNCONFIRMED    0x0001
 411
 412 struct l2cap_move_chan_cfm_rsp {
 413         __le16      icid;
 414 } __packed;
 415
 416 /* info type */
 417 #define L2CAP_IT_CL_MTU         0x0001
 418 #define L2CAP_IT_FEAT_MASK      0x0002
 419 #define L2CAP_IT_FIXED_CHAN     0x0003
 420
 421 /* info result */
 422 #define L2CAP_IR_SUCCESS        0x0000
 423 #define L2CAP_IR_NOTSUPP        0x0001
 424
 425 struct l2cap_conn_param_update_req {
 426         __le16      min;
 427         __le16      max;
 428         __le16      latency;
 429         __le16      to_multiplier;
 430 } __packed;
 431
 432 struct l2cap_conn_param_update_rsp {
 433         __le16      result;
 434 } __packed;
 435
 436 /* Connection Parameters result */
 437 #define L2CAP_CONN_PARAM_ACCEPTED       0x0000
 438 #define L2CAP_CONN_PARAM_REJECTED       0x0001
 439
 440 struct l2cap_le_conn_req {
 441         __le16     psm;
 442         __le16     scid;
 443         __le16     mtu;
 444         __le16     mps;
 445         __le16     credits;
 446 } __packed;
 447
 448 struct l2cap_le_conn_rsp {
 449         __le16     dcid;
 450         __le16     mtu;
 451         __le16     mps;
 452         __le16     credits;
 453         __le16     result;
 454 } __packed;
 455
 456 struct l2cap_le_credits {
 457         __le16     cid;
 458         __le16     credits;
 459 } __packed;
 460
 461 #define L2CAP_ECRED_MIN_MTU             64
 462 #define L2CAP_ECRED_MIN_MPS             64
 463 #define L2CAP_ECRED_MAX_CID             5
 464
 465 struct l2cap_ecred_conn_req {
 466         __le16 psm;
 467         __le16 mtu;
 468         __le16 mps;
 469         __le16 credits;
 470         __le16 scid[];
 471 } __packed;
 472
 473 struct l2cap_ecred_conn_rsp {
 474         __le16 mtu;
 475         __le16 mps;
 476         __le16 credits;
 477         __le16 result;
 478         __le16 dcid[];
 479 };
 480
 481 struct l2cap_ecred_reconf_req {
 482         __le16 mtu;
 483         __le16 mps;
 484         __le16 scid[];
 485 } __packed;
 486
 487 #define L2CAP_RECONF_SUCCESS            0x0000
 488 #define L2CAP_RECONF_INVALID_MTU        0x0001
 489 #define L2CAP_RECONF_INVALID_MPS        0x0002
 490
 491 struct l2cap_ecred_reconf_rsp {
 492         __le16 result;
 493 } __packed;
 494
 495 /* ----- L2CAP channels and connections ----- */
 496 struct l2cap_seq_list {
 497         __u16   head;
 498         __u16   tail;
 499         __u16   mask;
 500         __u16   *list;
 501 };
 502
 503 #define L2CAP_SEQ_LIST_CLEAR    0xFFFF
 504 #define L2CAP_SEQ_LIST_TAIL     0x8000
 505
 506 struct l2cap_chan {
 507         struct l2cap_conn       *conn;
 508         struct kref     kref;
 509         atomic_t        nesting;
 510
 511         __u8            state;
 512
 513         bdaddr_t        dst;
 514         __u8            dst_type;
 515         bdaddr_t        src;
 516         __u8            src_type;
 517         __le16          psm;
 518         __le16          sport;
 519         __u16           dcid;
 520         __u16           scid;
 521
 522         __u16           imtu;
 523         __u16           omtu;
 524         __u16           flush_to;
 525         __u8            mode;
 526         __u8            chan_type;
 527         __u8            chan_policy;
 528
 529         __u8            sec_level;
 530
 531         __u8            ident;
 532
 533         __u8            conf_req[64];
 534         __u8            conf_len;
 535         __u8            num_conf_req;
 536         __u8            num_conf_rsp;
 537
 538         __u8            fcs;
 539
 540         __u16           tx_win;
 541         __u16           tx_win_max;
 542         __u16           ack_win;
 543         __u8            max_tx;
 544         __u16           retrans_timeout;
 545         __u16           monitor_timeout;
 546         __u16           mps;
 547
 548         __u16           tx_credits;
 549         __u16           rx_credits;
 550
 551         __u8            tx_state;
 552         __u8            rx_state;
 553
 554         unsigned long   conf_state;
 555         unsigned long   conn_state;
 556         unsigned long   flags;
 557
 558         __u16           next_tx_seq;
 559         __u16           expected_ack_seq;
 560         __u16           expected_tx_seq;
 561         __u16           buffer_seq;
 562         __u16           srej_save_reqseq;
 563         __u16           last_acked_seq;
 564         __u16           frames_sent;
 565         __u16           unacked_frames;
 566         __u8            retry_count;
 567         __u16           sdu_len;
 568         struct sk_buff  *sdu;
 569         struct sk_buff  *sdu_last_frag;
 570
 571         __u16           remote_tx_win;
 572         __u8            remote_max_tx;
 573         __u16           remote_mps;
 574
 575         __u8            local_id;
 576         __u8            local_stype;
 577         __u16           local_msdu;
 578         __u32           local_sdu_itime;
 579         __u32           local_acc_lat;
 580         __u32           local_flush_to;
 581
 582         __u8            remote_id;
 583         __u8            remote_stype;
 584         __u16           remote_msdu;
 585         __u32           remote_sdu_itime;
 586         __u32           remote_acc_lat;
 587         __u32           remote_flush_to;
 588
 589         struct delayed_work     chan_timer;
 590         struct delayed_work     retrans_timer;
 591         struct delayed_work     monitor_timer;
 592         struct delayed_work     ack_timer;
 593
 594         struct sk_buff          *tx_send_head;
 595         struct sk_buff_head     tx_q;
 596         struct sk_buff_head     srej_q;
 597         struct l2cap_seq_list   srej_list;
 598         struct l2cap_seq_list   retrans_list;
 599
 600         struct list_head        list;
 601         struct list_head        global_l;
 602
 603         void                    *data;
 604         const struct l2cap_ops  *ops;
 605         struct mutex            lock;
 606 };
 607
 608 struct l2cap_ops {
 609         char                    *name;
 610
 611         struct l2cap_chan       *(*new_connection) (struct l2cap_chan *chan);
 612         int                     (*recv) (struct l2cap_chan * chan,
 613                                          struct sk_buff *skb);
 614         void                    (*teardown) (struct l2cap_chan *chan, int err);
 615         void                    (*close) (struct l2cap_chan *chan);
 616         void                    (*state_change) (struct l2cap_chan *chan,
 617                                                  int state, int err);
 618         void                    (*ready) (struct l2cap_chan *chan);
 619         void                    (*defer) (struct l2cap_chan *chan);
 620         void                    (*resume) (struct l2cap_chan *chan);
 621         void                    (*suspend) (struct l2cap_chan *chan);
 622         void                    (*set_shutdown) (struct l2cap_chan *chan);
 623         long                    (*get_sndtimeo) (struct l2cap_chan *chan);
 624         struct pid              *(*get_peer_pid) (struct l2cap_chan *chan);
 625         struct sk_buff          *(*alloc_skb) (struct l2cap_chan *chan,
 626                                                unsigned long hdr_len,
 627                                                unsigned long len, int nb);
 628         int                     (*filter) (struct l2cap_chan * chan,
 629                                            struct sk_buff *skb);
 630 };
 631
 632 struct l2cap_conn {
 633         struct hci_conn         *hcon;
 634         struct hci_chan         *hchan;
 635
 636         unsigned int            mtu;
 637
 638         __u32                   feat_mask;
 639         __u8                    remote_fixed_chan;
 640         __u8                    local_fixed_chan;
 641
 642         __u8                    info_state;
 643         __u8                    info_ident;
 644
 645         struct delayed_work     info_timer;
 646
 647         struct sk_buff          *rx_skb;
 648         __u32                   rx_len;
 649         __u8                    tx_ident;
 650         struct mutex            ident_lock;
 651
 652         struct sk_buff_head     pending_rx;
 653         struct work_struct      pending_rx_work;
 654
 655         struct delayed_work     id_addr_timer;
 656
 657         __u8                    disc_reason;
 658
 659         struct l2cap_chan       *smp;
 660
 661         struct list_head        chan_l;
 662         struct mutex            chan_lock;
 663         struct kref             ref;
 664         struct list_head        users;
 665 };
 666
 667 struct l2cap_user {
 668         struct list_head list;
 669         int (*probe) (struct l2cap_conn *conn, struct l2cap_user *user);
 670         void (*remove) (struct l2cap_conn *conn, struct l2cap_user *user);
 671 };
 672
 673 #define L2CAP_INFO_CL_MTU_REQ_SENT      0x01
 674 #define L2CAP_INFO_FEAT_MASK_REQ_SENT   0x04
 675 #define L2CAP_INFO_FEAT_MASK_REQ_DONE   0x08
 676
 677 #define L2CAP_CHAN_RAW                  1
 678 #define L2CAP_CHAN_CONN_LESS            2
 679 #define L2CAP_CHAN_CONN_ORIENTED        3
 680 #define L2CAP_CHAN_FIXED                4
 681
 682 /* ----- L2CAP socket info ----- */
 683 #define l2cap_pi(sk) ((struct l2cap_pinfo *) sk)
 684
 685 struct l2cap_pinfo {
 686         struct bt_sock          bt;
 687         struct l2cap_chan       *chan;
 688         struct sk_buff          *rx_busy_skb;
 689 };
 690
 691 enum {
 692         CONF_REQ_SENT,
 693         CONF_INPUT_DONE,
 694         CONF_OUTPUT_DONE,
 695         CONF_MTU_DONE,
 696         CONF_MODE_DONE,
 697         CONF_CONNECT_PEND,
 698         CONF_RECV_NO_FCS,
 699         CONF_STATE2_DEVICE,
 700         CONF_EWS_RECV,
 701         CONF_LOC_CONF_PEND,
 702         CONF_REM_CONF_PEND,
 703         CONF_NOT_COMPLETE,
 704 };
 705
 706 #define L2CAP_CONF_MAX_CONF_REQ 2
 707 #define L2CAP_CONF_MAX_CONF_RSP 2
 708
 709 enum {
 710         CONN_SREJ_SENT,
 711         CONN_WAIT_F,
 712         CONN_SREJ_ACT,
 713         CONN_SEND_PBIT,
 714         CONN_REMOTE_BUSY,
 715         CONN_LOCAL_BUSY,
 716         CONN_REJ_ACT,
 717         CONN_SEND_FBIT,
 718         CONN_RNR_SENT,
 719 };
 720
 721 /* Definitions for flags in l2cap_chan */
 722 enum {
 723         FLAG_ROLE_SWITCH,
 724         FLAG_FORCE_ACTIVE,
 725         FLAG_FORCE_RELIABLE,
 726         FLAG_FLUSHABLE,
 727         FLAG_EXT_CTRL,
 728         FLAG_EFS_ENABLE,
 729         FLAG_DEFER_SETUP,
 730         FLAG_LE_CONN_REQ_SENT,
 731         FLAG_ECRED_CONN_REQ_SENT,
 732         FLAG_PENDING_SECURITY,
 733         FLAG_HOLD_HCI_CONN,
 734 };
 735
 736 /* Lock nesting levels for L2CAP channels. We need these because lockdep
 737  * otherwise considers all channels equal and will e.g. complain about a
 738  * connection oriented channel triggering SMP procedures or a listening
 739  * channel creating and locking a child channel.
 740  */
 741 enum {
 742         L2CAP_NESTING_SMP,
 743         L2CAP_NESTING_NORMAL,
 744         L2CAP_NESTING_PARENT,
 745 };
 746
 747 enum {
 748         L2CAP_TX_STATE_XMIT,
 749         L2CAP_TX_STATE_WAIT_F,
 750 };
 751
 752 enum {
 753         L2CAP_RX_STATE_RECV,
 754         L2CAP_RX_STATE_SREJ_SENT,
 755         L2CAP_RX_STATE_MOVE,
 756         L2CAP_RX_STATE_WAIT_P,
 757         L2CAP_RX_STATE_WAIT_F,
 758 };
 759
 760 enum {
 761         L2CAP_TXSEQ_EXPECTED,
 762         L2CAP_TXSEQ_EXPECTED_SREJ,
 763         L2CAP_TXSEQ_UNEXPECTED,
 764         L2CAP_TXSEQ_UNEXPECTED_SREJ,
 765         L2CAP_TXSEQ_DUPLICATE,
 766         L2CAP_TXSEQ_DUPLICATE_SREJ,
 767         L2CAP_TXSEQ_INVALID,
 768         L2CAP_TXSEQ_INVALID_IGNORE,
 769 };
 770
 771 enum {
 772         L2CAP_EV_DATA_REQUEST,
 773         L2CAP_EV_LOCAL_BUSY_DETECTED,
 774         L2CAP_EV_LOCAL_BUSY_CLEAR,
 775         L2CAP_EV_RECV_REQSEQ_AND_FBIT,
 776         L2CAP_EV_RECV_FBIT,
 777         L2CAP_EV_RETRANS_TO,
 778         L2CAP_EV_MONITOR_TO,
 779         L2CAP_EV_EXPLICIT_POLL,
 780         L2CAP_EV_RECV_IFRAME,
 781         L2CAP_EV_RECV_RR,
 782         L2CAP_EV_RECV_REJ,
 783         L2CAP_EV_RECV_RNR,
 784         L2CAP_EV_RECV_SREJ,
 785         L2CAP_EV_RECV_FRAME,
 786 };
 787
 788 enum {
 789         L2CAP_MOVE_ROLE_NONE,
 790         L2CAP_MOVE_ROLE_INITIATOR,
 791         L2CAP_MOVE_ROLE_RESPONDER,
 792 };
 793
 794 enum {
 795         L2CAP_MOVE_STABLE,
 796         L2CAP_MOVE_WAIT_REQ,
 797         L2CAP_MOVE_WAIT_RSP,
 798         L2CAP_MOVE_WAIT_RSP_SUCCESS,
 799         L2CAP_MOVE_WAIT_CONFIRM,
 800         L2CAP_MOVE_WAIT_CONFIRM_RSP,
 801         L2CAP_MOVE_WAIT_LOGICAL_COMP,
 802         L2CAP_MOVE_WAIT_LOGICAL_CFM,
 803         L2CAP_MOVE_WAIT_LOCAL_BUSY,
 804         L2CAP_MOVE_WAIT_PREPARE,
 805 };
 806
 807 void l2cap_chan_hold(struct l2cap_chan *c);
 808 struct l2cap_chan *l2cap_chan_hold_unless_zero(struct l2cap_chan *c);
 809 void l2cap_chan_put(struct l2cap_chan *c);
 810
 811 static inline void l2cap_chan_lock(struct l2cap_chan *chan)
 812 {
 813         mutex_lock_nested(&chan->lock, atomic_read(&chan->nesting));
 814 }
 815
 816 static inline void l2cap_chan_unlock(struct l2cap_chan *chan)
 817 {
 818         mutex_unlock(&chan->lock);
 819 }
 820
 821 static inline void l2cap_set_timer(struct l2cap_chan *chan,
 822                                    struct delayed_work *work, long timeout)
 823 {
 824         BT_DBG("chan %p state %s timeout %ld", chan,
 825                state_to_string(chan->state), timeout);
 826
 827         /* If delayed work cancelled do not hold(chan)
 828            since it is already done with previous set_timer */
 829         if (!cancel_delayed_work(work))
 830                 l2cap_chan_hold(chan);
 831
 832         schedule_delayed_work(work, timeout);
 833 }
 834
 835 static inline bool l2cap_clear_timer(struct l2cap_chan *chan,
 836                                      struct delayed_work *work)
 837 {
 838         bool ret;
 839
 840         /* put(chan) if delayed work cancelled otherwise it
 841            is done in delayed work function */
 842         ret = cancel_delayed_work(work);
 843         if (ret)
 844                 l2cap_chan_put(chan);
 845
 846         return ret;
 847 }
 848
 849 #define __set_chan_timer(c, t) l2cap_set_timer(c, &c->chan_timer, (t))
 850 #define __clear_chan_timer(c) l2cap_clear_timer(c, &c->chan_timer)
 851 #define __clear_retrans_timer(c) l2cap_clear_timer(c, &c->retrans_timer)
 852 #define __clear_monitor_timer(c) l2cap_clear_timer(c, &c->monitor_timer)
 853 #define __set_ack_timer(c) l2cap_set_timer(c, &chan->ack_timer, \
 854                 msecs_to_jiffies(L2CAP_DEFAULT_ACK_TO));
 855 #define __clear_ack_timer(c) l2cap_clear_timer(c, &c->ack_timer)
 856
 857 static inline int __seq_offset(struct l2cap_chan *chan, __u16 seq1, __u16 seq2)
 858 {
 859         if (seq1 >= seq2)
 860                 return seq1 - seq2;
 861         else
 862                 return chan->tx_win_max + 1 - seq2 + seq1;
 863 }
 864
 865 static inline __u16 __next_seq(struct l2cap_chan *chan, __u16 seq)
 866 {
 867         return (seq + 1) % (chan->tx_win_max + 1);
 868 }
 869
 870 static inline struct l2cap_chan *l2cap_chan_no_new_connection(struct l2cap_chan *chan)
 871 {
 872         return NULL;
 873 }
 874
 875 static inline int l2cap_chan_no_recv(struct l2cap_chan *chan, struct sk_buff *skb)
 876 {
 877         return -ENOSYS;
 878 }
 879
 880 static inline struct sk_buff *l2cap_chan_no_alloc_skb(struct l2cap_chan *chan,
 881                                                       unsigned long hdr_len,
 882                                                       unsigned long len, int nb)
 883 {
 884         return ERR_PTR(-ENOSYS);
 885 }
 886
 887 static inline void l2cap_chan_no_teardown(struct l2cap_chan *chan, int err)
 888 {
 889 }
 890
 891 static inline void l2cap_chan_no_close(struct l2cap_chan *chan)
 892 {
 893 }
 894
 895 static inline void l2cap_chan_no_ready(struct l2cap_chan *chan)
 896 {
 897 }
 898
 899 static inline void l2cap_chan_no_state_change(struct l2cap_chan *chan,
 900                                               int state, int err)
 901 {
 902 }
 903
 904 static inline void l2cap_chan_no_defer(struct l2cap_chan *chan)
 905 {
 906 }
 907
 908 static inline void l2cap_chan_no_suspend(struct l2cap_chan *chan)
 909 {
 910 }
 911
 912 static inline void l2cap_chan_no_resume(struct l2cap_chan *chan)
 913 {
 914 }
 915
 916 static inline void l2cap_chan_no_set_shutdown(struct l2cap_chan *chan)
 917 {
 918 }
 919
 920 static inline long l2cap_chan_no_get_sndtimeo(struct l2cap_chan *chan)
 921 {
 922         return 0;
 923 }
 924
 925 extern bool disable_ertm;
 926 extern bool enable_ecred;
 927
 928 int l2cap_init_sockets(void);
 929 void l2cap_cleanup_sockets(void);
 930 bool l2cap_is_socket(struct socket *sock);
 931
 932 void __l2cap_le_connect_rsp_defer(struct l2cap_chan *chan);
 933 void __l2cap_ecred_conn_rsp_defer(struct l2cap_chan *chan);
 934 void __l2cap_connect_rsp_defer(struct l2cap_chan *chan);
 935
 936 int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm);
 937 int l2cap_add_scid(struct l2cap_chan *chan,  __u16 scid);
 938
 939 struct l2cap_chan *l2cap_chan_create(void);
 940 void l2cap_chan_close(struct l2cap_chan *chan, int reason);
 941 int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid,
 942                        bdaddr_t *dst, u8 dst_type, u16 timeout);
 943 int l2cap_chan_reconfigure(struct l2cap_chan *chan, __u16 mtu);
 944 int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len);
 945 void l2cap_chan_busy(struct l2cap_chan *chan, int busy);
 946 int l2cap_chan_check_security(struct l2cap_chan *chan, bool initiator);
 947 void l2cap_chan_set_defaults(struct l2cap_chan *chan);
 948 int l2cap_ertm_init(struct l2cap_chan *chan);
 949 void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan);
 950 void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan);
 951 typedef void (*l2cap_chan_func_t)(struct l2cap_chan *chan, void *data);
 952 void l2cap_chan_list(struct l2cap_conn *conn, l2cap_chan_func_t func,
 953                      void *data);
 954 void l2cap_chan_del(struct l2cap_chan *chan, int err);
 955 void l2cap_send_conn_req(struct l2cap_chan *chan);
 956 void l2cap_move_start(struct l2cap_chan *chan);
 957 void l2cap_logical_cfm(struct l2cap_chan *chan, struct hci_chan *hchan,
 958                        u8 status);
 959 void __l2cap_physical_cfm(struct l2cap_chan *chan, int result);
 960
 961 struct l2cap_conn *l2cap_conn_get(struct l2cap_conn *conn);
 962 void l2cap_conn_put(struct l2cap_conn *conn);
 963
 964 int l2cap_register_user(struct l2cap_conn *conn, struct l2cap_user *user);
 965 void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user);
 966
 967 #endif /* __L2CAP_H */