Merge master.kernel.org:/pub/scm/linux/kernel/git/holtmann/bluetooth-2.6

4 files changed, 169 insertions, 45 deletions

diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index 63980bd6b5f2..5fdfc9a67d39 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -123,8 +123,8 @@ void hci_add_sco(struct hci_conn *conn, __u16 handle)
         conn->state = BT_CONNECT;
         conn->out = 1;
 
-        cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
         cp.handle   = cpu_to_le16(handle);
+        cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
 
         hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ADD_SCO, sizeof(cp), &cp);
 }
@@ -220,19 +220,19 @@ int hci_conn_del(struct hci_conn *conn)
 
         del_timer(&conn->disc_timer);
 
-        if (conn->type == SCO_LINK) {
-                struct hci_conn *acl = conn->link;
-                if (acl) {
-                        acl->link = NULL;
-                        hci_conn_put(acl);
-                }
-        } else {
+        if (conn->type == ACL_LINK) {
                 struct hci_conn *sco = conn->link;
                 if (sco)
                         sco->link = NULL;
 
                 /* Unacked frames */
                 hdev->acl_cnt += conn->sent;
+        } else {
+                struct hci_conn *acl = conn->link;
+                if (acl) {
+                        acl->link = NULL;
+                        hci_conn_put(acl);
+                }
         }
 
         tasklet_disable(&hdev->tx_task);
@@ -297,9 +297,10 @@ EXPORT_SYMBOL(hci_get_route);
 
 /* Create SCO or ACL connection.
  * Device _must_ be locked */
-struct hci_conn * hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
+struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
 {
         struct hci_conn *acl;
+        struct hci_conn *sco;
 
         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 
@@ -313,28 +314,26 @@ struct hci_conn * hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
         if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
                 hci_acl_connect(acl);
 
-        if (type == SCO_LINK) {
-                struct hci_conn *sco;
+        if (type == ACL_LINK)
+                return acl;
 
-                if (!(sco = hci_conn_hash_lookup_ba(hdev, SCO_LINK, dst))) {
-                        if (!(sco = hci_conn_add(hdev, SCO_LINK, dst))) {
-                                hci_conn_put(acl);
-                                return NULL;
-                        }
+        if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
+                if (!(sco = hci_conn_add(hdev, type, dst))) {
+                        hci_conn_put(acl);
+                        return NULL;
                 }
-                acl->link = sco;
-                sco->link = acl;
+        }
 
-                hci_conn_hold(sco);
+        acl->link = sco;
+        sco->link = acl;
 
-                if (acl->state == BT_CONNECTED &&
-                                (sco->state == BT_OPEN || sco->state == BT_CLOSED))
-                        hci_add_sco(sco, acl->handle);
+        hci_conn_hold(sco);
 
-                return sco;
-        } else {
-                return acl;
-        }
+        if (acl->state == BT_CONNECTED &&
+                        (sco->state == BT_OPEN || sco->state == BT_CLOSED))
+                hci_add_sco(sco, acl->handle);
+
+        return sco;
 }
 EXPORT_SYMBOL(hci_connect);
 
diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index aa4b56a8c3ea..f6d867e0179f 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -826,7 +826,7 @@ EXPORT_SYMBOL(hci_free_dev);
 int hci_register_dev(struct hci_dev *hdev)
 {
         struct list_head *head = &hci_dev_list, *p;
-        int id = 0;
+        int i, id = 0;
 
         BT_DBG("%p name %s type %d owner %p", hdev, hdev->name, hdev->type, hdev->owner);
 
@@ -851,6 +851,7 @@ int hci_register_dev(struct hci_dev *hdev)
 
         hdev->flags = 0;
         hdev->pkt_type  = (HCI_DM1 | HCI_DH1 | HCI_HV1);
+        hdev->esco_type = (ESCO_HV1);
         hdev->link_mode = (HCI_LM_ACCEPT);
 
         hdev->idle_timeout = 0;
@@ -865,6 +866,9 @@ int hci_register_dev(struct hci_dev *hdev)
         skb_queue_head_init(&hdev->cmd_q);
         skb_queue_head_init(&hdev->raw_q);
 
+        for (i = 0; i < 3; i++)
+                hdev->reassembly[i] = NULL;
+
         init_waitqueue_head(&hdev->req_wait_q);
         init_MUTEX(&hdev->req_lock);
 
@@ -889,6 +893,8 @@ EXPORT_SYMBOL(hci_register_dev);
 /* Unregister HCI device */
 int hci_unregister_dev(struct hci_dev *hdev)
 {
+        int i;
+
         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
 
         hci_unregister_sysfs(hdev);
@@ -899,9 +905,13 @@ int hci_unregister_dev(struct hci_dev *hdev)
 
         hci_dev_do_close(hdev);
 
+        for (i = 0; i < 3; i++)
+                kfree_skb(hdev->reassembly[i]);
+
         hci_notify(hdev, HCI_DEV_UNREG);
 
         __hci_dev_put(hdev);
+
         return 0;
 }
 EXPORT_SYMBOL(hci_unregister_dev);
@@ -922,6 +932,90 @@ int hci_resume_dev(struct hci_dev *hdev)
 }
 EXPORT_SYMBOL(hci_resume_dev);
 
+/* Receive packet type fragment */
+#define __reassembly(hdev, type)  ((hdev)->reassembly[(type) - 2])
+
+int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
+{
+        if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
+                return -EILSEQ;
+
+        while (count) {
+                struct sk_buff *skb = __reassembly(hdev, type);
+                struct { int expect; } *scb;
+                int len = 0;
+
+                if (!skb) {
+                        /* Start of the frame */
+
+                        switch (type) {
+                        case HCI_EVENT_PKT:
+                                if (count >= HCI_EVENT_HDR_SIZE) {
+                                        struct hci_event_hdr *h = data;
+                                        len = HCI_EVENT_HDR_SIZE + h->plen;
+                                } else
+                                        return -EILSEQ;
+                                break;
+
+                        case HCI_ACLDATA_PKT:
+                                if (count >= HCI_ACL_HDR_SIZE) {
+                                        struct hci_acl_hdr *h = data;
+                                        len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
+                                } else
+                                        return -EILSEQ;
+                                break;
+
+                        case HCI_SCODATA_PKT:
+                                if (count >= HCI_SCO_HDR_SIZE) {
+                                        struct hci_sco_hdr *h = data;
+                                        len = HCI_SCO_HDR_SIZE + h->dlen;
+                                } else
+                                        return -EILSEQ;
+                                break;
+                        }
+
+                        skb = bt_skb_alloc(len, GFP_ATOMIC);
+                        if (!skb) {
+                                BT_ERR("%s no memory for packet", hdev->name);
+                                return -ENOMEM;
+                        }
+
+                        skb->dev = (void *) hdev;
+                        bt_cb(skb)->pkt_type = type;
+        
+                        __reassembly(hdev, type) = skb;
+
+                        scb = (void *) skb->cb;
+                        scb->expect = len;
+                } else {
+                        /* Continuation */
+
+                        scb = (void *) skb->cb;
+                        len = scb->expect;
+                }
+
+                len = min(len, count);
+
+                memcpy(skb_put(skb, len), data, len);
+
+                scb->expect -= len;
+
+                if (scb->expect == 0) {
+                        /* Complete frame */
+
+                        __reassembly(hdev, type) = NULL;
+
+                        bt_cb(skb)->pkt_type = type;
+                        hci_recv_frame(skb);
+                }
+
+                count -= len; data += len;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(hci_recv_fragment);
+
 /* ---- Interface to upper protocols ---- */
 
 /* Register/Unregister protocols.
@@ -1029,7 +1123,7 @@ int hci_send_cmd(struct hci_dev *hdev, __u16 ogf, __u16 ocf, __u32 plen, void *p
 
         skb = bt_skb_alloc(len, GFP_ATOMIC);
         if (!skb) {
-                BT_ERR("%s Can't allocate memory for HCI command", hdev->name);
+                BT_ERR("%s no memory for command", hdev->name);
                 return -ENOMEM;
         }
 
@@ -1161,7 +1255,7 @@ EXPORT_SYMBOL(hci_send_sco);
 static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote)
 {
         struct hci_conn_hash *h = &hdev->conn_hash;
-        struct hci_conn  *conn = NULL;
+        struct hci_conn *conn = NULL;
         int num = 0, min = ~0;
         struct list_head *p;
 
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 447ba7131220..4baea1e38652 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -350,11 +350,24 @@ static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *s
                 if (hdev->features[0] & LMP_5SLOT)
                         hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
 
-                if (hdev->features[1] & LMP_HV2)
-                        hdev->pkt_type |= (HCI_HV2);
+                if (hdev->features[1] & LMP_HV2) {
+                        hdev->pkt_type  |= (HCI_HV2);
+                        hdev->esco_type |= (ESCO_HV2);
+                }
+
+                if (hdev->features[1] & LMP_HV3) {
+                        hdev->pkt_type  |= (HCI_HV3);
+                        hdev->esco_type |= (ESCO_HV3);
+                }
 
-                if (hdev->features[1] & LMP_HV3)
-                        hdev->pkt_type |= (HCI_HV3);
+                if (hdev->features[3] & LMP_ESCO)
+                        hdev->esco_type |= (ESCO_EV3);
+
+                if (hdev->features[4] & LMP_EV4)
+                        hdev->esco_type |= (ESCO_EV4);
+
+                if (hdev->features[4] & LMP_EV5)
+                        hdev->esco_type |= (ESCO_EV5);
 
                 BT_DBG("%s: features 0x%x 0x%x 0x%x", hdev->name,
                                 lf->features[0], lf->features[1], lf->features[2]);
@@ -881,12 +894,12 @@ static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *s
                 if (conn) {
                         conn->sent -= count;
 
-                        if (conn->type == SCO_LINK) {
-                                if ((hdev->sco_cnt += count) > hdev->sco_pkts)
-                                        hdev->sco_cnt = hdev->sco_pkts;
-                        } else {
+                        if (conn->type == ACL_LINK) {
                                 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
                                         hdev->acl_cnt = hdev->acl_pkts;
+                        } else {
+                                if ((hdev->sco_cnt += count) > hdev->sco_pkts)
+                                        hdev->sco_cnt = hdev->sco_pkts;
                         }
                 }
         }
diff --git a/net/bluetooth/rfcomm/tty.c b/net/bluetooth/rfcomm/tty.c
index b2b1cceb102a..23ba61a13bdd 100644
--- a/net/bluetooth/rfcomm/tty.c
+++ b/net/bluetooth/rfcomm/tty.c
@@ -95,6 +95,10 @@ static void rfcomm_dev_destruct(struct rfcomm_dev *dev)
 
         BT_DBG("dev %p dlc %p", dev, dlc);
 
+        write_lock_bh(&rfcomm_dev_lock);
+        list_del_init(&dev->list);
+        write_unlock_bh(&rfcomm_dev_lock);
+
         rfcomm_dlc_lock(dlc);
         /* Detach DLC if it's owned by this dev */
         if (dlc->owner == dev)
@@ -156,8 +160,13 @@ static inline struct rfcomm_dev *rfcomm_dev_get(int id)
         read_lock(&rfcomm_dev_lock);
 
         dev = __rfcomm_dev_get(id);
-        if (dev)
-                rfcomm_dev_hold(dev);
+
+        if (dev) {
+                if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
+                        dev = NULL;
+                else
+                        rfcomm_dev_hold(dev);
+        }
 
         read_unlock(&rfcomm_dev_lock);
 
@@ -265,6 +274,12 @@ out:
 
         dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);
 
+        if (IS_ERR(dev->tty_dev)) {
+                list_del(&dev->list);
+                kfree(dev);
+                return PTR_ERR(dev->tty_dev);
+        }
+
         return dev->id;
 }
 
@@ -272,10 +287,7 @@ static void rfcomm_dev_del(struct rfcomm_dev *dev)
 {
         BT_DBG("dev %p", dev);
 
-        write_lock_bh(&rfcomm_dev_lock);
-        list_del_init(&dev->list);
-        write_unlock_bh(&rfcomm_dev_lock);
-
+        set_bit(RFCOMM_TTY_RELEASED, &dev->flags);
         rfcomm_dev_put(dev);
 }
 
@@ -329,7 +341,7 @@ static int rfcomm_create_dev(struct sock *sk, void __user *arg)
         if (copy_from_user(&req, arg, sizeof(req)))
                 return -EFAULT;
 
-        BT_DBG("sk %p dev_id %id flags 0x%x", sk, req.dev_id, req.flags);
+        BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
 
         if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
                 return -EPERM;
@@ -370,7 +382,7 @@ static int rfcomm_release_dev(void __user *arg)
         if (copy_from_user(&req, arg, sizeof(req)))
                 return -EFAULT;
 
-        BT_DBG("dev_id %id flags 0x%x", req.dev_id, req.flags);
+        BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
 
         if (!(dev = rfcomm_dev_get(req.dev_id)))
                 return -ENODEV;
@@ -383,6 +395,10 @@ static int rfcomm_release_dev(void __user *arg)
         if (req.flags & (1 << RFCOMM_HANGUP_NOW))
                 rfcomm_dlc_close(dev->dlc, 0);
 
+        /* Shut down TTY synchronously before freeing rfcomm_dev */
+        if (dev->tty)
+                tty_vhangup(dev->tty);
+
         rfcomm_dev_del(dev);
         rfcomm_dev_put(dev);
         return 0;
@@ -415,6 +431,8 @@ static int rfcomm_get_dev_list(void __user *arg)
 
         list_for_each(p, &rfcomm_dev_list) {
                 struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
+                if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
+                        continue;
                 (di + n)->id      = dev->id;
                 (di + n)->flags   = dev->flags;
                 (di + n)->state   = dev->dlc->state;