Bluetooth: Use bit operations on conn_state

Instead of setting bits manually we use set_bit, test_bit, etc.
Also remove L2CAP_ prefix from macros.

Signed-off-by: Gustavo F. Padovan <padovan@profusion.mobi>

diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h
index 4ab1b27996bcc4f5d50cb8f9e939298211d4a989..9c18e555b6ed0c302552f2676f36a04f7ddc5389 100644 (file)
--- a/include/net/bluetooth/l2cap.h
+++ b/include/net/bluetooth/l2cap.h
@@ -325,7 +325,7 @@ struct l2cap_chan {
        __u16           mps;
 
        unsigned long   conf_state;
-       __u16           conn_state;
+       unsigned long   conn_state;
 
        __u8            next_tx_seq;
        __u8            expected_ack_seq;
@@ -438,17 +438,19 @@ enum {
 #define L2CAP_CONF_MAX_CONF_REQ 2
 #define L2CAP_CONF_MAX_CONF_RSP 2
 
-#define L2CAP_CONN_SAR_SDU         0x0001
-#define L2CAP_CONN_SREJ_SENT       0x0002
-#define L2CAP_CONN_WAIT_F          0x0004
-#define L2CAP_CONN_SREJ_ACT        0x0008
-#define L2CAP_CONN_SEND_PBIT       0x0010
-#define L2CAP_CONN_REMOTE_BUSY     0x0020
-#define L2CAP_CONN_LOCAL_BUSY      0x0040
-#define L2CAP_CONN_REJ_ACT         0x0080
-#define L2CAP_CONN_SEND_FBIT       0x0100
-#define L2CAP_CONN_RNR_SENT        0x0200
-#define L2CAP_CONN_SAR_RETRY       0x0400
+enum {
+       CONN_SAR_SDU,
+       CONN_SREJ_SENT,
+       CONN_WAIT_F,
+       CONN_SREJ_ACT,
+       CONN_SEND_PBIT,
+       CONN_REMOTE_BUSY,
+       CONN_LOCAL_BUSY,
+       CONN_REJ_ACT,
+       CONN_SEND_FBIT,
+       CONN_RNR_SENT,
+       CONN_SAR_RETRY,
+};
 
 #define __set_chan_timer(c, t) l2cap_set_timer(c, &c->chan_timer, (t))
 #define __clear_chan_timer(c) l2cap_clear_timer(c, &c->chan_timer)

diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c
index b4e927eb174eba5964d14630b2e73994973a6377..25f31f4c7d0824b7a205212616b2014232b134fd 100644 (file)
--- a/net/bluetooth/l2cap_core.c
+++ b/net/bluetooth/l2cap_core.c
@@ -584,15 +584,11 @@ static inline void l2cap_send_sframe(struct l2cap_chan *chan, u16 control)
        count = min_t(unsigned int, conn->mtu, hlen);
        control |= L2CAP_CTRL_FRAME_TYPE;
 
-       if (chan->conn_state & L2CAP_CONN_SEND_FBIT) {
+       if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
                control |= L2CAP_CTRL_FINAL;
-               chan->conn_state &= ~L2CAP_CONN_SEND_FBIT;
-       }
 
-       if (chan->conn_state & L2CAP_CONN_SEND_PBIT) {
+       if (test_and_clear_bit(CONN_SEND_PBIT, &chan->conn_state))
                control |= L2CAP_CTRL_POLL;
-               chan->conn_state &= ~L2CAP_CONN_SEND_PBIT;
-       }
 
        skb = bt_skb_alloc(count, GFP_ATOMIC);
        if (!skb)
@@ -620,9 +616,9 @@ static inline void l2cap_send_sframe(struct l2cap_chan *chan, u16 control)
 
 static inline void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, u16 control)
 {
-       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
                control |= L2CAP_SUPER_RCV_NOT_READY;
-               chan->conn_state |= L2CAP_CONN_RNR_SENT;
+               set_bit(CONN_RNR_SENT, &chan->conn_state);
        } else
                control |= L2CAP_SUPER_RCV_READY;
 
@@ -1223,7 +1219,7 @@ static void l2cap_retrans_timeout(unsigned long arg)
        chan->retry_count = 1;
        __set_monitor_timer(chan);
 
-       chan->conn_state |= L2CAP_CONN_WAIT_F;
+       set_bit(CONN_WAIT_F, &chan->conn_state);
 
        l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_POLL);
        bh_unlock_sock(sk);
@@ -1314,10 +1310,8 @@ static void l2cap_retransmit_one_frame(struct l2cap_chan *chan, u8 tx_seq)
        control = get_unaligned_le16(tx_skb->data + L2CAP_HDR_SIZE);
        control &= L2CAP_CTRL_SAR;
 
-       if (chan->conn_state & L2CAP_CONN_SEND_FBIT) {
+       if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
                control |= L2CAP_CTRL_FINAL;
-               chan->conn_state &= ~L2CAP_CONN_SEND_FBIT;
-       }
 
        control |= (chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
                        | (tx_seq << L2CAP_CTRL_TXSEQ_SHIFT);
@@ -1356,10 +1350,9 @@ int l2cap_ertm_send(struct l2cap_chan *chan)
                control = get_unaligned_le16(tx_skb->data + L2CAP_HDR_SIZE);
                control &= L2CAP_CTRL_SAR;
 
-               if (chan->conn_state & L2CAP_CONN_SEND_FBIT) {
+               if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
                        control |= L2CAP_CTRL_FINAL;
-                       chan->conn_state &= ~L2CAP_CONN_SEND_FBIT;
-               }
+
                control |= (chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
                                | (chan->next_tx_seq << L2CAP_CTRL_TXSEQ_SHIFT);
                put_unaligned_le16(control, tx_skb->data + L2CAP_HDR_SIZE);
@@ -1411,9 +1404,9 @@ static void l2cap_send_ack(struct l2cap_chan *chan)
 
        control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
 
-       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
                control |= L2CAP_SUPER_RCV_NOT_READY;
-               chan->conn_state |= L2CAP_CONN_RNR_SENT;
+               set_bit(CONN_RNR_SENT, &chan->conn_state);
                l2cap_send_sframe(chan, control);
                return;
        }
@@ -1680,8 +1673,8 @@ int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
                        break;
                }
 
-               if ((chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
-                               (chan->conn_state & L2CAP_CONN_WAIT_F)) {
+               if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state) &&
+                               test_bit(CONN_WAIT_F, &chan->conn_state)) {
                        err = len;
                        break;
                }
@@ -3071,18 +3064,18 @@ static inline void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan)
 
        control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
 
-       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
                control |= L2CAP_SUPER_RCV_NOT_READY;
                l2cap_send_sframe(chan, control);
-               chan->conn_state |= L2CAP_CONN_RNR_SENT;
+               set_bit(CONN_RNR_SENT, &chan->conn_state);
        }
 
-       if (chan->conn_state & L2CAP_CONN_REMOTE_BUSY)
+       if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
                l2cap_retransmit_frames(chan);
 
        l2cap_ertm_send(chan);
 
-       if (!(chan->conn_state & L2CAP_CONN_LOCAL_BUSY) &&
+       if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) &&
                        chan->frames_sent == 0) {
                control |= L2CAP_SUPER_RCV_READY;
                l2cap_send_sframe(chan, control);
@@ -3138,13 +3131,13 @@ static int l2cap_ertm_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *sk
 
        switch (control & L2CAP_CTRL_SAR) {
        case L2CAP_SDU_UNSEGMENTED:
-               if (chan->conn_state & L2CAP_CONN_SAR_SDU)
+               if (test_bit(CONN_SAR_SDU, &chan->conn_state))
                        goto drop;
 
                return chan->ops->recv(chan->data, skb);
 
        case L2CAP_SDU_START:
-               if (chan->conn_state & L2CAP_CONN_SAR_SDU)
+               if (test_bit(CONN_SAR_SDU, &chan->conn_state))
                        goto drop;
 
                chan->sdu_len = get_unaligned_le16(skb->data);
@@ -3163,12 +3156,12 @@ static int l2cap_ertm_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *sk
 
                memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
-               chan->conn_state |= L2CAP_CONN_SAR_SDU;
+               set_bit(CONN_SAR_SDU, &chan->conn_state);
                chan->partial_sdu_len = skb->len;
                break;
 
        case L2CAP_SDU_CONTINUE:
-               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
                        goto disconnect;
 
                if (!chan->sdu)
@@ -3183,13 +3176,13 @@ static int l2cap_ertm_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *sk
                break;
 
        case L2CAP_SDU_END:
-               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
                        goto disconnect;
 
                if (!chan->sdu)
                        goto disconnect;
 
-               if (!(chan->conn_state & L2CAP_CONN_SAR_RETRY)) {
+               if (!test_bit(CONN_SAR_RETRY, &chan->conn_state)) {
                        chan->partial_sdu_len += skb->len;
 
                        if (chan->partial_sdu_len > chan->imtu)
@@ -3203,19 +3196,19 @@ static int l2cap_ertm_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *sk
 
                _skb = skb_clone(chan->sdu, GFP_ATOMIC);
                if (!_skb) {
-                       chan->conn_state |= L2CAP_CONN_SAR_RETRY;
+                       set_bit(CONN_SAR_RETRY, &chan->conn_state);
                        return -ENOMEM;
                }
 
                err = chan->ops->recv(chan->data, _skb);
                if (err < 0) {
                        kfree_skb(_skb);
-                       chan->conn_state |= L2CAP_CONN_SAR_RETRY;
+                       set_bit(CONN_SAR_RETRY, &chan->conn_state);
                        return err;
                }
 
-               chan->conn_state &= ~L2CAP_CONN_SAR_RETRY;
-               chan->conn_state &= ~L2CAP_CONN_SAR_SDU;
+               clear_bit(CONN_SAR_RETRY, &chan->conn_state);
+               clear_bit(CONN_SAR_SDU, &chan->conn_state);
 
                kfree_skb(chan->sdu);
                break;
@@ -3251,7 +3244,7 @@ static int l2cap_try_push_rx_skb(struct l2cap_chan *chan)
                chan->buffer_seq = (chan->buffer_seq + 1) % 64;
        }
 
-       if (!(chan->conn_state & L2CAP_CONN_RNR_SENT))
+       if (!test_bit(CONN_RNR_SENT, &chan->conn_state))
                goto done;
 
        control = chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
@@ -3262,11 +3255,11 @@ static int l2cap_try_push_rx_skb(struct l2cap_chan *chan)
        __clear_retrans_timer(chan);
        __set_monitor_timer(chan);
 
-       chan->conn_state |= L2CAP_CONN_WAIT_F;
+       set_bit(CONN_WAIT_F, &chan->conn_state);
 
 done:
-       chan->conn_state &= ~L2CAP_CONN_LOCAL_BUSY;
-       chan->conn_state &= ~L2CAP_CONN_RNR_SENT;
+       clear_bit(CONN_LOCAL_BUSY, &chan->conn_state);
+       clear_bit(CONN_RNR_SENT, &chan->conn_state);
 
        BT_DBG("chan %p, Exit local busy", chan);
 
@@ -3324,7 +3317,7 @@ static int l2cap_push_rx_skb(struct l2cap_chan *chan, struct sk_buff *skb, u16 c
 {
        int sctrl, err;
 
-       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
                bt_cb(skb)->sar = control >> L2CAP_CTRL_SAR_SHIFT;
                __skb_queue_tail(&chan->busy_q, skb);
                return l2cap_try_push_rx_skb(chan);
@@ -3341,7 +3334,7 @@ static int l2cap_push_rx_skb(struct l2cap_chan *chan, struct sk_buff *skb, u16 c
        /* Busy Condition */
        BT_DBG("chan %p, Enter local busy", chan);
 
-       chan->conn_state |= L2CAP_CONN_LOCAL_BUSY;
+       set_bit(CONN_LOCAL_BUSY, &chan->conn_state);
        bt_cb(skb)->sar = control >> L2CAP_CTRL_SAR_SHIFT;
        __skb_queue_tail(&chan->busy_q, skb);
 
@@ -3349,7 +3342,7 @@ static int l2cap_push_rx_skb(struct l2cap_chan *chan, struct sk_buff *skb, u16 c
        sctrl |= L2CAP_SUPER_RCV_NOT_READY;
        l2cap_send_sframe(chan, sctrl);
 
-       chan->conn_state |= L2CAP_CONN_RNR_SENT;
+       set_bit(CONN_RNR_SENT, &chan->conn_state);
 
        __clear_ack_timer(chan);
 
@@ -3370,7 +3363,7 @@ static int l2cap_streaming_reassembly_sdu(struct l2cap_chan *chan, struct sk_buf
 
        switch (control & L2CAP_CTRL_SAR) {
        case L2CAP_SDU_UNSEGMENTED:
-               if (chan->conn_state & L2CAP_CONN_SAR_SDU) {
+               if (test_bit(CONN_SAR_SDU, &chan->conn_state)) {
                        kfree_skb(chan->sdu);
                        break;
                }
@@ -3382,7 +3375,7 @@ static int l2cap_streaming_reassembly_sdu(struct l2cap_chan *chan, struct sk_buf
                break;
 
        case L2CAP_SDU_START:
-               if (chan->conn_state & L2CAP_CONN_SAR_SDU) {
+               if (test_bit(CONN_SAR_SDU, &chan->conn_state)) {
                        kfree_skb(chan->sdu);
                        break;
                }
@@ -3403,13 +3396,13 @@ static int l2cap_streaming_reassembly_sdu(struct l2cap_chan *chan, struct sk_buf
 
                memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
-               chan->conn_state |= L2CAP_CONN_SAR_SDU;
+               set_bit(CONN_SAR_SDU, &chan->conn_state);
                chan->partial_sdu_len = skb->len;
                err = 0;
                break;
 
        case L2CAP_SDU_CONTINUE:
-               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
                        break;
 
                memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
@@ -3423,12 +3416,12 @@ static int l2cap_streaming_reassembly_sdu(struct l2cap_chan *chan, struct sk_buf
                break;
 
        case L2CAP_SDU_END:
-               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
                        break;
 
                memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
-               chan->conn_state &= ~L2CAP_CONN_SAR_SDU;
+               clear_bit(CONN_SAR_SDU, &chan->conn_state);
                chan->partial_sdu_len += skb->len;
 
                if (chan->partial_sdu_len > chan->imtu)
@@ -3519,11 +3512,11 @@ static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_cont
                                                        tx_seq, rx_control);
 
        if (L2CAP_CTRL_FINAL & rx_control &&
-                       chan->conn_state & L2CAP_CONN_WAIT_F) {
+                       test_bit(CONN_WAIT_F, &chan->conn_state)) {
                __clear_monitor_timer(chan);
                if (chan->unacked_frames > 0)
                        __set_retrans_timer(chan);
-               chan->conn_state &= ~L2CAP_CONN_WAIT_F;
+               clear_bit(CONN_WAIT_F, &chan->conn_state);
        }
 
        chan->expected_ack_seq = req_seq;
@@ -3542,10 +3535,10 @@ static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_cont
                goto drop;
        }
 
-       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY)
+       if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state))
                goto drop;
 
-       if (chan->conn_state & L2CAP_CONN_SREJ_SENT) {
+       if (test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
                struct srej_list *first;
 
                first = list_first_entry(&chan->srej_l,
@@ -3559,7 +3552,7 @@ static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_cont
 
                        if (list_empty(&chan->srej_l)) {
                                chan->buffer_seq = chan->buffer_seq_srej;
-                               chan->conn_state &= ~L2CAP_CONN_SREJ_SENT;
+                               clear_bit(CONN_SREJ_SENT, &chan->conn_state);
                                l2cap_send_ack(chan);
                                BT_DBG("chan %p, Exit SREJ_SENT", chan);
                        }
@@ -3588,7 +3581,7 @@ static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_cont
                if (tx_seq_offset < expected_tx_seq_offset)
                        goto drop;
 
-               chan->conn_state |= L2CAP_CONN_SREJ_SENT;
+               set_bit(CONN_SREJ_SENT, &chan->conn_state);
 
                BT_DBG("chan %p, Enter SREJ", chan);
 
@@ -3599,7 +3592,7 @@ static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_cont
                __skb_queue_head_init(&chan->busy_q);
                l2cap_add_to_srej_queue(chan, skb, tx_seq, sar);
 
-               chan->conn_state |= L2CAP_CONN_SEND_PBIT;
+               set_bit(CONN_SEND_PBIT, &chan->conn_state);
 
                l2cap_send_srejframe(chan, tx_seq);
 
@@ -3610,7 +3603,7 @@ static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_cont
 expected:
        chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
 
-       if (chan->conn_state & L2CAP_CONN_SREJ_SENT) {
+       if (test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
                bt_cb(skb)->tx_seq = tx_seq;
                bt_cb(skb)->sar = sar;
                __skb_queue_tail(&chan->srej_q, skb);
@@ -3622,9 +3615,7 @@ expected:
                return 0;
 
        if (rx_control & L2CAP_CTRL_FINAL) {
-               if (chan->conn_state & L2CAP_CONN_REJ_ACT)
-                       chan->conn_state &= ~L2CAP_CONN_REJ_ACT;
-               else
+               if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state))
                        l2cap_retransmit_frames(chan);
        }
 
@@ -3650,33 +3641,31 @@ static inline void l2cap_data_channel_rrframe(struct l2cap_chan *chan, u16 rx_co
        l2cap_drop_acked_frames(chan);
 
        if (rx_control & L2CAP_CTRL_POLL) {
-               chan->conn_state |= L2CAP_CONN_SEND_FBIT;
-               if (chan->conn_state & L2CAP_CONN_SREJ_SENT) {
-                       if ((chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
+               set_bit(CONN_SEND_FBIT, &chan->conn_state);
+               if (test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
+                       if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state) &&
                                        (chan->unacked_frames > 0))
                                __set_retrans_timer(chan);
 
-                       chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+                       clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
                        l2cap_send_srejtail(chan);
                } else {
                        l2cap_send_i_or_rr_or_rnr(chan);
                }
 
        } else if (rx_control & L2CAP_CTRL_FINAL) {
-               chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+               clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
 
-               if (chan->conn_state & L2CAP_CONN_REJ_ACT)
-                       chan->conn_state &= ~L2CAP_CONN_REJ_ACT;
-               else
+               if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state))
                        l2cap_retransmit_frames(chan);
 
        } else {
-               if ((chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
+               if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state) &&
                                (chan->unacked_frames > 0))
                        __set_retrans_timer(chan);
 
-               chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
-               if (chan->conn_state & L2CAP_CONN_SREJ_SENT)
+               clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
+               if (test_bit(CONN_SREJ_SENT, &chan->conn_state))
                        l2cap_send_ack(chan);
                else
                        l2cap_ertm_send(chan);
@@ -3689,21 +3678,19 @@ static inline void l2cap_data_channel_rejframe(struct l2cap_chan *chan, u16 rx_c
 
        BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
 
-       chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+       clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
 
        chan->expected_ack_seq = tx_seq;
        l2cap_drop_acked_frames(chan);
 
        if (rx_control & L2CAP_CTRL_FINAL) {
-               if (chan->conn_state & L2CAP_CONN_REJ_ACT)
-                       chan->conn_state &= ~L2CAP_CONN_REJ_ACT;
-               else
+               if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state))
                        l2cap_retransmit_frames(chan);
        } else {
                l2cap_retransmit_frames(chan);
 
-               if (chan->conn_state & L2CAP_CONN_WAIT_F)
-                       chan->conn_state |= L2CAP_CONN_REJ_ACT;
+               if (test_bit(CONN_WAIT_F, &chan->conn_state))
+                       set_bit(CONN_REJ_ACT, &chan->conn_state);
        }
 }
 static inline void l2cap_data_channel_srejframe(struct l2cap_chan *chan, u16 rx_control)
@@ -3712,32 +3699,32 @@ static inline void l2cap_data_channel_srejframe(struct l2cap_chan *chan, u16 rx_
 
        BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
 
-       chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+       clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
 
        if (rx_control & L2CAP_CTRL_POLL) {
                chan->expected_ack_seq = tx_seq;
                l2cap_drop_acked_frames(chan);
 
-               chan->conn_state |= L2CAP_CONN_SEND_FBIT;
+               set_bit(CONN_SEND_FBIT, &chan->conn_state);
                l2cap_retransmit_one_frame(chan, tx_seq);
 
                l2cap_ertm_send(chan);
 
-               if (chan->conn_state & L2CAP_CONN_WAIT_F) {
+               if (test_bit(CONN_WAIT_F, &chan->conn_state)) {
                        chan->srej_save_reqseq = tx_seq;
-                       chan->conn_state |= L2CAP_CONN_SREJ_ACT;
+                       set_bit(CONN_SREJ_ACT, &chan->conn_state);
                }
        } else if (rx_control & L2CAP_CTRL_FINAL) {
-               if ((chan->conn_state & L2CAP_CONN_SREJ_ACT) &&
+               if (test_bit(CONN_SREJ_ACT, &chan->conn_state) &&
                                chan->srej_save_reqseq == tx_seq)
-                       chan->conn_state &= ~L2CAP_CONN_SREJ_ACT;
+                       clear_bit(CONN_SREJ_ACT, &chan->conn_state);
                else
                        l2cap_retransmit_one_frame(chan, tx_seq);
        } else {
                l2cap_retransmit_one_frame(chan, tx_seq);
-               if (chan->conn_state & L2CAP_CONN_WAIT_F) {
+               if (test_bit(CONN_WAIT_F, &chan->conn_state)) {
                        chan->srej_save_reqseq = tx_seq;
-                       chan->conn_state |= L2CAP_CONN_SREJ_ACT;
+                       set_bit(CONN_SREJ_ACT, &chan->conn_state);
                }
        }
 }
@@ -3748,14 +3735,14 @@ static inline void l2cap_data_channel_rnrframe(struct l2cap_chan *chan, u16 rx_c
 
        BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
 
-       chan->conn_state |= L2CAP_CONN_REMOTE_BUSY;
+       set_bit(CONN_REMOTE_BUSY, &chan->conn_state);
        chan->expected_ack_seq = tx_seq;
        l2cap_drop_acked_frames(chan);
 
        if (rx_control & L2CAP_CTRL_POLL)
-               chan->conn_state |= L2CAP_CONN_SEND_FBIT;
+               set_bit(CONN_SEND_FBIT, &chan->conn_state);
 
-       if (!(chan->conn_state & L2CAP_CONN_SREJ_SENT)) {
+       if (!test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
                __clear_retrans_timer(chan);
                if (rx_control & L2CAP_CTRL_POLL)
                        l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_FINAL);
@@ -3773,11 +3760,11 @@ static inline int l2cap_data_channel_sframe(struct l2cap_chan *chan, u16 rx_cont
        BT_DBG("chan %p rx_control 0x%4.4x len %d", chan, rx_control, skb->len);
 
        if (L2CAP_CTRL_FINAL & rx_control &&
-                       chan->conn_state & L2CAP_CONN_WAIT_F) {
+                       test_bit(CONN_WAIT_F, &chan->conn_state)) {
                __clear_monitor_timer(chan);
                if (chan->unacked_frames > 0)
                        __set_retrans_timer(chan);
-               chan->conn_state &= ~L2CAP_CONN_WAIT_F;
+               clear_bit(CONN_WAIT_F, &chan->conn_state);
        }
 
        switch (rx_control & L2CAP_CTRL_SUPERVISE) {