ppc: Export __handle_mm_fault for MOL
[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 #undef  BT_DMP
61 #define BT_DMP( A... )
62 #endif
63
64 /* Initialize protocol */
65 static int h4_open(struct hci_uart *hu)
66 {
67         struct h4_struct *h4;
68         
69         BT_DBG("hu %p", hu);
70         
71         h4 = kmalloc(sizeof(*h4), GFP_ATOMIC);
72         if (!h4)
73                 return -ENOMEM;
74         memset(h4, 0, sizeof(*h4));
75
76         skb_queue_head_init(&h4->txq);
77
78         hu->priv = h4;
79         return 0;
80 }
81
82 /* Flush protocol data */
83 static int h4_flush(struct hci_uart *hu)
84 {
85         struct h4_struct *h4 = hu->priv;
86
87         BT_DBG("hu %p", hu);
88         skb_queue_purge(&h4->txq);
89         return 0;
90 }
91
92 /* Close protocol */
93 static int h4_close(struct hci_uart *hu)
94 {
95         struct h4_struct *h4 = hu->priv;
96         hu->priv = NULL;
97
98         BT_DBG("hu %p", hu);
99
100         skb_queue_purge(&h4->txq);
101         if (h4->rx_skb)
102                 kfree_skb(h4->rx_skb);
103
104         hu->priv = NULL;
105         kfree(h4);
106         return 0;
107 }
108
109 /* Enqueue frame for transmittion (padding, crc, etc) */
110 static int h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
111 {
112         struct h4_struct *h4 = hu->priv;
113
114         BT_DBG("hu %p skb %p", hu, skb);
115
116         /* Prepend skb with frame type */
117         memcpy(skb_push(skb, 1), &skb->pkt_type, 1);
118         skb_queue_tail(&h4->txq, skb);
119         return 0;
120 }
121
122 static inline int h4_check_data_len(struct h4_struct *h4, int len)
123 {
124         register int room = skb_tailroom(h4->rx_skb);
125
126         BT_DBG("len %d room %d", len, room);
127         if (!len) {
128                 BT_DMP(h4->rx_skb->data, h4->rx_skb->len);
129                 hci_recv_frame(h4->rx_skb);
130         } else if (len > room) {
131                 BT_ERR("Data length is too large");
132                 kfree_skb(h4->rx_skb);
133         } else {
134                 h4->rx_state = H4_W4_DATA;
135                 h4->rx_count = len;
136                 return len;
137         }
138
139         h4->rx_state = H4_W4_PACKET_TYPE;
140         h4->rx_skb   = NULL;
141         h4->rx_count = 0;
142         return 0;
143 }
144
145 /* Recv data */
146 static int h4_recv(struct hci_uart *hu, void *data, int count)
147 {
148         struct h4_struct *h4 = hu->priv;
149         register char *ptr;
150         struct hci_event_hdr *eh;
151         struct hci_acl_hdr   *ah;
152         struct hci_sco_hdr   *sh;
153         register int len, type, dlen;
154
155         BT_DBG("hu %p count %d rx_state %ld rx_count %ld", 
156                         hu, count, h4->rx_state, h4->rx_count);
157
158         ptr = data;
159         while (count) {
160                 if (h4->rx_count) {
161                         len = min_t(unsigned int, h4->rx_count, count);
162                         memcpy(skb_put(h4->rx_skb, len), ptr, len);
163                         h4->rx_count -= len; count -= len; ptr += len;
164
165                         if (h4->rx_count)
166                                 continue;
167
168                         switch (h4->rx_state) {
169                         case H4_W4_DATA:
170                                 BT_DBG("Complete data");
171
172                                 BT_DMP(h4->rx_skb->data, h4->rx_skb->len);
173
174                                 hci_recv_frame(h4->rx_skb);
175
176                                 h4->rx_state = H4_W4_PACKET_TYPE;
177                                 h4->rx_skb = NULL;
178                                 continue;
179
180                         case H4_W4_EVENT_HDR:
181                                 eh = (struct hci_event_hdr *) h4->rx_skb->data;
182
183                                 BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
184
185                                 h4_check_data_len(h4, eh->plen);
186                                 continue;
187
188                         case H4_W4_ACL_HDR:
189                                 ah = (struct hci_acl_hdr *) h4->rx_skb->data;
190                                 dlen = __le16_to_cpu(ah->dlen);
191
192                                 BT_DBG("ACL header: dlen %d", dlen);
193
194                                 h4_check_data_len(h4, dlen);
195                                 continue;
196
197                         case H4_W4_SCO_HDR:
198                                 sh = (struct hci_sco_hdr *) h4->rx_skb->data;
199
200                                 BT_DBG("SCO header: dlen %d", sh->dlen);
201
202                                 h4_check_data_len(h4, sh->dlen);
203                                 continue;
204                         }
205                 }
206
207                 /* H4_W4_PACKET_TYPE */
208                 switch (*ptr) {
209                 case HCI_EVENT_PKT:
210                         BT_DBG("Event packet");
211                         h4->rx_state = H4_W4_EVENT_HDR;
212                         h4->rx_count = HCI_EVENT_HDR_SIZE;
213                         type = HCI_EVENT_PKT;
214                         break;
215
216                 case HCI_ACLDATA_PKT:
217                         BT_DBG("ACL packet");
218                         h4->rx_state = H4_W4_ACL_HDR;
219                         h4->rx_count = HCI_ACL_HDR_SIZE;
220                         type = HCI_ACLDATA_PKT;
221                         break;
222
223                 case HCI_SCODATA_PKT:
224                         BT_DBG("SCO packet");
225                         h4->rx_state = H4_W4_SCO_HDR;
226                         h4->rx_count = HCI_SCO_HDR_SIZE;
227                         type = HCI_SCODATA_PKT;
228                         break;
229
230                 default:
231                         BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
232                         hu->hdev->stat.err_rx++;
233                         ptr++; count--;
234                         continue;
235                 };
236                 ptr++; count--;
237
238                 /* Allocate packet */
239                 h4->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
240                 if (!h4->rx_skb) {
241                         BT_ERR("Can't allocate mem for new packet");
242                         h4->rx_state = H4_W4_PACKET_TYPE;
243                         h4->rx_count = 0;
244                         return 0;
245                 }
246                 h4->rx_skb->dev = (void *) hu->hdev;
247                 h4->rx_skb->pkt_type = type;
248         }
249         return count;
250 }
251
252 static struct sk_buff *h4_dequeue(struct hci_uart *hu)
253 {
254         struct h4_struct *h4 = hu->priv;
255         return skb_dequeue(&h4->txq);
256 }
257
258 static struct hci_uart_proto h4p = {
259         .id      = HCI_UART_H4,
260         .open    = h4_open,
261         .close   = h4_close,
262         .recv    = h4_recv,
263         .enqueue = h4_enqueue,
264         .dequeue = h4_dequeue,
265         .flush   = h4_flush,
266 };
267               
268 int h4_init(void)
269 {
270         int err = hci_uart_register_proto(&h4p);
271         if (!err)
272                 BT_INFO("HCI H4 protocol initialized");
273         else
274                 BT_ERR("HCI H4 protocol registration failed");
275         
276         return err;
277 }
278
279 int h4_deinit(void)
280 {
281         return hci_uart_unregister_proto(&h4p);
282 }