Merge master.kernel.org:/pub/scm/linux/kernel/git/holtmann/bluetooth-2.6
[linux-3.10.git] / drivers / bluetooth / hci_h4.c
1 /* 
2    BlueZ - Bluetooth protocol stack for Linux
3    Copyright (C) 2000-2001 Qualcomm Incorporated
4
5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License version 2 as
9    published by the Free Software Foundation;
10
11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 
16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 
21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 
22    SOFTWARE IS DISCLAIMED.
23 */
24
25 /*
26  * Bluetooth HCI UART(H4) protocol.
27  *
28  * $Id: hci_h4.c,v 1.3 2002/09/09 01:17:32 maxk Exp $    
29  */
30 #define VERSION "1.2"
31
32 #include <linux/config.h>
33 #include <linux/module.h>
34
35 #include <linux/kernel.h>
36 #include <linux/init.h>
37 #include <linux/sched.h>
38 #include <linux/types.h>
39 #include <linux/fcntl.h>
40 #include <linux/interrupt.h>
41 #include <linux/ptrace.h>
42 #include <linux/poll.h>
43
44 #include <linux/slab.h>
45 #include <linux/tty.h>
46 #include <linux/errno.h>
47 #include <linux/string.h>
48 #include <linux/signal.h>
49 #include <linux/ioctl.h>
50 #include <linux/skbuff.h>
51
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h>
54 #include "hci_uart.h"
55 #include "hci_h4.h"
56
57 #ifndef CONFIG_BT_HCIUART_DEBUG
58 #undef  BT_DBG
59 #define BT_DBG( A... )
60 #endif
61
62 /* Initialize protocol */
63 static int h4_open(struct hci_uart *hu)
64 {
65         struct h4_struct *h4;
66         
67         BT_DBG("hu %p", hu);
68         
69         h4 = kmalloc(sizeof(*h4), GFP_ATOMIC);
70         if (!h4)
71                 return -ENOMEM;
72         memset(h4, 0, sizeof(*h4));
73
74         skb_queue_head_init(&h4->txq);
75
76         hu->priv = h4;
77         return 0;
78 }
79
80 /* Flush protocol data */
81 static int h4_flush(struct hci_uart *hu)
82 {
83         struct h4_struct *h4 = hu->priv;
84
85         BT_DBG("hu %p", hu);
86         skb_queue_purge(&h4->txq);
87         return 0;
88 }
89
90 /* Close protocol */
91 static int h4_close(struct hci_uart *hu)
92 {
93         struct h4_struct *h4 = hu->priv;
94         hu->priv = NULL;
95
96         BT_DBG("hu %p", hu);
97
98         skb_queue_purge(&h4->txq);
99         if (h4->rx_skb)
100                 kfree_skb(h4->rx_skb);
101
102         hu->priv = NULL;
103         kfree(h4);
104         return 0;
105 }
106
107 /* Enqueue frame for transmittion (padding, crc, etc) */
108 static int h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
109 {
110         struct h4_struct *h4 = hu->priv;
111
112         BT_DBG("hu %p skb %p", hu, skb);
113
114         /* Prepend skb with frame type */
115         memcpy(skb_push(skb, 1), &skb->pkt_type, 1);
116         skb_queue_tail(&h4->txq, skb);
117         return 0;
118 }
119
120 static inline int h4_check_data_len(struct h4_struct *h4, int len)
121 {
122         register int room = skb_tailroom(h4->rx_skb);
123
124         BT_DBG("len %d room %d", len, room);
125         if (!len) {
126                 hci_recv_frame(h4->rx_skb);
127         } else if (len > room) {
128                 BT_ERR("Data length is too large");
129                 kfree_skb(h4->rx_skb);
130         } else {
131                 h4->rx_state = H4_W4_DATA;
132                 h4->rx_count = len;
133                 return len;
134         }
135
136         h4->rx_state = H4_W4_PACKET_TYPE;
137         h4->rx_skb   = NULL;
138         h4->rx_count = 0;
139         return 0;
140 }
141
142 /* Recv data */
143 static int h4_recv(struct hci_uart *hu, void *data, int count)
144 {
145         struct h4_struct *h4 = hu->priv;
146         register char *ptr;
147         struct hci_event_hdr *eh;
148         struct hci_acl_hdr   *ah;
149         struct hci_sco_hdr   *sh;
150         register int len, type, dlen;
151
152         BT_DBG("hu %p count %d rx_state %ld rx_count %ld", 
153                         hu, count, h4->rx_state, h4->rx_count);
154
155         ptr = data;
156         while (count) {
157                 if (h4->rx_count) {
158                         len = min_t(unsigned int, h4->rx_count, count);
159                         memcpy(skb_put(h4->rx_skb, len), ptr, len);
160                         h4->rx_count -= len; count -= len; ptr += len;
161
162                         if (h4->rx_count)
163                                 continue;
164
165                         switch (h4->rx_state) {
166                         case H4_W4_DATA:
167                                 BT_DBG("Complete data");
168
169                                 hci_recv_frame(h4->rx_skb);
170
171                                 h4->rx_state = H4_W4_PACKET_TYPE;
172                                 h4->rx_skb = NULL;
173                                 continue;
174
175                         case H4_W4_EVENT_HDR:
176                                 eh = (struct hci_event_hdr *) h4->rx_skb->data;
177
178                                 BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
179
180                                 h4_check_data_len(h4, eh->plen);
181                                 continue;
182
183                         case H4_W4_ACL_HDR:
184                                 ah = (struct hci_acl_hdr *) h4->rx_skb->data;
185                                 dlen = __le16_to_cpu(ah->dlen);
186
187                                 BT_DBG("ACL header: dlen %d", dlen);
188
189                                 h4_check_data_len(h4, dlen);
190                                 continue;
191
192                         case H4_W4_SCO_HDR:
193                                 sh = (struct hci_sco_hdr *) h4->rx_skb->data;
194
195                                 BT_DBG("SCO header: dlen %d", sh->dlen);
196
197                                 h4_check_data_len(h4, sh->dlen);
198                                 continue;
199                         }
200                 }
201
202                 /* H4_W4_PACKET_TYPE */
203                 switch (*ptr) {
204                 case HCI_EVENT_PKT:
205                         BT_DBG("Event packet");
206                         h4->rx_state = H4_W4_EVENT_HDR;
207                         h4->rx_count = HCI_EVENT_HDR_SIZE;
208                         type = HCI_EVENT_PKT;
209                         break;
210
211                 case HCI_ACLDATA_PKT:
212                         BT_DBG("ACL packet");
213                         h4->rx_state = H4_W4_ACL_HDR;
214                         h4->rx_count = HCI_ACL_HDR_SIZE;
215                         type = HCI_ACLDATA_PKT;
216                         break;
217
218                 case HCI_SCODATA_PKT:
219                         BT_DBG("SCO packet");
220                         h4->rx_state = H4_W4_SCO_HDR;
221                         h4->rx_count = HCI_SCO_HDR_SIZE;
222                         type = HCI_SCODATA_PKT;
223                         break;
224
225                 default:
226                         BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
227                         hu->hdev->stat.err_rx++;
228                         ptr++; count--;
229                         continue;
230                 };
231                 ptr++; count--;
232
233                 /* Allocate packet */
234                 h4->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
235                 if (!h4->rx_skb) {
236                         BT_ERR("Can't allocate mem for new packet");
237                         h4->rx_state = H4_W4_PACKET_TYPE;
238                         h4->rx_count = 0;
239                         return 0;
240                 }
241                 h4->rx_skb->dev = (void *) hu->hdev;
242                 h4->rx_skb->pkt_type = type;
243         }
244         return count;
245 }
246
247 static struct sk_buff *h4_dequeue(struct hci_uart *hu)
248 {
249         struct h4_struct *h4 = hu->priv;
250         return skb_dequeue(&h4->txq);
251 }
252
253 static struct hci_uart_proto h4p = {
254         .id      = HCI_UART_H4,
255         .open    = h4_open,
256         .close   = h4_close,
257         .recv    = h4_recv,
258         .enqueue = h4_enqueue,
259         .dequeue = h4_dequeue,
260         .flush   = h4_flush,
261 };
262               
263 int h4_init(void)
264 {
265         int err = hci_uart_register_proto(&h4p);
266         if (!err)
267                 BT_INFO("HCI H4 protocol initialized");
268         else
269                 BT_ERR("HCI H4 protocol registration failed");
270         
271         return err;
272 }
273
274 int h4_deinit(void)
275 {
276         return hci_uart_unregister_proto(&h4p);
277 }