Linux-2.6.12-rc2
[linux-2.6/kvm.git] / drivers / bluetooth / hci_h4.c
blobade94a57bb11292e15ad3e45f1c7ac3badedb9fc
1 /*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
26 * Bluetooth HCI UART(H4) protocol.
28 * $Id: hci_h4.c,v 1.3 2002/09/09 01:17:32 maxk Exp $
30 #define VERSION "1.2"
32 #include <linux/config.h>
33 #include <linux/module.h>
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>
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>
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h>
54 #include "hci_uart.h"
55 #include "hci_h4.h"
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
64 /* Initialize protocol */
65 static int h4_open(struct hci_uart *hu)
67 struct h4_struct *h4;
69 BT_DBG("hu %p", hu);
71 h4 = kmalloc(sizeof(*h4), GFP_ATOMIC);
72 if (!h4)
73 return -ENOMEM;
74 memset(h4, 0, sizeof(*h4));
76 skb_queue_head_init(&h4->txq);
78 hu->priv = h4;
79 return 0;
82 /* Flush protocol data */
83 static int h4_flush(struct hci_uart *hu)
85 struct h4_struct *h4 = hu->priv;
87 BT_DBG("hu %p", hu);
88 skb_queue_purge(&h4->txq);
89 return 0;
92 /* Close protocol */
93 static int h4_close(struct hci_uart *hu)
95 struct h4_struct *h4 = hu->priv;
96 hu->priv = NULL;
98 BT_DBG("hu %p", hu);
100 skb_queue_purge(&h4->txq);
101 if (h4->rx_skb)
102 kfree_skb(h4->rx_skb);
104 hu->priv = NULL;
105 kfree(h4);
106 return 0;
109 /* Enqueue frame for transmittion (padding, crc, etc) */
110 static int h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
112 struct h4_struct *h4 = hu->priv;
114 BT_DBG("hu %p skb %p", hu, skb);
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;
122 static inline int h4_check_data_len(struct h4_struct *h4, int len)
124 register int room = skb_tailroom(h4->rx_skb);
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;
139 h4->rx_state = H4_W4_PACKET_TYPE;
140 h4->rx_skb = NULL;
141 h4->rx_count = 0;
142 return 0;
145 /* Recv data */
146 static int h4_recv(struct hci_uart *hu, void *data, int count)
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;
155 BT_DBG("hu %p count %d rx_state %ld rx_count %ld",
156 hu, count, h4->rx_state, h4->rx_count);
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;
165 if (h4->rx_count)
166 continue;
168 switch (h4->rx_state) {
169 case H4_W4_DATA:
170 BT_DBG("Complete data");
172 BT_DMP(h4->rx_skb->data, h4->rx_skb->len);
174 hci_recv_frame(h4->rx_skb);
176 h4->rx_state = H4_W4_PACKET_TYPE;
177 h4->rx_skb = NULL;
178 continue;
180 case H4_W4_EVENT_HDR:
181 eh = (struct hci_event_hdr *) h4->rx_skb->data;
183 BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
185 h4_check_data_len(h4, eh->plen);
186 continue;
188 case H4_W4_ACL_HDR:
189 ah = (struct hci_acl_hdr *) h4->rx_skb->data;
190 dlen = __le16_to_cpu(ah->dlen);
192 BT_DBG("ACL header: dlen %d", dlen);
194 h4_check_data_len(h4, dlen);
195 continue;
197 case H4_W4_SCO_HDR:
198 sh = (struct hci_sco_hdr *) h4->rx_skb->data;
200 BT_DBG("SCO header: dlen %d", sh->dlen);
202 h4_check_data_len(h4, sh->dlen);
203 continue;
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;
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;
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;
230 default:
231 BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
232 hu->hdev->stat.err_rx++;
233 ptr++; count--;
234 continue;
236 ptr++; count--;
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;
246 h4->rx_skb->dev = (void *) hu->hdev;
247 h4->rx_skb->pkt_type = type;
249 return count;
252 static struct sk_buff *h4_dequeue(struct hci_uart *hu)
254 struct h4_struct *h4 = hu->priv;
255 return skb_dequeue(&h4->txq);
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,
268 int h4_init(void)
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");
276 return err;
279 int h4_deinit(void)
281 return hci_uart_unregister_proto(&h4p);