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 <linux/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         /* New members must be added within the struct_group() macro below. */
 467         __struct_group(l2cap_ecred_conn_req_hdr, hdr, __packed,
 468                 __le16 psm;
 469                 __le16 mtu;
 470                 __le16 mps;
 471                 __le16 credits;
 472         );
 473         __le16 scid[];
 474 } __packed;
 475
 476 struct l2cap_ecred_conn_rsp {
 477         /* New members must be added within the struct_group() macro below. */
 478         struct_group_tagged(l2cap_ecred_conn_rsp_hdr, hdr,
 479                 __le16 mtu;
 480                 __le16 mps;
 481                 __le16 credits;
 482                 __le16 result;
 483         );
 484         __le16 dcid[];
 485 };
 486
 487 struct l2cap_ecred_reconf_req {
 488         __le16 mtu;
 489         __le16 mps;
 490         __le16 scid[];
 491 } __packed;
 492
 493 #define L2CAP_RECONF_SUCCESS            0x0000
 494 #define L2CAP_RECONF_INVALID_MTU        0x0001
 495 #define L2CAP_RECONF_INVALID_MPS        0x0002
 496
 497 struct l2cap_ecred_reconf_rsp {
 498         __le16 result;
 499 } __packed;
 500
 501 /* ----- L2CAP channels and connections ----- */
 502 struct l2cap_seq_list {
 503         __u16   head;
 504         __u16   tail;
 505         __u16   mask;
 506         __u16   *list;
 507 };
 508
 509 #define L2CAP_SEQ_LIST_CLEAR    0xFFFF
 510 #define L2CAP_SEQ_LIST_TAIL     0x8000
 511
 512 struct l2cap_chan {
 513         struct l2cap_conn       *conn;
 514         struct kref     kref;
 515         atomic_t        nesting;
 516
 517         __u8            state;
 518
 519         bdaddr_t        dst;
 520         __u8            dst_type;
 521         bdaddr_t        src;
 522         __u8            src_type;
 523         __le16          psm;
 524         __le16          sport;
 525         __u16           dcid;
 526         __u16           scid;
 527
 528         __u16           imtu;
 529         __u16           omtu;
 530         __u16           flush_to;
 531         __u8            mode;
 532         __u8            chan_type;
 533         __u8            chan_policy;
 534
 535         __u8            sec_level;
 536
 537         __u8            ident;
 538
 539         __u8            conf_req[64];
 540         __u8            conf_len;
 541         __u8            num_conf_req;
 542         __u8            num_conf_rsp;
 543
 544         __u8            fcs;
 545
 546         __u16           tx_win;
 547         __u16           tx_win_max;
 548         __u16           ack_win;
 549         __u8            max_tx;
 550         __u16           retrans_timeout;
 551         __u16           monitor_timeout;
 552         __u16           mps;
 553
 554         __u16           tx_credits;
 555         __u16           rx_credits;
 556
 557         /* estimated available receive buffer space or -1 if unknown */
 558         ssize_t         rx_avail;
 559
 560         __u8            tx_state;
 561         __u8            rx_state;
 562
 563         unsigned long   conf_state;
 564         unsigned long   conn_state;
 565         unsigned long   flags;
 566
 567         __u16           next_tx_seq;
 568         __u16           expected_ack_seq;
 569         __u16           expected_tx_seq;
 570         __u16           buffer_seq;
 571         __u16           srej_save_reqseq;
 572         __u16           last_acked_seq;
 573         __u16           frames_sent;
 574         __u16           unacked_frames;
 575         __u8            retry_count;
 576         __u16           sdu_len;
 577         struct sk_buff  *sdu;
 578         struct sk_buff  *sdu_last_frag;
 579
 580         __u16           remote_tx_win;
 581         __u8            remote_max_tx;
 582         __u16           remote_mps;
 583
 584         __u8            local_id;
 585         __u8            local_stype;
 586         __u16           local_msdu;
 587         __u32           local_sdu_itime;
 588         __u32           local_acc_lat;
 589         __u32           local_flush_to;
 590
 591         __u8            remote_id;
 592         __u8            remote_stype;
 593         __u16           remote_msdu;
 594         __u32           remote_sdu_itime;
 595         __u32           remote_acc_lat;
 596         __u32           remote_flush_to;
 597
 598         struct delayed_work     chan_timer;
 599         struct delayed_work     retrans_timer;
 600         struct delayed_work     monitor_timer;
 601         struct delayed_work     ack_timer;
 602
 603         struct sk_buff          *tx_send_head;
 604         struct sk_buff_head     tx_q;
 605         struct sk_buff_head     srej_q;
 606         struct l2cap_seq_list   srej_list;
 607         struct l2cap_seq_list   retrans_list;
 608
 609         struct list_head        list;
 610         struct list_head        global_l;
 611
 612         void                    *data;
 613         const struct l2cap_ops  *ops;
 614         struct mutex            lock;
 615 };
 616
 617 struct l2cap_ops {
 618         char                    *name;
 619
 620         struct l2cap_chan       *(*new_connection) (struct l2cap_chan *chan);
 621         int                     (*recv) (struct l2cap_chan * chan,
 622                                          struct sk_buff *skb);
 623         void                    (*teardown) (struct l2cap_chan *chan, int err);
 624         void                    (*close) (struct l2cap_chan *chan);
 625         void                    (*state_change) (struct l2cap_chan *chan,
 626                                                  int state, int err);
 627         void                    (*ready) (struct l2cap_chan *chan);
 628         void                    (*defer) (struct l2cap_chan *chan);
 629         void                    (*resume) (struct l2cap_chan *chan);
 630         void                    (*suspend) (struct l2cap_chan *chan);
 631         void                    (*set_shutdown) (struct l2cap_chan *chan);
 632         long                    (*get_sndtimeo) (struct l2cap_chan *chan);
 633         struct pid              *(*get_peer_pid) (struct l2cap_chan *chan);
 634         struct sk_buff          *(*alloc_skb) (struct l2cap_chan *chan,
 635                                                unsigned long hdr_len,
 636                                                unsigned long len, int nb);
 637         int                     (*filter) (struct l2cap_chan * chan,
 638                                            struct sk_buff *skb);
 639 };
 640
 641 struct l2cap_conn {
 642         struct hci_conn         *hcon;
 643         struct hci_chan         *hchan;
 644
 645         unsigned int            mtu;
 646
 647         __u32                   feat_mask;
 648         __u8                    remote_fixed_chan;
 649         __u8                    local_fixed_chan;
 650
 651         __u8                    info_state;
 652         __u8                    info_ident;
 653
 654         struct delayed_work     info_timer;
 655
 656         struct sk_buff          *rx_skb;
 657         __u32                   rx_len;
 658         __u8                    tx_ident;
 659         struct mutex            ident_lock;
 660
 661         struct sk_buff_head     pending_rx;
 662         struct work_struct      pending_rx_work;
 663
 664         struct delayed_work     id_addr_timer;
 665
 666         __u8                    disc_reason;
 667
 668         struct l2cap_chan       *smp;
 669
 670         struct list_head        chan_l;
 671         struct mutex            chan_lock;
 672         struct kref             ref;
 673         struct list_head        users;
 674 };
 675
 676 struct l2cap_user {
 677         struct list_head list;
 678         int (*probe) (struct l2cap_conn *conn, struct l2cap_user *user);
 679         void (*remove) (struct l2cap_conn *conn, struct l2cap_user *user);
 680 };
 681
 682 #define L2CAP_INFO_CL_MTU_REQ_SENT      0x01
 683 #define L2CAP_INFO_FEAT_MASK_REQ_SENT   0x04
 684 #define L2CAP_INFO_FEAT_MASK_REQ_DONE   0x08
 685
 686 #define L2CAP_CHAN_RAW                  1
 687 #define L2CAP_CHAN_CONN_LESS            2
 688 #define L2CAP_CHAN_CONN_ORIENTED        3
 689 #define L2CAP_CHAN_FIXED                4
 690
 691 /* ----- L2CAP socket info ----- */
 692 #define l2cap_pi(sk) ((struct l2cap_pinfo *) sk)
 693
 694 struct l2cap_rx_busy {
 695         struct list_head        list;
 696         struct sk_buff          *skb;
 697 };
 698
 699 struct l2cap_pinfo {
 700         struct bt_sock          bt;
 701         struct l2cap_chan       *chan;
 702         struct list_head        rx_busy;
 703 };
 704
 705 enum {
 706         CONF_REQ_SENT,
 707         CONF_INPUT_DONE,
 708         CONF_OUTPUT_DONE,
 709         CONF_MTU_DONE,
 710         CONF_MODE_DONE,
 711         CONF_CONNECT_PEND,
 712         CONF_RECV_NO_FCS,
 713         CONF_STATE2_DEVICE,
 714         CONF_EWS_RECV,
 715         CONF_LOC_CONF_PEND,
 716         CONF_REM_CONF_PEND,
 717         CONF_NOT_COMPLETE,
 718 };
 719
 720 #define L2CAP_CONF_MAX_CONF_REQ 2
 721 #define L2CAP_CONF_MAX_CONF_RSP 2
 722
 723 enum {
 724         CONN_SREJ_SENT,
 725         CONN_WAIT_F,
 726         CONN_SREJ_ACT,
 727         CONN_SEND_PBIT,
 728         CONN_REMOTE_BUSY,
 729         CONN_LOCAL_BUSY,
 730         CONN_REJ_ACT,
 731         CONN_SEND_FBIT,
 732         CONN_RNR_SENT,
 733 };
 734
 735 /* Definitions for flags in l2cap_chan */
 736 enum {
 737         FLAG_ROLE_SWITCH,
 738         FLAG_FORCE_ACTIVE,
 739         FLAG_FORCE_RELIABLE,
 740         FLAG_FLUSHABLE,
 741         FLAG_EXT_CTRL,
 742         FLAG_EFS_ENABLE,
 743         FLAG_DEFER_SETUP,
 744         FLAG_LE_CONN_REQ_SENT,
 745         FLAG_ECRED_CONN_REQ_SENT,
 746         FLAG_PENDING_SECURITY,
 747         FLAG_HOLD_HCI_CONN,
 748 };
 749
 750 /* Lock nesting levels for L2CAP channels. We need these because lockdep
 751  * otherwise considers all channels equal and will e.g. complain about a
 752  * connection oriented channel triggering SMP procedures or a listening
 753  * channel creating and locking a child channel.
 754  */
 755 enum {
 756         L2CAP_NESTING_SMP,
 757         L2CAP_NESTING_NORMAL,
 758         L2CAP_NESTING_PARENT,
 759 };
 760
 761 enum {
 762         L2CAP_TX_STATE_XMIT,
 763         L2CAP_TX_STATE_WAIT_F,
 764 };
 765
 766 enum {
 767         L2CAP_RX_STATE_RECV,
 768         L2CAP_RX_STATE_SREJ_SENT,
 769         L2CAP_RX_STATE_MOVE,
 770         L2CAP_RX_STATE_WAIT_P,
 771         L2CAP_RX_STATE_WAIT_F,
 772 };
 773
 774 enum {
 775         L2CAP_TXSEQ_EXPECTED,
 776         L2CAP_TXSEQ_EXPECTED_SREJ,
 777         L2CAP_TXSEQ_UNEXPECTED,
 778         L2CAP_TXSEQ_UNEXPECTED_SREJ,
 779         L2CAP_TXSEQ_DUPLICATE,
 780         L2CAP_TXSEQ_DUPLICATE_SREJ,
 781         L2CAP_TXSEQ_INVALID,
 782         L2CAP_TXSEQ_INVALID_IGNORE,
 783 };
 784
 785 enum {
 786         L2CAP_EV_DATA_REQUEST,
 787         L2CAP_EV_LOCAL_BUSY_DETECTED,
 788         L2CAP_EV_LOCAL_BUSY_CLEAR,
 789         L2CAP_EV_RECV_REQSEQ_AND_FBIT,
 790         L2CAP_EV_RECV_FBIT,
 791         L2CAP_EV_RETRANS_TO,
 792         L2CAP_EV_MONITOR_TO,
 793         L2CAP_EV_EXPLICIT_POLL,
 794         L2CAP_EV_RECV_IFRAME,
 795         L2CAP_EV_RECV_RR,
 796         L2CAP_EV_RECV_REJ,
 797         L2CAP_EV_RECV_RNR,
 798         L2CAP_EV_RECV_SREJ,
 799         L2CAP_EV_RECV_FRAME,
 800 };
 801
 802 enum {
 803         L2CAP_MOVE_ROLE_NONE,
 804         L2CAP_MOVE_ROLE_INITIATOR,
 805         L2CAP_MOVE_ROLE_RESPONDER,
 806 };
 807
 808 enum {
 809         L2CAP_MOVE_STABLE,
 810         L2CAP_MOVE_WAIT_REQ,
 811         L2CAP_MOVE_WAIT_RSP,
 812         L2CAP_MOVE_WAIT_RSP_SUCCESS,
 813         L2CAP_MOVE_WAIT_CONFIRM,
 814         L2CAP_MOVE_WAIT_CONFIRM_RSP,
 815         L2CAP_MOVE_WAIT_LOGICAL_COMP,
 816         L2CAP_MOVE_WAIT_LOGICAL_CFM,
 817         L2CAP_MOVE_WAIT_LOCAL_BUSY,
 818         L2CAP_MOVE_WAIT_PREPARE,
 819 };
 820
 821 void l2cap_chan_hold(struct l2cap_chan *c);
 822 struct l2cap_chan *l2cap_chan_hold_unless_zero(struct l2cap_chan *c);
 823 void l2cap_chan_put(struct l2cap_chan *c);
 824
 825 static inline void l2cap_chan_lock(struct l2cap_chan *chan)
 826 {
 827         mutex_lock_nested(&chan->lock, atomic_read(&chan->nesting));
 828 }
 829
 830 static inline void l2cap_chan_unlock(struct l2cap_chan *chan)
 831 {
 832         mutex_unlock(&chan->lock);
 833 }
 834
 835 static inline void l2cap_set_timer(struct l2cap_chan *chan,
 836                                    struct delayed_work *work, long timeout)
 837 {
 838         BT_DBG("chan %p state %s timeout %ld", chan,
 839                state_to_string(chan->state), timeout);
 840
 841         /* If delayed work cancelled do not hold(chan)
 842            since it is already done with previous set_timer */
 843         if (!cancel_delayed_work(work))
 844                 l2cap_chan_hold(chan);
 845
 846         schedule_delayed_work(work, timeout);
 847 }
 848
 849 static inline bool l2cap_clear_timer(struct l2cap_chan *chan,
 850                                      struct delayed_work *work)
 851 {
 852         bool ret;
 853
 854         /* put(chan) if delayed work cancelled otherwise it
 855            is done in delayed work function */
 856         ret = cancel_delayed_work(work);
 857         if (ret)
 858                 l2cap_chan_put(chan);
 859
 860         return ret;
 861 }
 862
 863 #define __set_chan_timer(c, t) l2cap_set_timer(c, &c->chan_timer, (t))
 864 #define __clear_chan_timer(c) l2cap_clear_timer(c, &c->chan_timer)
 865 #define __clear_retrans_timer(c) l2cap_clear_timer(c, &c->retrans_timer)
 866 #define __clear_monitor_timer(c) l2cap_clear_timer(c, &c->monitor_timer)
 867 #define __set_ack_timer(c) l2cap_set_timer(c, &chan->ack_timer, \
 868                 msecs_to_jiffies(L2CAP_DEFAULT_ACK_TO));
 869 #define __clear_ack_timer(c) l2cap_clear_timer(c, &c->ack_timer)
 870
 871 static inline int __seq_offset(struct l2cap_chan *chan, __u16 seq1, __u16 seq2)
 872 {
 873         if (seq1 >= seq2)
 874                 return seq1 - seq2;
 875         else
 876                 return chan->tx_win_max + 1 - seq2 + seq1;
 877 }
 878
 879 static inline __u16 __next_seq(struct l2cap_chan *chan, __u16 seq)
 880 {
 881         return (seq + 1) % (chan->tx_win_max + 1);
 882 }
 883
 884 static inline struct l2cap_chan *l2cap_chan_no_new_connection(struct l2cap_chan *chan)
 885 {
 886         return NULL;
 887 }
 888
 889 static inline int l2cap_chan_no_recv(struct l2cap_chan *chan, struct sk_buff *skb)
 890 {
 891         return -ENOSYS;
 892 }
 893
 894 static inline struct sk_buff *l2cap_chan_no_alloc_skb(struct l2cap_chan *chan,
 895                                                       unsigned long hdr_len,
 896                                                       unsigned long len, int nb)
 897 {
 898         return ERR_PTR(-ENOSYS);
 899 }
 900
 901 static inline void l2cap_chan_no_teardown(struct l2cap_chan *chan, int err)
 902 {
 903 }
 904
 905 static inline void l2cap_chan_no_close(struct l2cap_chan *chan)
 906 {
 907 }
 908
 909 static inline void l2cap_chan_no_ready(struct l2cap_chan *chan)
 910 {
 911 }
 912
 913 static inline void l2cap_chan_no_state_change(struct l2cap_chan *chan,
 914                                               int state, int err)
 915 {
 916 }
 917
 918 static inline void l2cap_chan_no_defer(struct l2cap_chan *chan)
 919 {
 920 }
 921
 922 static inline void l2cap_chan_no_suspend(struct l2cap_chan *chan)
 923 {
 924 }
 925
 926 static inline void l2cap_chan_no_resume(struct l2cap_chan *chan)
 927 {
 928 }
 929
 930 static inline void l2cap_chan_no_set_shutdown(struct l2cap_chan *chan)
 931 {
 932 }
 933
 934 static inline long l2cap_chan_no_get_sndtimeo(struct l2cap_chan *chan)
 935 {
 936         return 0;
 937 }
 938
 939 extern bool disable_ertm;
 940 extern bool enable_ecred;
 941
 942 int l2cap_init_sockets(void);
 943 void l2cap_cleanup_sockets(void);
 944 bool l2cap_is_socket(struct socket *sock);
 945
 946 void __l2cap_le_connect_rsp_defer(struct l2cap_chan *chan);
 947 void __l2cap_ecred_conn_rsp_defer(struct l2cap_chan *chan);
 948 void __l2cap_connect_rsp_defer(struct l2cap_chan *chan);
 949
 950 int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm);
 951 int l2cap_add_scid(struct l2cap_chan *chan,  __u16 scid);
 952
 953 struct l2cap_chan *l2cap_chan_create(void);
 954 void l2cap_chan_close(struct l2cap_chan *chan, int reason);
 955 int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid,
 956                        bdaddr_t *dst, u8 dst_type, u16 timeout);
 957 int l2cap_chan_reconfigure(struct l2cap_chan *chan, __u16 mtu);
 958 int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len);
 959 void l2cap_chan_busy(struct l2cap_chan *chan, int busy);
 960 void l2cap_chan_rx_avail(struct l2cap_chan *chan, ssize_t rx_avail);
 961 int l2cap_chan_check_security(struct l2cap_chan *chan, bool initiator);
 962 void l2cap_chan_set_defaults(struct l2cap_chan *chan);
 963 int l2cap_ertm_init(struct l2cap_chan *chan);
 964 void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan);
 965 void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan);
 966 typedef void (*l2cap_chan_func_t)(struct l2cap_chan *chan, void *data);
 967 void l2cap_chan_list(struct l2cap_conn *conn, l2cap_chan_func_t func,
 968                      void *data);
 969 void l2cap_chan_del(struct l2cap_chan *chan, int err);
 970 void l2cap_send_conn_req(struct l2cap_chan *chan);
 971
 972 struct l2cap_conn *l2cap_conn_get(struct l2cap_conn *conn);
 973 void l2cap_conn_put(struct l2cap_conn *conn);
 974
 975 int l2cap_register_user(struct l2cap_conn *conn, struct l2cap_user *user);
 976 void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user);
 977
 978 #endif /* __L2CAP_H */