ia64/linux-2.6.18-xen.hg

view drivers/bluetooth/hci_usb.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 HCI USB driver for Linux Bluetooth protocol stack (BlueZ)
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6 Copyright (C) 2003 Maxim Krasnyansky <maxk@qualcomm.com>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License version 2 as
10 published by the Free Software Foundation;
12 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
13 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
15 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
16 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
17 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
22 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
23 SOFTWARE IS DISCLAIMED.
24 */
26 /*
27 * Bluetooth HCI USB driver.
28 * Based on original USB Bluetooth driver for Linux kernel
29 * Copyright (c) 2000 Greg Kroah-Hartman <greg@kroah.com>
30 * Copyright (c) 2000 Mark Douglas Corner <mcorner@umich.edu>
31 *
32 */
34 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/init.h>
38 #include <linux/sched.h>
39 #include <linux/unistd.h>
40 #include <linux/types.h>
41 #include <linux/interrupt.h>
42 #include <linux/moduleparam.h>
44 #include <linux/slab.h>
45 #include <linux/errno.h>
46 #include <linux/string.h>
47 #include <linux/skbuff.h>
49 #include <linux/usb.h>
51 #include <net/bluetooth/bluetooth.h>
52 #include <net/bluetooth/hci_core.h>
54 #include "hci_usb.h"
56 #ifndef CONFIG_BT_HCIUSB_DEBUG
57 #undef BT_DBG
58 #define BT_DBG(D...)
59 #endif
61 #ifndef CONFIG_BT_HCIUSB_ZERO_PACKET
62 #undef URB_ZERO_PACKET
63 #define URB_ZERO_PACKET 0
64 #endif
66 static int ignore = 0;
67 static int ignore_dga = 0;
68 static int ignore_csr = 0;
69 static int ignore_sniffer = 0;
70 static int disable_scofix = 0;
71 static int force_scofix = 0;
72 static int reset = 0;
74 #ifdef CONFIG_BT_HCIUSB_SCO
75 static int isoc = 2;
76 #endif
78 #define VERSION "2.9"
80 static struct usb_driver hci_usb_driver;
82 static struct usb_device_id bluetooth_ids[] = {
83 /* Generic Bluetooth USB device */
84 { USB_DEVICE_INFO(HCI_DEV_CLASS, HCI_DEV_SUBCLASS, HCI_DEV_PROTOCOL) },
86 /* AVM BlueFRITZ! USB v2.0 */
87 { USB_DEVICE(0x057c, 0x3800) },
89 /* Bluetooth Ultraport Module from IBM */
90 { USB_DEVICE(0x04bf, 0x030a) },
92 /* ALPS Modules with non-standard id */
93 { USB_DEVICE(0x044e, 0x3001) },
94 { USB_DEVICE(0x044e, 0x3002) },
96 /* Ericsson with non-standard id */
97 { USB_DEVICE(0x0bdb, 0x1002) },
99 { } /* Terminating entry */
100 };
102 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
104 static struct usb_device_id blacklist_ids[] = {
105 /* CSR BlueCore devices */
106 { USB_DEVICE(0x0a12, 0x0001), .driver_info = HCI_CSR },
108 /* Broadcom BCM2033 without firmware */
109 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
111 /* Broadcom BCM2035 */
112 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET | HCI_WRONG_SCO_MTU },
113 { USB_DEVICE(0x0a5c, 0x2009), .driver_info = HCI_BCM92035 },
115 /* IBM/Lenovo ThinkPad with Broadcom chip */
116 { USB_DEVICE(0x0a5c, 0x201e), .driver_info = HCI_WRONG_SCO_MTU },
118 /* Microsoft Wireless Transceiver for Bluetooth 2.0 */
119 { USB_DEVICE(0x045e, 0x009c), .driver_info = HCI_RESET },
121 /* Kensington Bluetooth USB adapter */
122 { USB_DEVICE(0x047d, 0x105d), .driver_info = HCI_RESET },
124 /* ISSC Bluetooth Adapter v3.1 */
125 { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
127 /* RTX Telecom based adapters with buggy SCO support */
128 { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
129 { USB_DEVICE(0x0400, 0x080a), .driver_info = HCI_BROKEN_ISOC },
131 /* Belkin F8T012 and F8T013 devices */
132 { USB_DEVICE(0x050d, 0x0012), .driver_info = HCI_WRONG_SCO_MTU },
133 { USB_DEVICE(0x050d, 0x0013), .driver_info = HCI_WRONG_SCO_MTU },
135 /* Digianswer devices */
136 { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
137 { USB_DEVICE(0x08fd, 0x0002), .driver_info = HCI_IGNORE },
139 /* CSR BlueCore Bluetooth Sniffer */
140 { USB_DEVICE(0x0a12, 0x0002), .driver_info = HCI_SNIFFER },
142 /* Frontline ComProbe Bluetooth Sniffer */
143 { USB_DEVICE(0x16d3, 0x0002), .driver_info = HCI_SNIFFER },
145 { } /* Terminating entry */
146 };
148 static struct _urb *_urb_alloc(int isoc, gfp_t gfp)
149 {
150 struct _urb *_urb = kmalloc(sizeof(struct _urb) +
151 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
152 if (_urb) {
153 memset(_urb, 0, sizeof(*_urb));
154 usb_init_urb(&_urb->urb);
155 }
156 return _urb;
157 }
159 static struct _urb *_urb_dequeue(struct _urb_queue *q)
160 {
161 struct _urb *_urb = NULL;
162 unsigned long flags;
163 spin_lock_irqsave(&q->lock, flags);
164 {
165 struct list_head *head = &q->head;
166 struct list_head *next = head->next;
167 if (next != head) {
168 _urb = list_entry(next, struct _urb, list);
169 list_del(next); _urb->queue = NULL;
170 }
171 }
172 spin_unlock_irqrestore(&q->lock, flags);
173 return _urb;
174 }
176 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
177 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs);
179 #define __pending_tx(husb, type) (&husb->pending_tx[type-1])
180 #define __pending_q(husb, type) (&husb->pending_q[type-1])
181 #define __completed_q(husb, type) (&husb->completed_q[type-1])
182 #define __transmit_q(husb, type) (&husb->transmit_q[type-1])
183 #define __reassembly(husb, type) (husb->reassembly[type-1])
185 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
186 {
187 return _urb_dequeue(__completed_q(husb, type));
188 }
190 #ifdef CONFIG_BT_HCIUSB_SCO
191 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
192 {
193 int offset = 0, i;
195 BT_DBG("len %d mtu %d", len, mtu);
197 for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
198 urb->iso_frame_desc[i].offset = offset;
199 urb->iso_frame_desc[i].length = mtu;
200 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
201 }
202 if (len && i < HCI_MAX_ISOC_FRAMES) {
203 urb->iso_frame_desc[i].offset = offset;
204 urb->iso_frame_desc[i].length = len;
205 BT_DBG("desc %d offset %d len %d", i, offset, len);
206 i++;
207 }
208 urb->number_of_packets = i;
209 }
210 #endif
212 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
213 {
214 struct _urb *_urb;
215 struct urb *urb;
216 int err, pipe, interval, size;
217 void *buf;
219 BT_DBG("%s", husb->hdev->name);
221 size = le16_to_cpu(husb->intr_in_ep->desc.wMaxPacketSize);
223 buf = kmalloc(size, GFP_ATOMIC);
224 if (!buf)
225 return -ENOMEM;
227 _urb = _urb_alloc(0, GFP_ATOMIC);
228 if (!_urb) {
229 kfree(buf);
230 return -ENOMEM;
231 }
232 _urb->type = HCI_EVENT_PKT;
233 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
235 urb = &_urb->urb;
236 pipe = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
237 interval = husb->intr_in_ep->desc.bInterval;
238 usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
240 err = usb_submit_urb(urb, GFP_ATOMIC);
241 if (err) {
242 BT_ERR("%s intr rx submit failed urb %p err %d",
243 husb->hdev->name, urb, err);
244 _urb_unlink(_urb);
245 _urb_free(_urb);
246 kfree(buf);
247 }
248 return err;
249 }
251 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
252 {
253 struct _urb *_urb;
254 struct urb *urb;
255 int err, pipe, size = HCI_MAX_FRAME_SIZE;
256 void *buf;
258 buf = kmalloc(size, GFP_ATOMIC);
259 if (!buf)
260 return -ENOMEM;
262 _urb = _urb_alloc(0, GFP_ATOMIC);
263 if (!_urb) {
264 kfree(buf);
265 return -ENOMEM;
266 }
267 _urb->type = HCI_ACLDATA_PKT;
268 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
270 urb = &_urb->urb;
271 pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
272 usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
273 urb->transfer_flags = 0;
275 BT_DBG("%s urb %p", husb->hdev->name, urb);
277 err = usb_submit_urb(urb, GFP_ATOMIC);
278 if (err) {
279 BT_ERR("%s bulk rx submit failed urb %p err %d",
280 husb->hdev->name, urb, err);
281 _urb_unlink(_urb);
282 _urb_free(_urb);
283 kfree(buf);
284 }
285 return err;
286 }
288 #ifdef CONFIG_BT_HCIUSB_SCO
289 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
290 {
291 struct _urb *_urb;
292 struct urb *urb;
293 int err, mtu, size;
294 void *buf;
296 mtu = le16_to_cpu(husb->isoc_in_ep->desc.wMaxPacketSize);
297 size = mtu * HCI_MAX_ISOC_FRAMES;
299 buf = kmalloc(size, GFP_ATOMIC);
300 if (!buf)
301 return -ENOMEM;
303 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
304 if (!_urb) {
305 kfree(buf);
306 return -ENOMEM;
307 }
308 _urb->type = HCI_SCODATA_PKT;
309 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
311 urb = &_urb->urb;
313 urb->context = husb;
314 urb->dev = husb->udev;
315 urb->pipe = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
316 urb->complete = hci_usb_rx_complete;
318 urb->interval = husb->isoc_in_ep->desc.bInterval;
320 urb->transfer_buffer_length = size;
321 urb->transfer_buffer = buf;
322 urb->transfer_flags = URB_ISO_ASAP;
324 __fill_isoc_desc(urb, size, mtu);
326 BT_DBG("%s urb %p", husb->hdev->name, urb);
328 err = usb_submit_urb(urb, GFP_ATOMIC);
329 if (err) {
330 BT_ERR("%s isoc rx submit failed urb %p err %d",
331 husb->hdev->name, urb, err);
332 _urb_unlink(_urb);
333 _urb_free(_urb);
334 kfree(buf);
335 }
336 return err;
337 }
338 #endif
340 /* Initialize device */
341 static int hci_usb_open(struct hci_dev *hdev)
342 {
343 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
344 int i, err;
345 unsigned long flags;
347 BT_DBG("%s", hdev->name);
349 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
350 return 0;
352 write_lock_irqsave(&husb->completion_lock, flags);
354 err = hci_usb_intr_rx_submit(husb);
355 if (!err) {
356 for (i = 0; i < HCI_MAX_BULK_RX; i++)
357 hci_usb_bulk_rx_submit(husb);
359 #ifdef CONFIG_BT_HCIUSB_SCO
360 if (husb->isoc_iface)
361 for (i = 0; i < HCI_MAX_ISOC_RX; i++)
362 hci_usb_isoc_rx_submit(husb);
363 #endif
364 } else {
365 clear_bit(HCI_RUNNING, &hdev->flags);
366 }
368 write_unlock_irqrestore(&husb->completion_lock, flags);
369 return err;
370 }
372 /* Reset device */
373 static int hci_usb_flush(struct hci_dev *hdev)
374 {
375 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
376 int i;
378 BT_DBG("%s", hdev->name);
380 for (i = 0; i < 4; i++)
381 skb_queue_purge(&husb->transmit_q[i]);
382 return 0;
383 }
385 static void hci_usb_unlink_urbs(struct hci_usb *husb)
386 {
387 int i;
389 BT_DBG("%s", husb->hdev->name);
391 for (i = 0; i < 4; i++) {
392 struct _urb *_urb;
393 struct urb *urb;
395 /* Kill pending requests */
396 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
397 urb = &_urb->urb;
398 BT_DBG("%s unlinking _urb %p type %d urb %p",
399 husb->hdev->name, _urb, _urb->type, urb);
400 usb_kill_urb(urb);
401 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
402 }
404 /* Release completed requests */
405 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
406 urb = &_urb->urb;
407 BT_DBG("%s freeing _urb %p type %d urb %p",
408 husb->hdev->name, _urb, _urb->type, urb);
409 kfree(urb->setup_packet);
410 kfree(urb->transfer_buffer);
411 _urb_free(_urb);
412 }
414 /* Release reassembly buffers */
415 if (husb->reassembly[i]) {
416 kfree_skb(husb->reassembly[i]);
417 husb->reassembly[i] = NULL;
418 }
419 }
420 }
422 /* Close device */
423 static int hci_usb_close(struct hci_dev *hdev)
424 {
425 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
426 unsigned long flags;
428 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
429 return 0;
431 BT_DBG("%s", hdev->name);
433 /* Synchronize with completion handlers */
434 write_lock_irqsave(&husb->completion_lock, flags);
435 write_unlock_irqrestore(&husb->completion_lock, flags);
437 hci_usb_unlink_urbs(husb);
438 hci_usb_flush(hdev);
439 return 0;
440 }
442 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
443 {
444 struct urb *urb = &_urb->urb;
445 int err;
447 BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
449 _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
450 err = usb_submit_urb(urb, GFP_ATOMIC);
451 if (err) {
452 BT_ERR("%s tx submit failed urb %p type %d err %d",
453 husb->hdev->name, urb, _urb->type, err);
454 _urb_unlink(_urb);
455 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
456 } else
457 atomic_inc(__pending_tx(husb, _urb->type));
459 return err;
460 }
462 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
463 {
464 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
465 struct usb_ctrlrequest *dr;
466 struct urb *urb;
468 if (!_urb) {
469 _urb = _urb_alloc(0, GFP_ATOMIC);
470 if (!_urb)
471 return -ENOMEM;
472 _urb->type = bt_cb(skb)->pkt_type;
474 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
475 if (!dr) {
476 _urb_free(_urb);
477 return -ENOMEM;
478 }
479 } else
480 dr = (void *) _urb->urb.setup_packet;
482 dr->bRequestType = husb->ctrl_req;
483 dr->bRequest = 0;
484 dr->wIndex = 0;
485 dr->wValue = 0;
486 dr->wLength = __cpu_to_le16(skb->len);
488 urb = &_urb->urb;
489 usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
490 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
492 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
494 _urb->priv = skb;
495 return __tx_submit(husb, _urb);
496 }
498 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
499 {
500 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
501 struct urb *urb;
502 int pipe;
504 if (!_urb) {
505 _urb = _urb_alloc(0, GFP_ATOMIC);
506 if (!_urb)
507 return -ENOMEM;
508 _urb->type = bt_cb(skb)->pkt_type;
509 }
511 urb = &_urb->urb;
512 pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
513 usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
514 hci_usb_tx_complete, husb);
515 urb->transfer_flags = URB_ZERO_PACKET;
517 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
519 _urb->priv = skb;
520 return __tx_submit(husb, _urb);
521 }
523 #ifdef CONFIG_BT_HCIUSB_SCO
524 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
525 {
526 struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
527 struct urb *urb;
529 if (!_urb) {
530 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
531 if (!_urb)
532 return -ENOMEM;
533 _urb->type = bt_cb(skb)->pkt_type;
534 }
536 BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
538 urb = &_urb->urb;
540 urb->context = husb;
541 urb->dev = husb->udev;
542 urb->pipe = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
543 urb->complete = hci_usb_tx_complete;
544 urb->transfer_flags = URB_ISO_ASAP;
546 urb->interval = husb->isoc_out_ep->desc.bInterval;
548 urb->transfer_buffer = skb->data;
549 urb->transfer_buffer_length = skb->len;
551 __fill_isoc_desc(urb, skb->len, le16_to_cpu(husb->isoc_out_ep->desc.wMaxPacketSize));
553 _urb->priv = skb;
554 return __tx_submit(husb, _urb);
555 }
556 #endif
558 static void hci_usb_tx_process(struct hci_usb *husb)
559 {
560 struct sk_buff_head *q;
561 struct sk_buff *skb;
563 BT_DBG("%s", husb->hdev->name);
565 do {
566 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
568 /* Process command queue */
569 q = __transmit_q(husb, HCI_COMMAND_PKT);
570 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
571 (skb = skb_dequeue(q))) {
572 if (hci_usb_send_ctrl(husb, skb) < 0)
573 skb_queue_head(q, skb);
574 }
576 #ifdef CONFIG_BT_HCIUSB_SCO
577 /* Process SCO queue */
578 q = __transmit_q(husb, HCI_SCODATA_PKT);
579 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
580 (skb = skb_dequeue(q))) {
581 if (hci_usb_send_isoc(husb, skb) < 0)
582 skb_queue_head(q, skb);
583 }
584 #endif
586 /* Process ACL queue */
587 q = __transmit_q(husb, HCI_ACLDATA_PKT);
588 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
589 (skb = skb_dequeue(q))) {
590 if (hci_usb_send_bulk(husb, skb) < 0) {
591 skb_queue_head(q, skb);
592 break;
593 }
594 }
595 } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
596 }
598 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
599 {
600 /* Serialize TX queue processing to avoid data reordering */
601 if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
602 hci_usb_tx_process(husb);
603 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
604 } else
605 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
606 }
608 /* Send frames from HCI layer */
609 static int hci_usb_send_frame(struct sk_buff *skb)
610 {
611 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
612 struct hci_usb *husb;
614 if (!hdev) {
615 BT_ERR("frame for uknown device (hdev=NULL)");
616 return -ENODEV;
617 }
619 if (!test_bit(HCI_RUNNING, &hdev->flags))
620 return -EBUSY;
622 BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
624 husb = (struct hci_usb *) hdev->driver_data;
626 switch (bt_cb(skb)->pkt_type) {
627 case HCI_COMMAND_PKT:
628 hdev->stat.cmd_tx++;
629 break;
631 case HCI_ACLDATA_PKT:
632 hdev->stat.acl_tx++;
633 break;
635 #ifdef CONFIG_BT_HCIUSB_SCO
636 case HCI_SCODATA_PKT:
637 hdev->stat.sco_tx++;
638 break;
639 #endif
641 default:
642 kfree_skb(skb);
643 return 0;
644 }
646 read_lock(&husb->completion_lock);
648 skb_queue_tail(__transmit_q(husb, bt_cb(skb)->pkt_type), skb);
649 hci_usb_tx_wakeup(husb);
651 read_unlock(&husb->completion_lock);
652 return 0;
653 }
655 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
656 {
657 BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
659 husb->hdev->stat.byte_rx += count;
661 while (count) {
662 struct sk_buff *skb = __reassembly(husb, type);
663 struct { int expect; } *scb;
664 int len = 0;
666 if (!skb) {
667 /* Start of the frame */
669 switch (type) {
670 case HCI_EVENT_PKT:
671 if (count >= HCI_EVENT_HDR_SIZE) {
672 struct hci_event_hdr *h = data;
673 len = HCI_EVENT_HDR_SIZE + h->plen;
674 } else
675 return -EILSEQ;
676 break;
678 case HCI_ACLDATA_PKT:
679 if (count >= HCI_ACL_HDR_SIZE) {
680 struct hci_acl_hdr *h = data;
681 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
682 } else
683 return -EILSEQ;
684 break;
685 #ifdef CONFIG_BT_HCIUSB_SCO
686 case HCI_SCODATA_PKT:
687 if (count >= HCI_SCO_HDR_SIZE) {
688 struct hci_sco_hdr *h = data;
689 len = HCI_SCO_HDR_SIZE + h->dlen;
690 } else
691 return -EILSEQ;
692 break;
693 #endif
694 }
695 BT_DBG("new packet len %d", len);
697 skb = bt_skb_alloc(len, GFP_ATOMIC);
698 if (!skb) {
699 BT_ERR("%s no memory for the packet", husb->hdev->name);
700 return -ENOMEM;
701 }
702 skb->dev = (void *) husb->hdev;
703 bt_cb(skb)->pkt_type = type;
705 __reassembly(husb, type) = skb;
707 scb = (void *) skb->cb;
708 scb->expect = len;
709 } else {
710 /* Continuation */
711 scb = (void *) skb->cb;
712 len = scb->expect;
713 }
715 len = min(len, count);
717 memcpy(skb_put(skb, len), data, len);
719 scb->expect -= len;
720 if (!scb->expect) {
721 /* Complete frame */
722 __reassembly(husb, type) = NULL;
723 bt_cb(skb)->pkt_type = type;
724 hci_recv_frame(skb);
725 }
727 count -= len; data += len;
728 }
729 return 0;
730 }
732 static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
733 {
734 struct _urb *_urb = container_of(urb, struct _urb, urb);
735 struct hci_usb *husb = (void *) urb->context;
736 struct hci_dev *hdev = husb->hdev;
737 int err, count = urb->actual_length;
739 BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
740 _urb->type, urb->status, count, urb->transfer_flags);
742 read_lock(&husb->completion_lock);
744 if (!test_bit(HCI_RUNNING, &hdev->flags))
745 goto unlock;
747 if (urb->status || !count)
748 goto resubmit;
750 if (_urb->type == HCI_SCODATA_PKT) {
751 #ifdef CONFIG_BT_HCIUSB_SCO
752 int i;
753 for (i=0; i < urb->number_of_packets; i++) {
754 BT_DBG("desc %d status %d offset %d len %d", i,
755 urb->iso_frame_desc[i].status,
756 urb->iso_frame_desc[i].offset,
757 urb->iso_frame_desc[i].actual_length);
759 if (!urb->iso_frame_desc[i].status)
760 __recv_frame(husb, _urb->type,
761 urb->transfer_buffer + urb->iso_frame_desc[i].offset,
762 urb->iso_frame_desc[i].actual_length);
763 }
764 #else
765 ;
766 #endif
767 } else {
768 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
769 if (err < 0) {
770 BT_ERR("%s corrupted packet: type %d count %d",
771 husb->hdev->name, _urb->type, count);
772 hdev->stat.err_rx++;
773 }
774 }
776 resubmit:
777 urb->dev = husb->udev;
778 err = usb_submit_urb(urb, GFP_ATOMIC);
779 BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
780 _urb->type, err);
782 unlock:
783 read_unlock(&husb->completion_lock);
784 }
786 static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs)
787 {
788 struct _urb *_urb = container_of(urb, struct _urb, urb);
789 struct hci_usb *husb = (void *) urb->context;
790 struct hci_dev *hdev = husb->hdev;
792 BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
793 urb->status, urb->transfer_flags);
795 atomic_dec(__pending_tx(husb, _urb->type));
797 urb->transfer_buffer = NULL;
798 kfree_skb((struct sk_buff *) _urb->priv);
800 if (!test_bit(HCI_RUNNING, &hdev->flags))
801 return;
803 if (!urb->status)
804 hdev->stat.byte_tx += urb->transfer_buffer_length;
805 else
806 hdev->stat.err_tx++;
808 read_lock(&husb->completion_lock);
810 _urb_unlink(_urb);
811 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
813 hci_usb_tx_wakeup(husb);
815 read_unlock(&husb->completion_lock);
816 }
818 static void hci_usb_destruct(struct hci_dev *hdev)
819 {
820 struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
822 BT_DBG("%s", hdev->name);
824 kfree(husb);
825 }
827 static void hci_usb_notify(struct hci_dev *hdev, unsigned int evt)
828 {
829 BT_DBG("%s evt %d", hdev->name, evt);
830 }
832 static int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
833 {
834 struct usb_device *udev = interface_to_usbdev(intf);
835 struct usb_host_endpoint *bulk_out_ep = NULL;
836 struct usb_host_endpoint *bulk_in_ep = NULL;
837 struct usb_host_endpoint *intr_in_ep = NULL;
838 struct usb_host_endpoint *ep;
839 struct usb_host_interface *uif;
840 struct usb_interface *isoc_iface;
841 struct hci_usb *husb;
842 struct hci_dev *hdev;
843 int i, e, size, isoc_ifnum, isoc_alts;
845 BT_DBG("udev %p intf %p", udev, intf);
847 if (!id->driver_info) {
848 const struct usb_device_id *match;
849 match = usb_match_id(intf, blacklist_ids);
850 if (match)
851 id = match;
852 }
854 if (ignore || id->driver_info & HCI_IGNORE)
855 return -ENODEV;
857 if (ignore_dga && id->driver_info & HCI_DIGIANSWER)
858 return -ENODEV;
860 if (ignore_csr && id->driver_info & HCI_CSR)
861 return -ENODEV;
863 if (ignore_sniffer && id->driver_info & HCI_SNIFFER)
864 return -ENODEV;
866 if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
867 return -ENODEV;
869 /* Find endpoints that we need */
870 uif = intf->cur_altsetting;
871 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
872 ep = &uif->endpoint[e];
874 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
875 case USB_ENDPOINT_XFER_INT:
876 if (ep->desc.bEndpointAddress & USB_DIR_IN)
877 intr_in_ep = ep;
878 break;
880 case USB_ENDPOINT_XFER_BULK:
881 if (ep->desc.bEndpointAddress & USB_DIR_IN)
882 bulk_in_ep = ep;
883 else
884 bulk_out_ep = ep;
885 break;
886 }
887 }
889 if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
890 BT_DBG("Bulk endpoints not found");
891 goto done;
892 }
894 if (!(husb = kzalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
895 BT_ERR("Can't allocate: control structure");
896 goto done;
897 }
899 husb->udev = udev;
900 husb->bulk_out_ep = bulk_out_ep;
901 husb->bulk_in_ep = bulk_in_ep;
902 husb->intr_in_ep = intr_in_ep;
904 if (id->driver_info & HCI_DIGIANSWER)
905 husb->ctrl_req = USB_TYPE_VENDOR;
906 else
907 husb->ctrl_req = USB_TYPE_CLASS;
909 /* Find isochronous endpoints that we can use */
910 size = 0;
911 isoc_iface = NULL;
912 isoc_alts = 0;
913 isoc_ifnum = 1;
915 #ifdef CONFIG_BT_HCIUSB_SCO
916 if (isoc && !(id->driver_info & (HCI_BROKEN_ISOC | HCI_SNIFFER)))
917 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
919 if (isoc_iface) {
920 int a;
921 struct usb_host_endpoint *isoc_out_ep = NULL;
922 struct usb_host_endpoint *isoc_in_ep = NULL;
924 for (a = 0; a < isoc_iface->num_altsetting; a++) {
925 uif = &isoc_iface->altsetting[a];
926 for (e = 0; e < uif->desc.bNumEndpoints; e++) {
927 ep = &uif->endpoint[e];
929 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
930 case USB_ENDPOINT_XFER_ISOC:
931 if (le16_to_cpu(ep->desc.wMaxPacketSize) < size ||
932 uif->desc.bAlternateSetting != isoc)
933 break;
934 size = le16_to_cpu(ep->desc.wMaxPacketSize);
936 isoc_alts = uif->desc.bAlternateSetting;
938 if (ep->desc.bEndpointAddress & USB_DIR_IN)
939 isoc_in_ep = ep;
940 else
941 isoc_out_ep = ep;
942 break;
943 }
944 }
945 }
947 if (!isoc_in_ep || !isoc_out_ep)
948 BT_DBG("Isoc endpoints not found");
949 else {
950 BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
951 if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
952 BT_ERR("Can't claim isoc interface");
953 else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
954 BT_ERR("Can't set isoc interface settings");
955 husb->isoc_iface = isoc_iface;
956 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
957 husb->isoc_iface = NULL;
958 } else {
959 husb->isoc_iface = isoc_iface;
960 husb->isoc_in_ep = isoc_in_ep;
961 husb->isoc_out_ep = isoc_out_ep;
962 }
963 }
964 }
965 #endif
967 rwlock_init(&husb->completion_lock);
969 for (i = 0; i < 4; i++) {
970 skb_queue_head_init(&husb->transmit_q[i]);
971 _urb_queue_init(&husb->pending_q[i]);
972 _urb_queue_init(&husb->completed_q[i]);
973 }
975 /* Initialize and register HCI device */
976 hdev = hci_alloc_dev();
977 if (!hdev) {
978 BT_ERR("Can't allocate HCI device");
979 goto probe_error;
980 }
982 husb->hdev = hdev;
984 hdev->type = HCI_USB;
985 hdev->driver_data = husb;
986 SET_HCIDEV_DEV(hdev, &intf->dev);
988 hdev->open = hci_usb_open;
989 hdev->close = hci_usb_close;
990 hdev->flush = hci_usb_flush;
991 hdev->send = hci_usb_send_frame;
992 hdev->destruct = hci_usb_destruct;
993 hdev->notify = hci_usb_notify;
995 hdev->owner = THIS_MODULE;
997 if (reset || id->driver_info & HCI_RESET)
998 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
1000 if (force_scofix || id->driver_info & HCI_WRONG_SCO_MTU) {
1001 if (!disable_scofix)
1002 set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
1005 if (id->driver_info & HCI_SNIFFER) {
1006 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
1007 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
1010 if (id->driver_info & HCI_BCM92035) {
1011 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
1012 struct sk_buff *skb;
1014 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
1015 if (skb) {
1016 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
1017 skb_queue_tail(&hdev->driver_init, skb);
1021 if (hci_register_dev(hdev) < 0) {
1022 BT_ERR("Can't register HCI device");
1023 hci_free_dev(hdev);
1024 goto probe_error;
1027 usb_set_intfdata(intf, husb);
1028 return 0;
1030 probe_error:
1031 if (husb->isoc_iface)
1032 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1033 kfree(husb);
1035 done:
1036 return -EIO;
1039 static void hci_usb_disconnect(struct usb_interface *intf)
1041 struct hci_usb *husb = usb_get_intfdata(intf);
1042 struct hci_dev *hdev;
1044 if (!husb || intf == husb->isoc_iface)
1045 return;
1047 usb_set_intfdata(intf, NULL);
1048 hdev = husb->hdev;
1050 BT_DBG("%s", hdev->name);
1052 hci_usb_close(hdev);
1054 if (husb->isoc_iface)
1055 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1057 if (hci_unregister_dev(hdev) < 0)
1058 BT_ERR("Can't unregister HCI device %s", hdev->name);
1060 hci_free_dev(hdev);
1063 static int hci_usb_suspend(struct usb_interface *intf, pm_message_t message)
1065 struct hci_usb *husb = usb_get_intfdata(intf);
1066 struct list_head killed;
1067 unsigned long flags;
1068 int i;
1070 if (!husb || intf == husb->isoc_iface)
1071 return 0;
1073 hci_suspend_dev(husb->hdev);
1075 INIT_LIST_HEAD(&killed);
1077 for (i = 0; i < 4; i++) {
1078 struct _urb_queue *q = &husb->pending_q[i];
1079 struct _urb *_urb, *_tmp;
1081 while ((_urb = _urb_dequeue(q))) {
1082 /* reset queue since _urb_dequeue sets it to NULL */
1083 _urb->queue = q;
1084 usb_kill_urb(&_urb->urb);
1085 list_add(&_urb->list, &killed);
1088 spin_lock_irqsave(&q->lock, flags);
1090 list_for_each_entry_safe(_urb, _tmp, &killed, list) {
1091 list_move_tail(&_urb->list, &q->head);
1094 spin_unlock_irqrestore(&q->lock, flags);
1097 return 0;
1100 static int hci_usb_resume(struct usb_interface *intf)
1102 struct hci_usb *husb = usb_get_intfdata(intf);
1103 unsigned long flags;
1104 int i, err = 0;
1106 if (!husb || intf == husb->isoc_iface)
1107 return 0;
1109 for (i = 0; i < 4; i++) {
1110 struct _urb_queue *q = &husb->pending_q[i];
1111 struct _urb *_urb;
1113 spin_lock_irqsave(&q->lock, flags);
1115 list_for_each_entry(_urb, &q->head, list) {
1116 err = usb_submit_urb(&_urb->urb, GFP_ATOMIC);
1117 if (err)
1118 break;
1121 spin_unlock_irqrestore(&q->lock, flags);
1123 if (err)
1124 return -EIO;
1127 hci_resume_dev(husb->hdev);
1129 return 0;
1132 static struct usb_driver hci_usb_driver = {
1133 .name = "hci_usb",
1134 .probe = hci_usb_probe,
1135 .disconnect = hci_usb_disconnect,
1136 .suspend = hci_usb_suspend,
1137 .resume = hci_usb_resume,
1138 .id_table = bluetooth_ids,
1139 };
1141 static int __init hci_usb_init(void)
1143 int err;
1145 BT_INFO("HCI USB driver ver %s", VERSION);
1147 if ((err = usb_register(&hci_usb_driver)) < 0)
1148 BT_ERR("Failed to register HCI USB driver");
1150 return err;
1153 static void __exit hci_usb_exit(void)
1155 usb_deregister(&hci_usb_driver);
1158 module_init(hci_usb_init);
1159 module_exit(hci_usb_exit);
1161 module_param(ignore, bool, 0644);
1162 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
1164 module_param(ignore_dga, bool, 0644);
1165 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
1167 module_param(ignore_csr, bool, 0644);
1168 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1170 module_param(ignore_sniffer, bool, 0644);
1171 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1173 module_param(disable_scofix, bool, 0644);
1174 MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
1176 module_param(force_scofix, bool, 0644);
1177 MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
1179 module_param(reset, bool, 0644);
1180 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1182 #ifdef CONFIG_BT_HCIUSB_SCO
1183 module_param(isoc, int, 0644);
1184 MODULE_PARM_DESC(isoc, "Set isochronous transfers for SCO over HCI support");
1185 #endif
1187 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1188 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1189 MODULE_VERSION(VERSION);
1190 MODULE_LICENSE("GPL");