ia64/linux-2.6.18-xen.hg

view drivers/bluetooth/bt3c_cs.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 * Driver for the 3Com Bluetooth PCMCIA card
4 *
5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
6 * Jose Orlando Pereira <jop@di.uminho.pt>
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation;
12 *
13 * Software distributed under the License is distributed on an "AS
14 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
15 * implied. See the License for the specific language governing
16 * rights and limitations under the License.
17 *
18 * The initial developer of the original code is David A. Hinds
19 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
20 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
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/delay.h>
32 #include <linux/errno.h>
33 #include <linux/ptrace.h>
34 #include <linux/ioport.h>
35 #include <linux/spinlock.h>
36 #include <linux/moduleparam.h>
38 #include <linux/skbuff.h>
39 #include <linux/string.h>
40 #include <linux/serial.h>
41 #include <linux/serial_reg.h>
42 #include <linux/bitops.h>
43 #include <asm/system.h>
44 #include <asm/io.h>
46 #include <linux/device.h>
47 #include <linux/firmware.h>
49 #include <pcmcia/cs_types.h>
50 #include <pcmcia/cs.h>
51 #include <pcmcia/cistpl.h>
52 #include <pcmcia/ciscode.h>
53 #include <pcmcia/ds.h>
54 #include <pcmcia/cisreg.h>
56 #include <net/bluetooth/bluetooth.h>
57 #include <net/bluetooth/hci_core.h>
61 /* ======================== Module parameters ======================== */
64 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
65 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
66 MODULE_LICENSE("GPL");
70 /* ======================== Local structures ======================== */
73 typedef struct bt3c_info_t {
74 struct pcmcia_device *p_dev;
75 dev_node_t node;
77 struct hci_dev *hdev;
79 spinlock_t lock; /* For serializing operations */
81 struct sk_buff_head txq;
82 unsigned long tx_state;
84 unsigned long rx_state;
85 unsigned long rx_count;
86 struct sk_buff *rx_skb;
87 } bt3c_info_t;
90 static int bt3c_config(struct pcmcia_device *link);
91 static void bt3c_release(struct pcmcia_device *link);
93 static void bt3c_detach(struct pcmcia_device *p_dev);
96 /* Transmit states */
97 #define XMIT_SENDING 1
98 #define XMIT_WAKEUP 2
99 #define XMIT_WAITING 8
101 /* Receiver states */
102 #define RECV_WAIT_PACKET_TYPE 0
103 #define RECV_WAIT_EVENT_HEADER 1
104 #define RECV_WAIT_ACL_HEADER 2
105 #define RECV_WAIT_SCO_HEADER 3
106 #define RECV_WAIT_DATA 4
110 /* ======================== Special I/O functions ======================== */
113 #define DATA_L 0
114 #define DATA_H 1
115 #define ADDR_L 2
116 #define ADDR_H 3
117 #define CONTROL 4
120 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
121 {
122 outb(addr & 0xff, iobase + ADDR_L);
123 outb((addr >> 8) & 0xff, iobase + ADDR_H);
124 }
127 static inline void bt3c_put(unsigned int iobase, unsigned short value)
128 {
129 outb(value & 0xff, iobase + DATA_L);
130 outb((value >> 8) & 0xff, iobase + DATA_H);
131 }
134 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
135 {
136 bt3c_address(iobase, addr);
137 bt3c_put(iobase, value);
138 }
141 static inline unsigned short bt3c_get(unsigned int iobase)
142 {
143 unsigned short value = inb(iobase + DATA_L);
145 value |= inb(iobase + DATA_H) << 8;
147 return value;
148 }
151 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
152 {
153 bt3c_address(iobase, addr);
155 return bt3c_get(iobase);
156 }
160 /* ======================== Interrupt handling ======================== */
163 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
164 {
165 int actual = 0;
167 bt3c_address(iobase, 0x7080);
169 /* Fill FIFO with current frame */
170 while (actual < len) {
171 /* Transmit next byte */
172 bt3c_put(iobase, buf[actual]);
173 actual++;
174 }
176 bt3c_io_write(iobase, 0x7005, actual);
178 return actual;
179 }
182 static void bt3c_write_wakeup(bt3c_info_t *info)
183 {
184 if (!info) {
185 BT_ERR("Unknown device");
186 return;
187 }
189 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
190 return;
192 do {
193 register unsigned int iobase = info->p_dev->io.BasePort1;
194 register struct sk_buff *skb;
195 register int len;
197 if (!pcmcia_dev_present(info->p_dev))
198 break;
201 if (!(skb = skb_dequeue(&(info->txq)))) {
202 clear_bit(XMIT_SENDING, &(info->tx_state));
203 break;
204 }
206 /* Send frame */
207 len = bt3c_write(iobase, 256, skb->data, skb->len);
209 if (len != skb->len) {
210 BT_ERR("Very strange");
211 }
213 kfree_skb(skb);
215 info->hdev->stat.byte_tx += len;
217 } while (0);
218 }
221 static void bt3c_receive(bt3c_info_t *info)
222 {
223 unsigned int iobase;
224 int size = 0, avail;
226 if (!info) {
227 BT_ERR("Unknown device");
228 return;
229 }
231 iobase = info->p_dev->io.BasePort1;
233 avail = bt3c_read(iobase, 0x7006);
234 //printk("bt3c_cs: receiving %d bytes\n", avail);
236 bt3c_address(iobase, 0x7480);
237 while (size < avail) {
238 size++;
239 info->hdev->stat.byte_rx++;
241 /* Allocate packet */
242 if (info->rx_skb == NULL) {
243 info->rx_state = RECV_WAIT_PACKET_TYPE;
244 info->rx_count = 0;
245 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
246 BT_ERR("Can't allocate mem for new packet");
247 return;
248 }
249 }
252 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
254 info->rx_skb->dev = (void *) info->hdev;
255 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
256 inb(iobase + DATA_H);
257 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
259 switch (bt_cb(info->rx_skb)->pkt_type) {
261 case HCI_EVENT_PKT:
262 info->rx_state = RECV_WAIT_EVENT_HEADER;
263 info->rx_count = HCI_EVENT_HDR_SIZE;
264 break;
266 case HCI_ACLDATA_PKT:
267 info->rx_state = RECV_WAIT_ACL_HEADER;
268 info->rx_count = HCI_ACL_HDR_SIZE;
269 break;
271 case HCI_SCODATA_PKT:
272 info->rx_state = RECV_WAIT_SCO_HEADER;
273 info->rx_count = HCI_SCO_HDR_SIZE;
274 break;
276 default:
277 /* Unknown packet */
278 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
279 info->hdev->stat.err_rx++;
280 clear_bit(HCI_RUNNING, &(info->hdev->flags));
282 kfree_skb(info->rx_skb);
283 info->rx_skb = NULL;
284 break;
286 }
288 } else {
290 __u8 x = inb(iobase + DATA_L);
292 *skb_put(info->rx_skb, 1) = x;
293 inb(iobase + DATA_H);
294 info->rx_count--;
296 if (info->rx_count == 0) {
298 int dlen;
299 struct hci_event_hdr *eh;
300 struct hci_acl_hdr *ah;
301 struct hci_sco_hdr *sh;
303 switch (info->rx_state) {
305 case RECV_WAIT_EVENT_HEADER:
306 eh = (struct hci_event_hdr *)(info->rx_skb->data);
307 info->rx_state = RECV_WAIT_DATA;
308 info->rx_count = eh->plen;
309 break;
311 case RECV_WAIT_ACL_HEADER:
312 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
313 dlen = __le16_to_cpu(ah->dlen);
314 info->rx_state = RECV_WAIT_DATA;
315 info->rx_count = dlen;
316 break;
318 case RECV_WAIT_SCO_HEADER:
319 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
320 info->rx_state = RECV_WAIT_DATA;
321 info->rx_count = sh->dlen;
322 break;
324 case RECV_WAIT_DATA:
325 hci_recv_frame(info->rx_skb);
326 info->rx_skb = NULL;
327 break;
329 }
331 }
333 }
335 }
337 bt3c_io_write(iobase, 0x7006, 0x0000);
338 }
341 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
342 {
343 bt3c_info_t *info = dev_inst;
344 unsigned int iobase;
345 int iir;
347 if (!info || !info->hdev) {
348 BT_ERR("Call of irq %d for unknown device", irq);
349 return IRQ_NONE;
350 }
352 iobase = info->p_dev->io.BasePort1;
354 spin_lock(&(info->lock));
356 iir = inb(iobase + CONTROL);
357 if (iir & 0x80) {
358 int stat = bt3c_read(iobase, 0x7001);
360 if ((stat & 0xff) == 0x7f) {
361 BT_ERR("Very strange (stat=0x%04x)", stat);
362 } else if ((stat & 0xff) != 0xff) {
363 if (stat & 0x0020) {
364 int stat = bt3c_read(iobase, 0x7002) & 0x10;
365 BT_INFO("%s: Antenna %s", info->hdev->name,
366 stat ? "out" : "in");
367 }
368 if (stat & 0x0001)
369 bt3c_receive(info);
370 if (stat & 0x0002) {
371 //BT_ERR("Ack (stat=0x%04x)", stat);
372 clear_bit(XMIT_SENDING, &(info->tx_state));
373 bt3c_write_wakeup(info);
374 }
376 bt3c_io_write(iobase, 0x7001, 0x0000);
378 outb(iir, iobase + CONTROL);
379 }
380 }
382 spin_unlock(&(info->lock));
384 return IRQ_HANDLED;
385 }
389 /* ======================== HCI interface ======================== */
392 static int bt3c_hci_flush(struct hci_dev *hdev)
393 {
394 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
396 /* Drop TX queue */
397 skb_queue_purge(&(info->txq));
399 return 0;
400 }
403 static int bt3c_hci_open(struct hci_dev *hdev)
404 {
405 set_bit(HCI_RUNNING, &(hdev->flags));
407 return 0;
408 }
411 static int bt3c_hci_close(struct hci_dev *hdev)
412 {
413 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
414 return 0;
416 bt3c_hci_flush(hdev);
418 return 0;
419 }
422 static int bt3c_hci_send_frame(struct sk_buff *skb)
423 {
424 bt3c_info_t *info;
425 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
426 unsigned long flags;
428 if (!hdev) {
429 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
430 return -ENODEV;
431 }
433 info = (bt3c_info_t *) (hdev->driver_data);
435 switch (bt_cb(skb)->pkt_type) {
436 case HCI_COMMAND_PKT:
437 hdev->stat.cmd_tx++;
438 break;
439 case HCI_ACLDATA_PKT:
440 hdev->stat.acl_tx++;
441 break;
442 case HCI_SCODATA_PKT:
443 hdev->stat.sco_tx++;
444 break;
445 };
447 /* Prepend skb with frame type */
448 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
449 skb_queue_tail(&(info->txq), skb);
451 spin_lock_irqsave(&(info->lock), flags);
453 bt3c_write_wakeup(info);
455 spin_unlock_irqrestore(&(info->lock), flags);
457 return 0;
458 }
461 static void bt3c_hci_destruct(struct hci_dev *hdev)
462 {
463 }
466 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
467 {
468 return -ENOIOCTLCMD;
469 }
473 /* ======================== Card services HCI interaction ======================== */
476 static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
477 {
478 char *ptr = (char *) firmware;
479 char b[9];
480 unsigned int iobase, size, addr, fcs, tmp;
481 int i, err = 0;
483 iobase = info->p_dev->io.BasePort1;
485 /* Reset */
486 bt3c_io_write(iobase, 0x8040, 0x0404);
487 bt3c_io_write(iobase, 0x8040, 0x0400);
489 udelay(1);
491 bt3c_io_write(iobase, 0x8040, 0x0404);
493 udelay(17);
495 /* Load */
496 while (count) {
497 if (ptr[0] != 'S') {
498 BT_ERR("Bad address in firmware");
499 err = -EFAULT;
500 goto error;
501 }
503 memset(b, 0, sizeof(b));
504 memcpy(b, ptr + 2, 2);
505 size = simple_strtol(b, NULL, 16);
507 memset(b, 0, sizeof(b));
508 memcpy(b, ptr + 4, 8);
509 addr = simple_strtol(b, NULL, 16);
511 memset(b, 0, sizeof(b));
512 memcpy(b, ptr + (size * 2) + 2, 2);
513 fcs = simple_strtol(b, NULL, 16);
515 memset(b, 0, sizeof(b));
516 for (tmp = 0, i = 0; i < size; i++) {
517 memcpy(b, ptr + (i * 2) + 2, 2);
518 tmp += simple_strtol(b, NULL, 16);
519 }
521 if (((tmp + fcs) & 0xff) != 0xff) {
522 BT_ERR("Checksum error in firmware");
523 err = -EILSEQ;
524 goto error;
525 }
527 if (ptr[1] == '3') {
528 bt3c_address(iobase, addr);
530 memset(b, 0, sizeof(b));
531 for (i = 0; i < (size - 4) / 2; i++) {
532 memcpy(b, ptr + (i * 4) + 12, 4);
533 tmp = simple_strtol(b, NULL, 16);
534 bt3c_put(iobase, tmp);
535 }
536 }
538 ptr += (size * 2) + 6;
539 count -= (size * 2) + 6;
540 }
542 udelay(17);
544 /* Boot */
545 bt3c_address(iobase, 0x3000);
546 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
548 error:
549 udelay(17);
551 /* Clear */
552 bt3c_io_write(iobase, 0x7006, 0x0000);
553 bt3c_io_write(iobase, 0x7005, 0x0000);
554 bt3c_io_write(iobase, 0x7001, 0x0000);
556 return err;
557 }
560 static int bt3c_open(bt3c_info_t *info)
561 {
562 const struct firmware *firmware;
563 struct hci_dev *hdev;
564 int err;
566 spin_lock_init(&(info->lock));
568 skb_queue_head_init(&(info->txq));
570 info->rx_state = RECV_WAIT_PACKET_TYPE;
571 info->rx_count = 0;
572 info->rx_skb = NULL;
574 /* Initialize HCI device */
575 hdev = hci_alloc_dev();
576 if (!hdev) {
577 BT_ERR("Can't allocate HCI device");
578 return -ENOMEM;
579 }
581 info->hdev = hdev;
583 hdev->type = HCI_PCCARD;
584 hdev->driver_data = info;
585 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
587 hdev->open = bt3c_hci_open;
588 hdev->close = bt3c_hci_close;
589 hdev->flush = bt3c_hci_flush;
590 hdev->send = bt3c_hci_send_frame;
591 hdev->destruct = bt3c_hci_destruct;
592 hdev->ioctl = bt3c_hci_ioctl;
594 hdev->owner = THIS_MODULE;
596 /* Load firmware */
597 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
598 if (err < 0) {
599 BT_ERR("Firmware request failed");
600 goto error;
601 }
603 err = bt3c_load_firmware(info, firmware->data, firmware->size);
605 release_firmware(firmware);
607 if (err < 0) {
608 BT_ERR("Firmware loading failed");
609 goto error;
610 }
612 /* Timeout before it is safe to send the first HCI packet */
613 msleep(1000);
615 /* Register HCI device */
616 err = hci_register_dev(hdev);
617 if (err < 0) {
618 BT_ERR("Can't register HCI device");
619 goto error;
620 }
622 return 0;
624 error:
625 info->hdev = NULL;
626 hci_free_dev(hdev);
627 return err;
628 }
631 static int bt3c_close(bt3c_info_t *info)
632 {
633 struct hci_dev *hdev = info->hdev;
635 if (!hdev)
636 return -ENODEV;
638 bt3c_hci_close(hdev);
640 if (hci_unregister_dev(hdev) < 0)
641 BT_ERR("Can't unregister HCI device %s", hdev->name);
643 hci_free_dev(hdev);
645 return 0;
646 }
648 static int bt3c_probe(struct pcmcia_device *link)
649 {
650 bt3c_info_t *info;
652 /* Create new info device */
653 info = kzalloc(sizeof(*info), GFP_KERNEL);
654 if (!info)
655 return -ENOMEM;
657 info->p_dev = link;
658 link->priv = info;
660 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
661 link->io.NumPorts1 = 8;
662 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
663 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
665 link->irq.Handler = bt3c_interrupt;
666 link->irq.Instance = info;
668 link->conf.Attributes = CONF_ENABLE_IRQ;
669 link->conf.IntType = INT_MEMORY_AND_IO;
671 return bt3c_config(link);
672 }
675 static void bt3c_detach(struct pcmcia_device *link)
676 {
677 bt3c_info_t *info = link->priv;
679 bt3c_release(link);
680 kfree(info);
681 }
683 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
684 {
685 int i;
687 i = pcmcia_get_tuple_data(handle, tuple);
688 if (i != CS_SUCCESS)
689 return i;
691 return pcmcia_parse_tuple(handle, tuple, parse);
692 }
694 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
695 {
696 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
697 return CS_NO_MORE_ITEMS;
698 return get_tuple(handle, tuple, parse);
699 }
701 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
702 {
703 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
704 return CS_NO_MORE_ITEMS;
705 return get_tuple(handle, tuple, parse);
706 }
708 static int bt3c_config(struct pcmcia_device *link)
709 {
710 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
711 bt3c_info_t *info = link->priv;
712 tuple_t tuple;
713 u_short buf[256];
714 cisparse_t parse;
715 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
716 int i, j, try, last_ret, last_fn;
718 tuple.TupleData = (cisdata_t *)buf;
719 tuple.TupleOffset = 0;
720 tuple.TupleDataMax = 255;
721 tuple.Attributes = 0;
723 /* Get configuration register information */
724 tuple.DesiredTuple = CISTPL_CONFIG;
725 last_ret = first_tuple(link, &tuple, &parse);
726 if (last_ret != CS_SUCCESS) {
727 last_fn = ParseTuple;
728 goto cs_failed;
729 }
730 link->conf.ConfigBase = parse.config.base;
731 link->conf.Present = parse.config.rmask[0];
733 /* First pass: look for a config entry that looks normal. */
734 tuple.TupleData = (cisdata_t *)buf;
735 tuple.TupleOffset = 0;
736 tuple.TupleDataMax = 255;
737 tuple.Attributes = 0;
738 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
739 /* Two tries: without IO aliases, then with aliases */
740 for (try = 0; try < 2; try++) {
741 i = first_tuple(link, &tuple, &parse);
742 while (i != CS_NO_MORE_ITEMS) {
743 if (i != CS_SUCCESS)
744 goto next_entry;
745 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
746 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
747 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
748 link->conf.ConfigIndex = cf->index;
749 link->io.BasePort1 = cf->io.win[0].base;
750 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
751 i = pcmcia_request_io(link, &link->io);
752 if (i == CS_SUCCESS)
753 goto found_port;
754 }
755 next_entry:
756 i = next_tuple(link, &tuple, &parse);
757 }
758 }
760 /* Second pass: try to find an entry that isn't picky about
761 its base address, then try to grab any standard serial port
762 address, and finally try to get any free port. */
763 i = first_tuple(link, &tuple, &parse);
764 while (i != CS_NO_MORE_ITEMS) {
765 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
766 link->conf.ConfigIndex = cf->index;
767 for (j = 0; j < 5; j++) {
768 link->io.BasePort1 = base[j];
769 link->io.IOAddrLines = base[j] ? 16 : 3;
770 i = pcmcia_request_io(link, &link->io);
771 if (i == CS_SUCCESS)
772 goto found_port;
773 }
774 }
775 i = next_tuple(link, &tuple, &parse);
776 }
778 found_port:
779 if (i != CS_SUCCESS) {
780 BT_ERR("No usable port range found");
781 cs_error(link, RequestIO, i);
782 goto failed;
783 }
785 i = pcmcia_request_irq(link, &link->irq);
786 if (i != CS_SUCCESS) {
787 cs_error(link, RequestIRQ, i);
788 link->irq.AssignedIRQ = 0;
789 }
791 i = pcmcia_request_configuration(link, &link->conf);
792 if (i != CS_SUCCESS) {
793 cs_error(link, RequestConfiguration, i);
794 goto failed;
795 }
797 if (bt3c_open(info) != 0)
798 goto failed;
800 strcpy(info->node.dev_name, info->hdev->name);
801 link->dev_node = &info->node;
803 return 0;
805 cs_failed:
806 cs_error(link, last_fn, last_ret);
808 failed:
809 bt3c_release(link);
810 return -ENODEV;
811 }
814 static void bt3c_release(struct pcmcia_device *link)
815 {
816 bt3c_info_t *info = link->priv;
818 bt3c_close(info);
820 pcmcia_disable_device(link);
821 }
824 static struct pcmcia_device_id bt3c_ids[] = {
825 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
826 PCMCIA_DEVICE_NULL
827 };
828 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
830 static struct pcmcia_driver bt3c_driver = {
831 .owner = THIS_MODULE,
832 .drv = {
833 .name = "bt3c_cs",
834 },
835 .probe = bt3c_probe,
836 .remove = bt3c_detach,
837 .id_table = bt3c_ids,
838 };
840 static int __init init_bt3c_cs(void)
841 {
842 return pcmcia_register_driver(&bt3c_driver);
843 }
846 static void __exit exit_bt3c_cs(void)
847 {
848 pcmcia_unregister_driver(&bt3c_driver);
849 }
851 module_init(init_bt3c_cs);
852 module_exit(exit_bt3c_cs);