ia64/linux-2.6.18-xen.hg

view drivers/bluetooth/bfusb.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 *
3 * AVM BlueFRITZ! USB driver
4 *
5 * Copyright (C) 2003 Marcel Holtmann <marcel@holtmann.org>
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
24 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/errno.h>
32 #include <linux/skbuff.h>
34 #include <linux/device.h>
35 #include <linux/firmware.h>
37 #include <linux/usb.h>
39 #include <net/bluetooth/bluetooth.h>
40 #include <net/bluetooth/hci_core.h>
42 #ifndef CONFIG_BT_HCIBFUSB_DEBUG
43 #undef BT_DBG
44 #define BT_DBG(D...)
45 #endif
47 #define VERSION "1.1"
49 static int ignore = 0;
51 static struct usb_driver bfusb_driver;
53 static struct usb_device_id bfusb_table[] = {
54 /* AVM BlueFRITZ! USB */
55 { USB_DEVICE(0x057c, 0x2200) },
57 { } /* Terminating entry */
58 };
60 MODULE_DEVICE_TABLE(usb, bfusb_table);
63 #define BFUSB_MAX_BLOCK_SIZE 256
65 #define BFUSB_BLOCK_TIMEOUT 3000
67 #define BFUSB_TX_PROCESS 1
68 #define BFUSB_TX_WAKEUP 2
70 #define BFUSB_MAX_BULK_TX 2
71 #define BFUSB_MAX_BULK_RX 2
73 struct bfusb {
74 struct hci_dev *hdev;
76 unsigned long state;
78 struct usb_device *udev;
80 unsigned int bulk_in_ep;
81 unsigned int bulk_out_ep;
82 unsigned int bulk_pkt_size;
84 rwlock_t lock;
86 struct sk_buff_head transmit_q;
88 struct sk_buff *reassembly;
90 atomic_t pending_tx;
91 struct sk_buff_head pending_q;
92 struct sk_buff_head completed_q;
93 };
95 struct bfusb_scb {
96 struct urb *urb;
97 };
99 static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs);
100 static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs);
102 static struct urb *bfusb_get_completed(struct bfusb *bfusb)
103 {
104 struct sk_buff *skb;
105 struct urb *urb = NULL;
107 BT_DBG("bfusb %p", bfusb);
109 skb = skb_dequeue(&bfusb->completed_q);
110 if (skb) {
111 urb = ((struct bfusb_scb *) skb->cb)->urb;
112 kfree_skb(skb);
113 }
115 return urb;
116 }
118 static void bfusb_unlink_urbs(struct bfusb *bfusb)
119 {
120 struct sk_buff *skb;
121 struct urb *urb;
123 BT_DBG("bfusb %p", bfusb);
125 while ((skb = skb_dequeue(&bfusb->pending_q))) {
126 urb = ((struct bfusb_scb *) skb->cb)->urb;
127 usb_kill_urb(urb);
128 skb_queue_tail(&bfusb->completed_q, skb);
129 }
131 while ((urb = bfusb_get_completed(bfusb)))
132 usb_free_urb(urb);
133 }
136 static int bfusb_send_bulk(struct bfusb *bfusb, struct sk_buff *skb)
137 {
138 struct bfusb_scb *scb = (void *) skb->cb;
139 struct urb *urb = bfusb_get_completed(bfusb);
140 int err, pipe;
142 BT_DBG("bfusb %p skb %p len %d", bfusb, skb, skb->len);
144 if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
145 return -ENOMEM;
147 pipe = usb_sndbulkpipe(bfusb->udev, bfusb->bulk_out_ep);
149 usb_fill_bulk_urb(urb, bfusb->udev, pipe, skb->data, skb->len,
150 bfusb_tx_complete, skb);
152 scb->urb = urb;
154 skb_queue_tail(&bfusb->pending_q, skb);
156 err = usb_submit_urb(urb, GFP_ATOMIC);
157 if (err) {
158 BT_ERR("%s bulk tx submit failed urb %p err %d",
159 bfusb->hdev->name, urb, err);
160 skb_unlink(skb, &bfusb->pending_q);
161 usb_free_urb(urb);
162 } else
163 atomic_inc(&bfusb->pending_tx);
165 return err;
166 }
168 static void bfusb_tx_wakeup(struct bfusb *bfusb)
169 {
170 struct sk_buff *skb;
172 BT_DBG("bfusb %p", bfusb);
174 if (test_and_set_bit(BFUSB_TX_PROCESS, &bfusb->state)) {
175 set_bit(BFUSB_TX_WAKEUP, &bfusb->state);
176 return;
177 }
179 do {
180 clear_bit(BFUSB_TX_WAKEUP, &bfusb->state);
182 while ((atomic_read(&bfusb->pending_tx) < BFUSB_MAX_BULK_TX) &&
183 (skb = skb_dequeue(&bfusb->transmit_q))) {
184 if (bfusb_send_bulk(bfusb, skb) < 0) {
185 skb_queue_head(&bfusb->transmit_q, skb);
186 break;
187 }
188 }
190 } while (test_bit(BFUSB_TX_WAKEUP, &bfusb->state));
192 clear_bit(BFUSB_TX_PROCESS, &bfusb->state);
193 }
195 static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs)
196 {
197 struct sk_buff *skb = (struct sk_buff *) urb->context;
198 struct bfusb *bfusb = (struct bfusb *) skb->dev;
200 BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
202 atomic_dec(&bfusb->pending_tx);
204 if (!test_bit(HCI_RUNNING, &bfusb->hdev->flags))
205 return;
207 if (!urb->status)
208 bfusb->hdev->stat.byte_tx += skb->len;
209 else
210 bfusb->hdev->stat.err_tx++;
212 read_lock(&bfusb->lock);
214 skb_unlink(skb, &bfusb->pending_q);
215 skb_queue_tail(&bfusb->completed_q, skb);
217 bfusb_tx_wakeup(bfusb);
219 read_unlock(&bfusb->lock);
220 }
223 static int bfusb_rx_submit(struct bfusb *bfusb, struct urb *urb)
224 {
225 struct bfusb_scb *scb;
226 struct sk_buff *skb;
227 int err, pipe, size = HCI_MAX_FRAME_SIZE + 32;
229 BT_DBG("bfusb %p urb %p", bfusb, urb);
231 if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
232 return -ENOMEM;
234 if (!(skb = bt_skb_alloc(size, GFP_ATOMIC))) {
235 usb_free_urb(urb);
236 return -ENOMEM;
237 }
239 skb->dev = (void *) bfusb;
241 scb = (struct bfusb_scb *) skb->cb;
242 scb->urb = urb;
244 pipe = usb_rcvbulkpipe(bfusb->udev, bfusb->bulk_in_ep);
246 usb_fill_bulk_urb(urb, bfusb->udev, pipe, skb->data, size,
247 bfusb_rx_complete, skb);
249 skb_queue_tail(&bfusb->pending_q, skb);
251 err = usb_submit_urb(urb, GFP_ATOMIC);
252 if (err) {
253 BT_ERR("%s bulk rx submit failed urb %p err %d",
254 bfusb->hdev->name, urb, err);
255 skb_unlink(skb, &bfusb->pending_q);
256 kfree_skb(skb);
257 usb_free_urb(urb);
258 }
260 return err;
261 }
263 static inline int bfusb_recv_block(struct bfusb *bfusb, int hdr, unsigned char *data, int len)
264 {
265 BT_DBG("bfusb %p hdr 0x%02x data %p len %d", bfusb, hdr, data, len);
267 if (hdr & 0x10) {
268 BT_ERR("%s error in block", bfusb->hdev->name);
269 if (bfusb->reassembly)
270 kfree_skb(bfusb->reassembly);
271 bfusb->reassembly = NULL;
272 return -EIO;
273 }
275 if (hdr & 0x04) {
276 struct sk_buff *skb;
277 unsigned char pkt_type;
278 int pkt_len = 0;
280 if (bfusb->reassembly) {
281 BT_ERR("%s unexpected start block", bfusb->hdev->name);
282 kfree_skb(bfusb->reassembly);
283 bfusb->reassembly = NULL;
284 }
286 if (len < 1) {
287 BT_ERR("%s no packet type found", bfusb->hdev->name);
288 return -EPROTO;
289 }
291 pkt_type = *data++; len--;
293 switch (pkt_type) {
294 case HCI_EVENT_PKT:
295 if (len >= HCI_EVENT_HDR_SIZE) {
296 struct hci_event_hdr *hdr = (struct hci_event_hdr *) data;
297 pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen;
298 } else {
299 BT_ERR("%s event block is too short", bfusb->hdev->name);
300 return -EILSEQ;
301 }
302 break;
304 case HCI_ACLDATA_PKT:
305 if (len >= HCI_ACL_HDR_SIZE) {
306 struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) data;
307 pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen);
308 } else {
309 BT_ERR("%s data block is too short", bfusb->hdev->name);
310 return -EILSEQ;
311 }
312 break;
314 case HCI_SCODATA_PKT:
315 if (len >= HCI_SCO_HDR_SIZE) {
316 struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) data;
317 pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen;
318 } else {
319 BT_ERR("%s audio block is too short", bfusb->hdev->name);
320 return -EILSEQ;
321 }
322 break;
323 }
325 skb = bt_skb_alloc(pkt_len, GFP_ATOMIC);
326 if (!skb) {
327 BT_ERR("%s no memory for the packet", bfusb->hdev->name);
328 return -ENOMEM;
329 }
331 skb->dev = (void *) bfusb->hdev;
332 bt_cb(skb)->pkt_type = pkt_type;
334 bfusb->reassembly = skb;
335 } else {
336 if (!bfusb->reassembly) {
337 BT_ERR("%s unexpected continuation block", bfusb->hdev->name);
338 return -EIO;
339 }
340 }
342 if (len > 0)
343 memcpy(skb_put(bfusb->reassembly, len), data, len);
345 if (hdr & 0x08) {
346 hci_recv_frame(bfusb->reassembly);
347 bfusb->reassembly = NULL;
348 }
350 return 0;
351 }
353 static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs)
354 {
355 struct sk_buff *skb = (struct sk_buff *) urb->context;
356 struct bfusb *bfusb = (struct bfusb *) skb->dev;
357 unsigned char *buf = urb->transfer_buffer;
358 int count = urb->actual_length;
359 int err, hdr, len;
361 BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
363 read_lock(&bfusb->lock);
365 if (!test_bit(HCI_RUNNING, &bfusb->hdev->flags))
366 goto unlock;
368 if (urb->status || !count)
369 goto resubmit;
371 bfusb->hdev->stat.byte_rx += count;
373 skb_put(skb, count);
375 while (count) {
376 hdr = buf[0] | (buf[1] << 8);
378 if (hdr & 0x4000) {
379 len = 0;
380 count -= 2;
381 buf += 2;
382 } else {
383 len = (buf[2] == 0) ? 256 : buf[2];
384 count -= 3;
385 buf += 3;
386 }
388 if (count < len) {
389 BT_ERR("%s block extends over URB buffer ranges",
390 bfusb->hdev->name);
391 }
393 if ((hdr & 0xe1) == 0xc1)
394 bfusb_recv_block(bfusb, hdr, buf, len);
396 count -= len;
397 buf += len;
398 }
400 skb_unlink(skb, &bfusb->pending_q);
401 kfree_skb(skb);
403 bfusb_rx_submit(bfusb, urb);
405 read_unlock(&bfusb->lock);
407 return;
409 resubmit:
410 urb->dev = bfusb->udev;
412 err = usb_submit_urb(urb, GFP_ATOMIC);
413 if (err) {
414 BT_ERR("%s bulk resubmit failed urb %p err %d",
415 bfusb->hdev->name, urb, err);
416 }
418 unlock:
419 read_unlock(&bfusb->lock);
420 }
423 static int bfusb_open(struct hci_dev *hdev)
424 {
425 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
426 unsigned long flags;
427 int i, err;
429 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
431 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
432 return 0;
434 write_lock_irqsave(&bfusb->lock, flags);
436 err = bfusb_rx_submit(bfusb, NULL);
437 if (!err) {
438 for (i = 1; i < BFUSB_MAX_BULK_RX; i++)
439 bfusb_rx_submit(bfusb, NULL);
440 } else {
441 clear_bit(HCI_RUNNING, &hdev->flags);
442 }
444 write_unlock_irqrestore(&bfusb->lock, flags);
446 return err;
447 }
449 static int bfusb_flush(struct hci_dev *hdev)
450 {
451 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
453 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
455 skb_queue_purge(&bfusb->transmit_q);
457 return 0;
458 }
460 static int bfusb_close(struct hci_dev *hdev)
461 {
462 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
463 unsigned long flags;
465 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
467 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
468 return 0;
470 write_lock_irqsave(&bfusb->lock, flags);
471 write_unlock_irqrestore(&bfusb->lock, flags);
473 bfusb_unlink_urbs(bfusb);
474 bfusb_flush(hdev);
476 return 0;
477 }
479 static int bfusb_send_frame(struct sk_buff *skb)
480 {
481 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
482 struct bfusb *bfusb;
483 struct sk_buff *nskb;
484 unsigned char buf[3];
485 int sent = 0, size, count;
487 BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len);
489 if (!hdev) {
490 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
491 return -ENODEV;
492 }
494 if (!test_bit(HCI_RUNNING, &hdev->flags))
495 return -EBUSY;
497 bfusb = (struct bfusb *) hdev->driver_data;
499 switch (bt_cb(skb)->pkt_type) {
500 case HCI_COMMAND_PKT:
501 hdev->stat.cmd_tx++;
502 break;
503 case HCI_ACLDATA_PKT:
504 hdev->stat.acl_tx++;
505 break;
506 case HCI_SCODATA_PKT:
507 hdev->stat.sco_tx++;
508 break;
509 };
511 /* Prepend skb with frame type */
512 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
514 count = skb->len;
516 /* Max HCI frame size seems to be 1511 + 1 */
517 if (!(nskb = bt_skb_alloc(count + 32, GFP_ATOMIC))) {
518 BT_ERR("Can't allocate memory for new packet");
519 return -ENOMEM;
520 }
522 nskb->dev = (void *) bfusb;
524 while (count) {
525 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE);
527 buf[0] = 0xc1 | ((sent == 0) ? 0x04 : 0) | ((count == size) ? 0x08 : 0);
528 buf[1] = 0x00;
529 buf[2] = (size == BFUSB_MAX_BLOCK_SIZE) ? 0 : size;
531 memcpy(skb_put(nskb, 3), buf, 3);
532 memcpy(skb_put(nskb, size), skb->data + sent, size);
534 sent += size;
535 count -= size;
536 }
538 /* Don't send frame with multiple size of bulk max packet */
539 if ((nskb->len % bfusb->bulk_pkt_size) == 0) {
540 buf[0] = 0xdd;
541 buf[1] = 0x00;
542 memcpy(skb_put(nskb, 2), buf, 2);
543 }
545 read_lock(&bfusb->lock);
547 skb_queue_tail(&bfusb->transmit_q, nskb);
548 bfusb_tx_wakeup(bfusb);
550 read_unlock(&bfusb->lock);
552 kfree_skb(skb);
554 return 0;
555 }
557 static void bfusb_destruct(struct hci_dev *hdev)
558 {
559 struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
561 BT_DBG("hdev %p bfusb %p", hdev, bfusb);
563 kfree(bfusb);
564 }
566 static int bfusb_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
567 {
568 return -ENOIOCTLCMD;
569 }
572 static int bfusb_load_firmware(struct bfusb *bfusb, unsigned char *firmware, int count)
573 {
574 unsigned char *buf;
575 int err, pipe, len, size, sent = 0;
577 BT_DBG("bfusb %p udev %p", bfusb, bfusb->udev);
579 BT_INFO("BlueFRITZ! USB loading firmware");
581 pipe = usb_sndctrlpipe(bfusb->udev, 0);
583 if (usb_control_msg(bfusb->udev, pipe, USB_REQ_SET_CONFIGURATION,
584 0, 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT) < 0) {
585 BT_ERR("Can't change to loading configuration");
586 return -EBUSY;
587 }
589 bfusb->udev->toggle[0] = bfusb->udev->toggle[1] = 0;
591 buf = kmalloc(BFUSB_MAX_BLOCK_SIZE + 3, GFP_ATOMIC);
592 if (!buf) {
593 BT_ERR("Can't allocate memory chunk for firmware");
594 return -ENOMEM;
595 }
597 pipe = usb_sndbulkpipe(bfusb->udev, bfusb->bulk_out_ep);
599 while (count) {
600 size = min_t(uint, count, BFUSB_MAX_BLOCK_SIZE + 3);
602 memcpy(buf, firmware + sent, size);
604 err = usb_bulk_msg(bfusb->udev, pipe, buf, size,
605 &len, BFUSB_BLOCK_TIMEOUT);
607 if (err || (len != size)) {
608 BT_ERR("Error in firmware loading");
609 goto error;
610 }
612 sent += size;
613 count -= size;
614 }
616 if ((err = usb_bulk_msg(bfusb->udev, pipe, NULL, 0,
617 &len, BFUSB_BLOCK_TIMEOUT)) < 0) {
618 BT_ERR("Error in null packet request");
619 goto error;
620 }
622 pipe = usb_sndctrlpipe(bfusb->udev, 0);
624 if ((err = usb_control_msg(bfusb->udev, pipe, USB_REQ_SET_CONFIGURATION,
625 0, 2, 0, NULL, 0, USB_CTRL_SET_TIMEOUT)) < 0) {
626 BT_ERR("Can't change to running configuration");
627 goto error;
628 }
630 bfusb->udev->toggle[0] = bfusb->udev->toggle[1] = 0;
632 BT_INFO("BlueFRITZ! USB device ready");
634 kfree(buf);
635 return 0;
637 error:
638 kfree(buf);
640 pipe = usb_sndctrlpipe(bfusb->udev, 0);
642 usb_control_msg(bfusb->udev, pipe, USB_REQ_SET_CONFIGURATION,
643 0, 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
645 return err;
646 }
648 static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
649 {
650 const struct firmware *firmware;
651 struct usb_device *udev = interface_to_usbdev(intf);
652 struct usb_host_endpoint *bulk_out_ep;
653 struct usb_host_endpoint *bulk_in_ep;
654 struct hci_dev *hdev;
655 struct bfusb *bfusb;
657 BT_DBG("intf %p id %p", intf, id);
659 if (ignore)
660 return -ENODEV;
662 /* Check number of endpoints */
663 if (intf->cur_altsetting->desc.bNumEndpoints < 2)
664 return -EIO;
666 bulk_out_ep = &intf->cur_altsetting->endpoint[0];
667 bulk_in_ep = &intf->cur_altsetting->endpoint[1];
669 if (!bulk_out_ep || !bulk_in_ep) {
670 BT_ERR("Bulk endpoints not found");
671 goto done;
672 }
674 /* Initialize control structure and load firmware */
675 if (!(bfusb = kzalloc(sizeof(struct bfusb), GFP_KERNEL))) {
676 BT_ERR("Can't allocate memory for control structure");
677 goto done;
678 }
680 bfusb->udev = udev;
681 bfusb->bulk_in_ep = bulk_in_ep->desc.bEndpointAddress;
682 bfusb->bulk_out_ep = bulk_out_ep->desc.bEndpointAddress;
683 bfusb->bulk_pkt_size = le16_to_cpu(bulk_out_ep->desc.wMaxPacketSize);
685 rwlock_init(&bfusb->lock);
687 bfusb->reassembly = NULL;
689 skb_queue_head_init(&bfusb->transmit_q);
690 skb_queue_head_init(&bfusb->pending_q);
691 skb_queue_head_init(&bfusb->completed_q);
693 if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) {
694 BT_ERR("Firmware request failed");
695 goto error;
696 }
698 BT_DBG("firmware data %p size %d", firmware->data, firmware->size);
700 if (bfusb_load_firmware(bfusb, firmware->data, firmware->size) < 0) {
701 BT_ERR("Firmware loading failed");
702 goto release;
703 }
705 release_firmware(firmware);
707 /* Initialize and register HCI device */
708 hdev = hci_alloc_dev();
709 if (!hdev) {
710 BT_ERR("Can't allocate HCI device");
711 goto error;
712 }
714 bfusb->hdev = hdev;
716 hdev->type = HCI_USB;
717 hdev->driver_data = bfusb;
718 SET_HCIDEV_DEV(hdev, &intf->dev);
720 hdev->open = bfusb_open;
721 hdev->close = bfusb_close;
722 hdev->flush = bfusb_flush;
723 hdev->send = bfusb_send_frame;
724 hdev->destruct = bfusb_destruct;
725 hdev->ioctl = bfusb_ioctl;
727 hdev->owner = THIS_MODULE;
729 if (hci_register_dev(hdev) < 0) {
730 BT_ERR("Can't register HCI device");
731 hci_free_dev(hdev);
732 goto error;
733 }
735 usb_set_intfdata(intf, bfusb);
737 return 0;
739 release:
740 release_firmware(firmware);
742 error:
743 kfree(bfusb);
745 done:
746 return -EIO;
747 }
749 static void bfusb_disconnect(struct usb_interface *intf)
750 {
751 struct bfusb *bfusb = usb_get_intfdata(intf);
752 struct hci_dev *hdev = bfusb->hdev;
754 BT_DBG("intf %p", intf);
756 if (!hdev)
757 return;
759 usb_set_intfdata(intf, NULL);
761 bfusb_close(hdev);
763 if (hci_unregister_dev(hdev) < 0)
764 BT_ERR("Can't unregister HCI device %s", hdev->name);
766 hci_free_dev(hdev);
767 }
769 static struct usb_driver bfusb_driver = {
770 .name = "bfusb",
771 .probe = bfusb_probe,
772 .disconnect = bfusb_disconnect,
773 .id_table = bfusb_table,
774 };
776 static int __init bfusb_init(void)
777 {
778 int err;
780 BT_INFO("BlueFRITZ! USB driver ver %s", VERSION);
782 if ((err = usb_register(&bfusb_driver)) < 0)
783 BT_ERR("Failed to register BlueFRITZ! USB driver");
785 return err;
786 }
788 static void __exit bfusb_exit(void)
789 {
790 usb_deregister(&bfusb_driver);
791 }
793 module_init(bfusb_init);
794 module_exit(bfusb_exit);
796 module_param(ignore, bool, 0644);
797 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
799 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
800 MODULE_DESCRIPTION("BlueFRITZ! USB driver ver " VERSION);
801 MODULE_VERSION(VERSION);
802 MODULE_LICENSE("GPL");