/* L2CAP socket address */
 struct sockaddr_l2 {
        sa_family_t     l2_family;
-       unsigned short  l2_psm;
+       __le16          l2_psm;
        bdaddr_t        l2_bdaddr;
 };
 
 
 /* L2CAP structures */
 struct l2cap_hdr {
-       __u16      len;
-       __u16      cid;
+       __le16     len;
+       __le16     cid;
 } __attribute__ ((packed));
 #define L2CAP_HDR_SIZE         4
 
 struct l2cap_cmd_hdr {
        __u8       code;
        __u8       ident;
-       __u16      len;
+       __le16     len;
 } __attribute__ ((packed));
 #define L2CAP_CMD_HDR_SIZE     4
 
 struct l2cap_cmd_rej {
-       __u16      reason;
+       __le16     reason;
 } __attribute__ ((packed));
 
 struct l2cap_conn_req {
-       __u16      psm;
-       __u16      scid;
+       __le16     psm;
+       __le16     scid;
 } __attribute__ ((packed));
 
 struct l2cap_conn_rsp {
-       __u16      dcid;
-       __u16      scid;
-       __u16      result;
-       __u16      status;
+       __le16     dcid;
+       __le16     scid;
+       __le16     result;
+       __le16     status;
 } __attribute__ ((packed));
 
 /* connect result */
 #define L2CAP_CS_AUTHOR_PEND  0x0002
 
 struct l2cap_conf_req {
-       __u16      dcid;
-       __u16      flags;
+       __le16     dcid;
+       __le16     flags;
        __u8       data[0];
 } __attribute__ ((packed));
 
 struct l2cap_conf_rsp {
-       __u16      scid;
-       __u16      flags;
-       __u16      result;
+       __le16     scid;
+       __le16     flags;
+       __le16     result;
        __u8       data[0];
 } __attribute__ ((packed));
 
 #define L2CAP_CONF_MAX_SIZE    22
 
 struct l2cap_disconn_req {
-       __u16      dcid;
-       __u16      scid;
+       __le16     dcid;
+       __le16     scid;
 } __attribute__ ((packed));
 
 struct l2cap_disconn_rsp {
-       __u16      dcid;
-       __u16      scid;
+       __le16     dcid;
+       __le16     scid;
 } __attribute__ ((packed));
 
 struct l2cap_info_req {
-       __u16       type;
+       __le16      type;
        __u8        data[0];
 } __attribute__ ((packed));
 
 struct l2cap_info_rsp {
-       __u16       type;
-       __u16       result;
+       __le16      type;
+       __le16      result;
        __u8        data[0];
 } __attribute__ ((packed));
 
 
 struct l2cap_pinfo {
        struct bt_sock  bt;
-       __u16           psm;
+       __le16          psm;
        __u16           dcid;
        __u16           scid;
 
 
        __u8            ident;
 
-       __u16           sport;
+       __le16          sport;
 
        struct l2cap_conn       *conn;
        struct sock             *next_c;
 
 }
 
 /* ---- Socket interface ---- */
-static struct sock *__l2cap_get_sock_by_addr(u16 psm, bdaddr_t *src)
+static struct sock *__l2cap_get_sock_by_addr(__le16 psm, bdaddr_t *src)
 {
        struct sock *sk;
        struct hlist_node *node;
 /* Find socket with psm and source bdaddr.
  * Returns closest match.
  */
-static struct sock *__l2cap_get_sock_by_psm(int state, u16 psm, bdaddr_t *src)
+static struct sock *__l2cap_get_sock_by_psm(int state, __le16 psm, bdaddr_t *src)
 {
        struct sock *sk = NULL, *sk1 = NULL;
        struct hlist_node *node;
 
 /* Find socket with given address (psm, src).
  * Returns locked socket */
-static inline struct sock *l2cap_get_sock_by_psm(int state, u16 psm, bdaddr_t *src)
+static inline struct sock *l2cap_get_sock_by_psm(int state, __le16 psm, bdaddr_t *src)
 {
        struct sock *s;
        read_lock(&l2cap_sk_list.lock);
                goto done;
        }
 
-       if (la->l2_psm > 0 && btohs(la->l2_psm) < 0x1001 &&
+       if (la->l2_psm && btohs(la->l2_psm) < 0x1001 &&
                                !capable(CAP_NET_BIND_SERVICE)) {
                err = -EACCES;
                goto done;
        lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
 
        if (sk->sk_type == SOCK_DGRAM)
-               put_unaligned(l2cap_pi(sk)->psm, (u16 *) skb_put(skb, 2));
+               put_unaligned(l2cap_pi(sk)->psm, (__le16 *) skb_put(skb, 2));
 
        if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
                err = -EFAULT;
                break;
 
        case 2:
-               *val = __le16_to_cpu(*((u16 *)opt->val));
+               *val = __le16_to_cpu(*((__le16 *)opt->val));
                break;
 
        case 4:
-               *val = __le32_to_cpu(*((u32 *)opt->val));
+               *val = __le32_to_cpu(*((__le32 *)opt->val));
                break;
 
        default:
                break;
 
        case 2:
-               *((u16 *) opt->val) = cpu_to_le16(val);
+               *((__le16 *) opt->val) = cpu_to_le16(val);
                break;
 
        case 4:
-               *((u32 *) opt->val) = cpu_to_le32(val);
+               *((__le32 *) opt->val) = cpu_to_le32(val);
                break;
 
        default:
        int result = 0, status = 0;
 
        u16 dcid = 0, scid = __le16_to_cpu(req->scid);
-       u16 psm  = req->psm;
+       __le16 psm  = req->psm;
 
        BT_DBG("psm 0x%2.2x scid 0x%4.4x", psm, scid);
 
        return 0;
 }
 
-static inline int l2cap_conless_channel(struct l2cap_conn *conn, u16 psm, struct sk_buff *skb)
+static inline int l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, struct sk_buff *skb)
 {
        struct sock *sk;
 
 static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
 {
        struct l2cap_hdr *lh = (void *) skb->data;
-       u16 cid, psm, len;
+       u16 cid, len;
+       __le16 psm;
 
        skb_pull(skb, L2CAP_HDR_SIZE);
        cid = __le16_to_cpu(lh->cid);
                break;
 
        case 0x0002:
-               psm = get_unaligned((u16 *) skb->data);
+               psm = get_unaligned((__le16 *) skb->data);
                skb_pull(skb, 2);
                l2cap_conless_channel(conn, psm, skb);
                break;