Lines Matching +full:timeout +full:- +full:pwr +full:- +full:ms
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>
53 return sock && sock->ops == &l2cap_sock_ops;
61 return -EINVAL;
63 /* Restrict usage of well-known PSMs */
65 return -EACCES;
74 return -EINVAL;
78 return -EACCES;
85 struct sock *sk = sock->sk;
86 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
93 addr->sa_family != AF_BLUETOOTH)
94 return -EINVAL;
101 return -EINVAL;
104 return -EINVAL;
110 return -EINVAL;
115 if (sk->sk_state != BT_OPEN) {
116 err = -EBADFD;
132 bacpy(&chan->src, &la.l2_bdaddr);
133 chan->src_type = la.l2_bdaddr_type;
143 switch (chan->chan_type) {
146 chan->sec_level = BT_SECURITY_SDP;
151 chan->sec_level = BT_SECURITY_SDP;
154 chan->sec_level = BT_SECURITY_SDP;
162 set_bit(FLAG_HOLD_HCI_CONN, &chan->flags);
169 if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
170 chan->mode != L2CAP_MODE_EXT_FLOWCTL)
171 chan->mode = L2CAP_MODE_LE_FLOWCTL;
173 chan->state = BT_BOUND;
174 sk->sk_state = BT_BOUND;
184 struct sock *sk = sock->sk;
185 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
197 return -EINVAL;
200 addr->sa_family != AF_BLUETOOTH)
201 return -EINVAL;
208 return -EINVAL;
211 return -EINVAL;
214 * conflicts with the address given to connect(). If chan->src
216 * chan->src_type and la.l2_bdaddr_type do not need to match.
218 if (chan->src_type == BDADDR_BREDR && bacmp(&chan->src, BDADDR_ANY) &&
226 if (chan->scid != L2CAP_CID_ATT ||
228 return -EINVAL;
236 chan->src_type = BDADDR_LE_PUBLIC;
239 if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)
240 return -EINVAL;
246 return -EINVAL;
252 if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
253 chan->mode != L2CAP_MODE_EXT_FLOWCTL)
254 chan->mode = L2CAP_MODE_LE_FLOWCTL;
258 READ_ONCE(sk->sk_sndtimeo));
274 struct sock *sk = sock->sk;
275 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
282 if (sk->sk_state != BT_BOUND) {
283 err = -EBADFD;
287 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
288 err = -EINVAL;
292 switch (chan->mode) {
298 err = -EOPNOTSUPP;
308 err = -EOPNOTSUPP;
312 sk->sk_max_ack_backlog = backlog;
313 sk->sk_ack_backlog = 0;
319 atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
321 chan->state = BT_LISTEN;
322 sk->sk_state = BT_LISTEN;
333 struct sock *sk = sock->sk, *nsk;
339 timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK);
343 /* Wait for an incoming connection. (wake-one). */
346 if (sk->sk_state != BT_LISTEN) {
347 err = -EBADFD;
356 err = -EAGAIN;
376 newsock->state = SS_CONNECTED;
389 struct sock *sk = sock->sk;
390 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
394 if (peer && sk->sk_state != BT_CONNECTED &&
395 sk->sk_state != BT_CONNECT && sk->sk_state != BT_CONNECT2 &&
396 sk->sk_state != BT_CONFIG)
397 return -ENOTCONN;
400 addr->sa_family = AF_BLUETOOTH;
402 la->l2_psm = chan->psm;
405 bacpy(&la->l2_bdaddr, &chan->dst);
406 la->l2_cid = cpu_to_le16(chan->dcid);
407 la->l2_bdaddr_type = chan->dst_type;
409 bacpy(&la->l2_bdaddr, &chan->src);
410 la->l2_cid = cpu_to_le16(chan->scid);
411 la->l2_bdaddr_type = chan->src_type;
419 switch (chan->mode) {
432 return -EINVAL;
438 struct sock *sk = sock->sk;
439 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
449 return -EFAULT;
459 if (bdaddr_type_is_le(chan->src_type) &&
460 chan->scid != L2CAP_CID_ATT) {
461 err = -EINVAL;
466 switch (chan->mode) {
472 err = -EINVAL;
480 opts.imtu = chan->imtu;
481 opts.omtu = chan->omtu;
482 opts.flush_to = chan->flush_to;
483 opts.mode = chan->mode;
484 opts.fcs = chan->fcs;
485 opts.max_tx = chan->max_tx;
486 opts.txwin_size = chan->tx_win;
488 BT_DBG("mode 0x%2.2x", chan->mode);
492 err = -EFAULT;
497 switch (chan->sec_level) {
517 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
520 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
524 err = -EFAULT;
529 if (sk->sk_state != BT_CONNECTED &&
530 !(sk->sk_state == BT_CONNECT2 &&
531 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
532 err = -ENOTCONN;
537 cinfo.hci_handle = chan->conn->hcon->handle;
538 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
542 err = -EFAULT;
547 err = -ENOPROTOOPT;
558 struct sock *sk = sock->sk;
559 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
561 struct bt_power pwr;
571 return -ENOPROTOOPT;
574 return -EFAULT;
580 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
581 chan->chan_type != L2CAP_CHAN_FIXED &&
582 chan->chan_type != L2CAP_CHAN_RAW) {
583 err = -EINVAL;
588 if (chan->conn) {
589 sec.level = chan->conn->hcon->sec_level;
591 if (sk->sk_state == BT_CONNECTED)
592 sec.key_size = chan->conn->hcon->enc_key_size;
594 sec.level = chan->sec_level;
599 err = -EFAULT;
604 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
605 err = -EINVAL;
609 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
611 err = -EFAULT;
616 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
618 err = -EFAULT;
623 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
624 && sk->sk_type != SOCK_RAW) {
625 err = -EINVAL;
629 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
631 len = min_t(unsigned int, len, sizeof(pwr));
632 if (copy_to_user(optval, (char *) &pwr, len))
633 err = -EFAULT;
638 if (put_user(chan->chan_policy, (u32 __user *) optval))
639 err = -EFAULT;
643 if (!bdaddr_type_is_le(chan->src_type)) {
644 err = -EINVAL;
648 if (sk->sk_state != BT_CONNECTED) {
649 err = -ENOTCONN;
653 if (put_user(chan->omtu, (u16 __user *) optval))
654 err = -EFAULT;
658 if (!bdaddr_type_is_le(chan->src_type)) {
659 err = -EINVAL;
663 if (put_user(chan->imtu, (u16 __user *) optval))
664 err = -EFAULT;
668 if (sk->sk_state != BT_CONNECTED) {
669 err = -ENOTCONN;
673 phys = hci_conn_get_phy(chan->conn->hcon);
676 err = -EFAULT;
681 err = -ENOPROTOOPT;
685 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
686 err = -EINVAL;
697 err = -EFAULT;
701 err = -ENOPROTOOPT;
711 switch (chan->scid) {
728 struct sock *sk = sock->sk;
729 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
740 if (bdaddr_type_is_le(chan->src_type)) {
741 err = -EINVAL;
745 if (sk->sk_state == BT_CONNECTED) {
746 err = -EINVAL;
750 opts.imtu = chan->imtu;
751 opts.omtu = chan->omtu;
752 opts.flush_to = chan->flush_to;
753 opts.mode = chan->mode;
754 opts.fcs = chan->fcs;
755 opts.max_tx = chan->max_tx;
756 opts.txwin_size = chan->tx_win;
764 err = -EINVAL;
769 err = -EINVAL;
776 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
784 err = -EINVAL;
791 chan->mode = opts.mode;
793 BT_DBG("mode 0x%2.2x", chan->mode);
795 chan->imtu = opts.imtu;
796 chan->omtu = opts.omtu;
797 chan->fcs = opts.fcs;
798 chan->max_tx = opts.max_tx;
799 chan->tx_win = opts.txwin_size;
800 chan->flush_to = opts.flush_to;
809 err = -EINVAL;
814 chan->sec_level = BT_SECURITY_LOW;
816 chan->sec_level = BT_SECURITY_MEDIUM;
818 chan->sec_level = BT_SECURITY_HIGH;
821 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
823 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
826 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
828 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
832 err = -ENOPROTOOPT;
844 if (bdaddr_type_is_le(chan->src_type))
845 return -EINVAL;
847 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
850 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
851 return -EINVAL;
855 if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
856 return -EINVAL;
860 if (!bdaddr_type_is_le(chan->src_type))
861 return -EINVAL;
866 if (!bdaddr_type_is_le(chan->src_type))
867 return -EINVAL;
871 return -EINVAL;
874 chan->mode = mode;
882 struct sock *sk = sock->sk;
883 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
885 struct bt_power pwr;
898 return -ENOPROTOOPT;
904 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
905 chan->chan_type != L2CAP_CHAN_FIXED &&
906 chan->chan_type != L2CAP_CHAN_RAW) {
907 err = -EINVAL;
919 err = -EINVAL;
923 chan->sec_level = sec.level;
925 if (!chan->conn)
928 conn = chan->conn;
931 if (chan->scid == L2CAP_CID_ATT) {
932 if (smp_conn_security(conn->hcon, sec.level)) {
933 err = -EINVAL;
937 set_bit(FLAG_PENDING_SECURITY, &chan->flags);
938 sk->sk_state = BT_CONFIG;
939 chan->state = BT_CONFIG;
942 } else if ((sk->sk_state == BT_CONNECT2 &&
943 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
944 sk->sk_state == BT_CONNECTED) {
946 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
948 sk->sk_state_change(sk);
950 err = -EINVAL;
955 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
956 err = -EINVAL;
965 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
966 set_bit(FLAG_DEFER_SETUP, &chan->flags);
968 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
969 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
979 err = -EINVAL;
984 conn = chan->conn;
987 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
988 err = -EINVAL;
994 set_bit(FLAG_FLUSHABLE, &chan->flags);
996 clear_bit(FLAG_FLUSHABLE, &chan->flags);
1000 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
1001 chan->chan_type != L2CAP_CHAN_RAW) {
1002 err = -EINVAL;
1006 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
1008 err = copy_safe_from_sockptr(&pwr, sizeof(pwr), optval, optlen);
1012 if (pwr.force_active)
1013 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1015 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
1023 err = -EOPNOTSUPP;
1027 if (!bdaddr_type_is_le(chan->src_type)) {
1028 err = -EINVAL;
1035 err = -EPERM;
1039 if (!bdaddr_type_is_le(chan->src_type)) {
1040 err = -EINVAL;
1044 if (chan->mode == L2CAP_MODE_LE_FLOWCTL &&
1045 sk->sk_state == BT_CONNECTED) {
1046 err = -EISCONN;
1054 if (chan->mode == L2CAP_MODE_EXT_FLOWCTL &&
1055 sk->sk_state == BT_CONNECTED)
1058 chan->imtu = mtu;
1064 err = -ENOPROTOOPT;
1068 BT_DBG("sk->sk_state %u", sk->sk_state);
1070 if (sk->sk_state != BT_BOUND) {
1071 err = -EINVAL;
1075 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1076 err = -EINVAL;
1091 BT_DBG("mode 0x%2.2x", chan->mode);
1096 err = -ENOPROTOOPT;
1107 struct sock *sk = sock->sk;
1108 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1118 if (msg->msg_flags & MSG_OOB)
1119 return -EOPNOTSUPP;
1121 if (sk->sk_state != BT_CONNECTED)
1122 return -ENOTCONN;
1126 if (msg->msg_controllen) {
1133 err = bt_sock_wait_ready(sk, msg->msg_flags);
1147 struct sock *sk = chan->data;
1148 ssize_t avail = sk->sk_rcvbuf - atomic_read(&sk->sk_rmem_alloc);
1156 if (!chan->mps) {
1157 l2cap_chan_rx_avail(chan, -1);
1163 * at least one full packet if receive space is non-zero.
1165 expected_skbs = DIV_ROUND_UP(avail, chan->mps);
1168 l2cap_chan_rx_avail(chan, avail - skb_overhead);
1170 l2cap_chan_rx_avail(chan, -1);
1176 struct sock *sk = sock->sk;
1186 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
1187 &bt_sk(sk)->flags)) {
1188 if (pi->chan->mode == L2CAP_MODE_EXT_FLOWCTL) {
1189 sk->sk_state = BT_CONNECTED;
1190 pi->chan->state = BT_CONNECTED;
1191 __l2cap_ecred_conn_rsp_defer(pi->chan);
1192 } else if (bdaddr_type_is_le(pi->chan->src_type)) {
1193 sk->sk_state = BT_CONNECTED;
1194 pi->chan->state = BT_CONNECTED;
1195 __l2cap_le_connect_rsp_defer(pi->chan);
1197 sk->sk_state = BT_CONFIG;
1198 pi->chan->state = BT_CONFIG;
1199 __l2cap_connect_rsp_defer(pi->chan);
1208 if (sock->type == SOCK_STREAM)
1213 if (pi->chan->mode != L2CAP_MODE_ERTM &&
1214 pi->chan->mode != L2CAP_MODE_LE_FLOWCTL &&
1215 pi->chan->mode != L2CAP_MODE_EXT_FLOWCTL)
1220 l2cap_publish_rx_avail(pi->chan);
1223 while (!list_empty(&pi->rx_busy)) {
1225 list_first_entry(&pi->rx_busy,
1228 if (__sock_queue_rcv_skb(sk, rx_busy->skb) < 0)
1230 list_del(&rx_busy->list);
1238 if (test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state) &&
1239 atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1240 l2cap_chan_busy(pi->chan, 0);
1252 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1255 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
1260 l2cap_pi(sk)->chan->data = NULL;
1263 l2cap_chan_put(l2cap_pi(sk)->chan);
1273 /* Timeout to prevent infinite loop */
1274 unsigned long timeout = jiffies + L2CAP_WAIT_ACK_TIMEOUT;
1279 BT_DBG("Waiting for %d ACKs, timeout %04d ms",
1280 chan->unacked_frames, time_after(jiffies, timeout) ? 0 :
1281 jiffies_to_msecs(timeout - jiffies));
1300 if (time_after(jiffies, timeout)) {
1301 err = -ENOLINK;
1305 } while (chan->unacked_frames > 0 &&
1306 chan->state == BT_CONNECTED);
1315 struct sock *sk = sock->sk;
1323 * SHUT_RD (0) --> RCV_SHUTDOWN (1)
1324 * SHUT_WR (1) --> SEND_SHUTDOWN (2)
1325 * SHUT_RDWR (2) --> SHUTDOWN_MASK (3)
1334 if ((sk->sk_shutdown & how) == how)
1343 chan = l2cap_chan_hold_unless_zero(l2cap_pi(sk)->chan);
1347 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1349 if (chan->mode == L2CAP_MODE_ERTM &&
1350 chan->unacked_frames > 0 &&
1351 chan->state == BT_CONNECTED) {
1358 if ((sk->sk_shutdown & how) == how)
1365 if ((how & RCV_SHUTDOWN) && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1366 sk->sk_shutdown |= RCV_SHUTDOWN;
1367 if ((sk->sk_shutdown & how) == how)
1371 sk->sk_shutdown |= SEND_SHUTDOWN;
1376 conn = l2cap_conn_hold_unless_zero(chan->conn);
1381 mutex_lock(&conn->lock);
1388 mutex_unlock(&conn->lock);
1394 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1395 !(current->flags & PF_EXITING))
1397 sk->sk_lingertime);
1404 if (!err && sk->sk_err)
1405 err = -sk->sk_err;
1416 struct sock *sk = sock->sk;
1432 chan = l2cap_pi(sk)->chan;
1451 state_to_string(parent->sk_state));
1455 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1458 state_to_string(chan->state));
1474 struct sock *sk, *parent = chan->data;
1480 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1500 return l2cap_pi(sk)->chan;
1509 sk = chan->data;
1511 return -ENXIO;
1515 if (chan->mode == L2CAP_MODE_ERTM && !list_empty(&pi->rx_busy)) {
1516 err = -ENOMEM;
1520 if (chan->mode != L2CAP_MODE_ERTM &&
1521 chan->mode != L2CAP_MODE_STREAMING &&
1522 chan->mode != L2CAP_MODE_LE_FLOWCTL &&
1523 chan->mode != L2CAP_MODE_EXT_FLOWCTL) {
1546 (chan->mode == L2CAP_MODE_ERTM ||
1547 chan->mode == L2CAP_MODE_LE_FLOWCTL ||
1548 chan->mode == L2CAP_MODE_EXT_FLOWCTL)) {
1552 err = -ENOMEM;
1555 rx_busy->skb = skb;
1556 list_add_tail(&rx_busy->list, &pi->rx_busy);
1569 struct sock *sk = chan->data;
1579 struct sock *sk = chan->data;
1585 BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
1594 lock_sock_nested(sk, atomic_read(&chan->nesting));
1596 parent = bt_sk(sk)->parent;
1598 switch (chan->state) {
1605 sk->sk_state = BT_CLOSED;
1606 chan->state = BT_CLOSED;
1610 sk->sk_state = BT_CLOSED;
1611 chan->state = BT_CLOSED;
1613 sk->sk_err = err;
1617 parent->sk_data_ready(parent);
1619 sk->sk_state_change(sk);
1634 struct sock *sk = chan->data;
1636 sk->sk_state = state;
1639 sk->sk_err = err;
1646 struct sock *sk = chan->data;
1660 if (chan->state != BT_CONNECTED) {
1662 return ERR_PTR(-ENOTCONN);
1665 skb->priority = READ_ONCE(sk->sk_priority);
1667 bt_cb(skb)->l2cap.chan = chan;
1674 struct sock *sk = chan->data;
1679 parent = bt_sk(sk)->parent;
1683 sk->sk_state = BT_CONNECTED;
1684 sk->sk_state_change(sk);
1687 parent->sk_data_ready(parent);
1694 struct sock *parent, *sk = chan->data;
1698 parent = bt_sk(sk)->parent;
1700 parent->sk_data_ready(parent);
1707 struct sock *sk = chan->data;
1712 if (test_and_clear_bit(FLAG_PENDING_SECURITY, &chan->flags)) {
1713 sk->sk_state = BT_CONNECTED;
1714 chan->state = BT_CONNECTED;
1717 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1718 sk->sk_state_change(sk);
1723 struct sock *sk = chan->data;
1726 sk->sk_shutdown = SHUTDOWN_MASK;
1732 struct sock *sk = chan->data;
1734 return READ_ONCE(sk->sk_sndtimeo);
1739 struct sock *sk = chan->data;
1741 return sk->sk_peer_pid;
1746 struct sock *sk = chan->data;
1748 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1749 sk->sk_state_change(sk);
1754 struct sock *sk = chan->data;
1756 switch (chan->mode) {
1789 if (l2cap_pi(sk)->chan) {
1790 l2cap_pi(sk)->chan->data = NULL;
1791 l2cap_chan_put(l2cap_pi(sk)->chan);
1794 list_for_each_entry_safe(rx_busy, next, &l2cap_pi(sk)->rx_busy, list) {
1795 kfree_skb(rx_busy->skb);
1796 list_del(&rx_busy->list);
1800 skb_queue_purge(&sk->sk_receive_queue);
1801 skb_queue_purge(&sk->sk_write_queue);
1810 la->l2_family = AF_BLUETOOTH;
1811 la->l2_psm = bt_cb(skb)->l2cap.psm;
1812 bacpy(&la->l2_bdaddr, &bt_cb(skb)->l2cap.bdaddr);
1819 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1824 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1826 sk->sk_type = parent->sk_type;
1827 bt_sk(sk)->flags = bt_sk(parent)->flags;
1829 chan->chan_type = pchan->chan_type;
1830 chan->imtu = pchan->imtu;
1831 chan->omtu = pchan->omtu;
1832 chan->conf_state = pchan->conf_state;
1833 chan->mode = pchan->mode;
1834 chan->fcs = pchan->fcs;
1835 chan->max_tx = pchan->max_tx;
1836 chan->tx_win = pchan->tx_win;
1837 chan->tx_win_max = pchan->tx_win_max;
1838 chan->sec_level = pchan->sec_level;
1839 chan->flags = pchan->flags;
1840 chan->tx_credits = pchan->tx_credits;
1841 chan->rx_credits = pchan->rx_credits;
1843 if (chan->chan_type == L2CAP_CHAN_FIXED) {
1844 chan->scid = pchan->scid;
1845 chan->dcid = pchan->scid;
1850 switch (sk->sk_type) {
1852 chan->chan_type = L2CAP_CHAN_RAW;
1855 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1856 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
1860 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1864 chan->imtu = L2CAP_DEFAULT_MTU;
1865 chan->omtu = 0;
1866 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1867 chan->mode = L2CAP_MODE_ERTM;
1868 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1870 chan->mode = L2CAP_MODE_BASIC;
1877 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1879 chan->data = sk;
1880 chan->ops = &l2cap_chan_ops;
1901 sk->sk_destruct = l2cap_sock_destruct;
1902 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1904 INIT_LIST_HEAD(&l2cap_pi(sk)->rx_busy);
1910 sock->sk = NULL;
1916 l2cap_pi(sk)->chan = chan;
1928 sock->state = SS_UNCONNECTED;
1930 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1931 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1932 return -ESOCKTNOSUPPORT;
1934 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1935 return -EPERM;
1937 sock->ops = &l2cap_sock_ops;
1941 return -ENOMEM;