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 */ 23 24 #include <linux/module.h> 25 26 #include <linux/kernel.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/types.h> 30 #include <linux/delay.h> 31 #include <linux/errno.h> 32 #include <linux/ptrace.h> 33 #include <linux/ioport.h> 34 #include <linux/spinlock.h> 35 #include <linux/moduleparam.h> 36 37 #include <linux/skbuff.h> 38 #include <linux/string.h> 39 #include <linux/serial.h> 40 #include <linux/serial_reg.h> 41 #include <linux/bitops.h> 42 #include <asm/system.h> 43 #include <asm/io.h> 44 45 #include <linux/device.h> 46 #include <linux/firmware.h> 47 48 #include <pcmcia/cs_types.h> 49 #include <pcmcia/cs.h> 50 #include <pcmcia/cistpl.h> 51 #include <pcmcia/ciscode.h> 52 #include <pcmcia/ds.h> 53 #include <pcmcia/cisreg.h> 54 55 #include <net/bluetooth/bluetooth.h> 56 #include <net/bluetooth/hci_core.h> 57 58 59 60 /* ======================== Module parameters ======================== */ 61 62 63 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>"); 64 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card"); 65 MODULE_LICENSE("GPL"); 66 67 68 69 /* ======================== Local structures ======================== */ 70 71 72 typedef struct bt3c_info_t { 73 struct pcmcia_device *p_dev; 74 dev_node_t node; 75 76 struct hci_dev *hdev; 77 78 spinlock_t lock; /* For serializing operations */ 79 80 struct sk_buff_head txq; 81 unsigned long tx_state; 82 83 unsigned long rx_state; 84 unsigned long rx_count; 85 struct sk_buff *rx_skb; 86 } bt3c_info_t; 87 88 89 static int bt3c_config(struct pcmcia_device *link); 90 static void bt3c_release(struct pcmcia_device *link); 91 92 static void bt3c_detach(struct pcmcia_device *p_dev); 93 94 95 /* Transmit states */ 96 #define XMIT_SENDING 1 97 #define XMIT_WAKEUP 2 98 #define XMIT_WAITING 8 99 100 /* Receiver states */ 101 #define RECV_WAIT_PACKET_TYPE 0 102 #define RECV_WAIT_EVENT_HEADER 1 103 #define RECV_WAIT_ACL_HEADER 2 104 #define RECV_WAIT_SCO_HEADER 3 105 #define RECV_WAIT_DATA 4 106 107 108 109 /* ======================== Special I/O functions ======================== */ 110 111 112 #define DATA_L 0 113 #define DATA_H 1 114 #define ADDR_L 2 115 #define ADDR_H 3 116 #define CONTROL 4 117 118 119 static inline void bt3c_address(unsigned int iobase, unsigned short addr) 120 { 121 outb(addr & 0xff, iobase + ADDR_L); 122 outb((addr >> 8) & 0xff, iobase + ADDR_H); 123 } 124 125 126 static inline void bt3c_put(unsigned int iobase, unsigned short value) 127 { 128 outb(value & 0xff, iobase + DATA_L); 129 outb((value >> 8) & 0xff, iobase + DATA_H); 130 } 131 132 133 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value) 134 { 135 bt3c_address(iobase, addr); 136 bt3c_put(iobase, value); 137 } 138 139 140 static inline unsigned short bt3c_get(unsigned int iobase) 141 { 142 unsigned short value = inb(iobase + DATA_L); 143 144 value |= inb(iobase + DATA_H) << 8; 145 146 return value; 147 } 148 149 150 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr) 151 { 152 bt3c_address(iobase, addr); 153 154 return bt3c_get(iobase); 155 } 156 157 158 159 /* ======================== Interrupt handling ======================== */ 160 161 162 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len) 163 { 164 int actual = 0; 165 166 bt3c_address(iobase, 0x7080); 167 168 /* Fill FIFO with current frame */ 169 while (actual < len) { 170 /* Transmit next byte */ 171 bt3c_put(iobase, buf[actual]); 172 actual++; 173 } 174 175 bt3c_io_write(iobase, 0x7005, actual); 176 177 return actual; 178 } 179 180 181 static void bt3c_write_wakeup(bt3c_info_t *info) 182 { 183 if (!info) { 184 BT_ERR("Unknown device"); 185 return; 186 } 187 188 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) 189 return; 190 191 do { 192 register unsigned int iobase = info->p_dev->io.BasePort1; 193 register struct sk_buff *skb; 194 register int len; 195 196 if (!pcmcia_dev_present(info->p_dev)) 197 break; 198 199 200 if (!(skb = skb_dequeue(&(info->txq)))) { 201 clear_bit(XMIT_SENDING, &(info->tx_state)); 202 break; 203 } 204 205 /* Send frame */ 206 len = bt3c_write(iobase, 256, skb->data, skb->len); 207 208 if (len != skb->len) { 209 BT_ERR("Very strange"); 210 } 211 212 kfree_skb(skb); 213 214 info->hdev->stat.byte_tx += len; 215 216 } while (0); 217 } 218 219 220 static void bt3c_receive(bt3c_info_t *info) 221 { 222 unsigned int iobase; 223 int size = 0, avail; 224 225 if (!info) { 226 BT_ERR("Unknown device"); 227 return; 228 } 229 230 iobase = info->p_dev->io.BasePort1; 231 232 avail = bt3c_read(iobase, 0x7006); 233 //printk("bt3c_cs: receiving %d bytes\n", avail); 234 235 bt3c_address(iobase, 0x7480); 236 while (size < avail) { 237 size++; 238 info->hdev->stat.byte_rx++; 239 240 /* Allocate packet */ 241 if (info->rx_skb == NULL) { 242 info->rx_state = RECV_WAIT_PACKET_TYPE; 243 info->rx_count = 0; 244 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 245 BT_ERR("Can't allocate mem for new packet"); 246 return; 247 } 248 } 249 250 251 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 252 253 info->rx_skb->dev = (void *) info->hdev; 254 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L); 255 inb(iobase + DATA_H); 256 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type); 257 258 switch (bt_cb(info->rx_skb)->pkt_type) { 259 260 case HCI_EVENT_PKT: 261 info->rx_state = RECV_WAIT_EVENT_HEADER; 262 info->rx_count = HCI_EVENT_HDR_SIZE; 263 break; 264 265 case HCI_ACLDATA_PKT: 266 info->rx_state = RECV_WAIT_ACL_HEADER; 267 info->rx_count = HCI_ACL_HDR_SIZE; 268 break; 269 270 case HCI_SCODATA_PKT: 271 info->rx_state = RECV_WAIT_SCO_HEADER; 272 info->rx_count = HCI_SCO_HDR_SIZE; 273 break; 274 275 default: 276 /* Unknown packet */ 277 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 278 info->hdev->stat.err_rx++; 279 clear_bit(HCI_RUNNING, &(info->hdev->flags)); 280 281 kfree_skb(info->rx_skb); 282 info->rx_skb = NULL; 283 break; 284 285 } 286 287 } else { 288 289 __u8 x = inb(iobase + DATA_L); 290 291 *skb_put(info->rx_skb, 1) = x; 292 inb(iobase + DATA_H); 293 info->rx_count--; 294 295 if (info->rx_count == 0) { 296 297 int dlen; 298 struct hci_event_hdr *eh; 299 struct hci_acl_hdr *ah; 300 struct hci_sco_hdr *sh; 301 302 switch (info->rx_state) { 303 304 case RECV_WAIT_EVENT_HEADER: 305 eh = (struct hci_event_hdr *)(info->rx_skb->data); 306 info->rx_state = RECV_WAIT_DATA; 307 info->rx_count = eh->plen; 308 break; 309 310 case RECV_WAIT_ACL_HEADER: 311 ah = (struct hci_acl_hdr *)(info->rx_skb->data); 312 dlen = __le16_to_cpu(ah->dlen); 313 info->rx_state = RECV_WAIT_DATA; 314 info->rx_count = dlen; 315 break; 316 317 case RECV_WAIT_SCO_HEADER: 318 sh = (struct hci_sco_hdr *)(info->rx_skb->data); 319 info->rx_state = RECV_WAIT_DATA; 320 info->rx_count = sh->dlen; 321 break; 322 323 case RECV_WAIT_DATA: 324 hci_recv_frame(info->rx_skb); 325 info->rx_skb = NULL; 326 break; 327 328 } 329 330 } 331 332 } 333 334 } 335 336 bt3c_io_write(iobase, 0x7006, 0x0000); 337 } 338 339 340 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst) 341 { 342 bt3c_info_t *info = dev_inst; 343 unsigned int iobase; 344 int iir; 345 346 if (!info || !info->hdev) { 347 BT_ERR("Call of irq %d for unknown device", irq); 348 return IRQ_NONE; 349 } 350 351 iobase = info->p_dev->io.BasePort1; 352 353 spin_lock(&(info->lock)); 354 355 iir = inb(iobase + CONTROL); 356 if (iir & 0x80) { 357 int stat = bt3c_read(iobase, 0x7001); 358 359 if ((stat & 0xff) == 0x7f) { 360 BT_ERR("Very strange (stat=0x%04x)", stat); 361 } else if ((stat & 0xff) != 0xff) { 362 if (stat & 0x0020) { 363 int stat = bt3c_read(iobase, 0x7002) & 0x10; 364 BT_INFO("%s: Antenna %s", info->hdev->name, 365 stat ? "out" : "in"); 366 } 367 if (stat & 0x0001) 368 bt3c_receive(info); 369 if (stat & 0x0002) { 370 //BT_ERR("Ack (stat=0x%04x)", stat); 371 clear_bit(XMIT_SENDING, &(info->tx_state)); 372 bt3c_write_wakeup(info); 373 } 374 375 bt3c_io_write(iobase, 0x7001, 0x0000); 376 377 outb(iir, iobase + CONTROL); 378 } 379 } 380 381 spin_unlock(&(info->lock)); 382 383 return IRQ_HANDLED; 384 } 385 386 387 388 /* ======================== HCI interface ======================== */ 389 390 391 static int bt3c_hci_flush(struct hci_dev *hdev) 392 { 393 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data); 394 395 /* Drop TX queue */ 396 skb_queue_purge(&(info->txq)); 397 398 return 0; 399 } 400 401 402 static int bt3c_hci_open(struct hci_dev *hdev) 403 { 404 set_bit(HCI_RUNNING, &(hdev->flags)); 405 406 return 0; 407 } 408 409 410 static int bt3c_hci_close(struct hci_dev *hdev) 411 { 412 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags))) 413 return 0; 414 415 bt3c_hci_flush(hdev); 416 417 return 0; 418 } 419 420 421 static int bt3c_hci_send_frame(struct sk_buff *skb) 422 { 423 bt3c_info_t *info; 424 struct hci_dev *hdev = (struct hci_dev *)(skb->dev); 425 unsigned long flags; 426 427 if (!hdev) { 428 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 429 return -ENODEV; 430 } 431 432 info = (bt3c_info_t *) (hdev->driver_data); 433 434 switch (bt_cb(skb)->pkt_type) { 435 case HCI_COMMAND_PKT: 436 hdev->stat.cmd_tx++; 437 break; 438 case HCI_ACLDATA_PKT: 439 hdev->stat.acl_tx++; 440 break; 441 case HCI_SCODATA_PKT: 442 hdev->stat.sco_tx++; 443 break; 444 }; 445 446 /* Prepend skb with frame type */ 447 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 448 skb_queue_tail(&(info->txq), skb); 449 450 spin_lock_irqsave(&(info->lock), flags); 451 452 bt3c_write_wakeup(info); 453 454 spin_unlock_irqrestore(&(info->lock), flags); 455 456 return 0; 457 } 458 459 460 static void bt3c_hci_destruct(struct hci_dev *hdev) 461 { 462 } 463 464 465 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 466 { 467 return -ENOIOCTLCMD; 468 } 469 470 471 472 /* ======================== Card services HCI interaction ======================== */ 473 474 475 static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count) 476 { 477 char *ptr = (char *) firmware; 478 char b[9]; 479 unsigned int iobase, size, addr, fcs, tmp; 480 int i, err = 0; 481 482 iobase = info->p_dev->io.BasePort1; 483 484 /* Reset */ 485 bt3c_io_write(iobase, 0x8040, 0x0404); 486 bt3c_io_write(iobase, 0x8040, 0x0400); 487 488 udelay(1); 489 490 bt3c_io_write(iobase, 0x8040, 0x0404); 491 492 udelay(17); 493 494 /* Load */ 495 while (count) { 496 if (ptr[0] != 'S') { 497 BT_ERR("Bad address in firmware"); 498 err = -EFAULT; 499 goto error; 500 } 501 502 memset(b, 0, sizeof(b)); 503 memcpy(b, ptr + 2, 2); 504 size = simple_strtol(b, NULL, 16); 505 506 memset(b, 0, sizeof(b)); 507 memcpy(b, ptr + 4, 8); 508 addr = simple_strtol(b, NULL, 16); 509 510 memset(b, 0, sizeof(b)); 511 memcpy(b, ptr + (size * 2) + 2, 2); 512 fcs = simple_strtol(b, NULL, 16); 513 514 memset(b, 0, sizeof(b)); 515 for (tmp = 0, i = 0; i < size; i++) { 516 memcpy(b, ptr + (i * 2) + 2, 2); 517 tmp += simple_strtol(b, NULL, 16); 518 } 519 520 if (((tmp + fcs) & 0xff) != 0xff) { 521 BT_ERR("Checksum error in firmware"); 522 err = -EILSEQ; 523 goto error; 524 } 525 526 if (ptr[1] == '3') { 527 bt3c_address(iobase, addr); 528 529 memset(b, 0, sizeof(b)); 530 for (i = 0; i < (size - 4) / 2; i++) { 531 memcpy(b, ptr + (i * 4) + 12, 4); 532 tmp = simple_strtol(b, NULL, 16); 533 bt3c_put(iobase, tmp); 534 } 535 } 536 537 ptr += (size * 2) + 6; 538 count -= (size * 2) + 6; 539 } 540 541 udelay(17); 542 543 /* Boot */ 544 bt3c_address(iobase, 0x3000); 545 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL); 546 547 error: 548 udelay(17); 549 550 /* Clear */ 551 bt3c_io_write(iobase, 0x7006, 0x0000); 552 bt3c_io_write(iobase, 0x7005, 0x0000); 553 bt3c_io_write(iobase, 0x7001, 0x0000); 554 555 return err; 556 } 557 558 559 static int bt3c_open(bt3c_info_t *info) 560 { 561 const struct firmware *firmware; 562 struct hci_dev *hdev; 563 int err; 564 565 spin_lock_init(&(info->lock)); 566 567 skb_queue_head_init(&(info->txq)); 568 569 info->rx_state = RECV_WAIT_PACKET_TYPE; 570 info->rx_count = 0; 571 info->rx_skb = NULL; 572 573 /* Initialize HCI device */ 574 hdev = hci_alloc_dev(); 575 if (!hdev) { 576 BT_ERR("Can't allocate HCI device"); 577 return -ENOMEM; 578 } 579 580 info->hdev = hdev; 581 582 hdev->type = HCI_PCCARD; 583 hdev->driver_data = info; 584 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 585 586 hdev->open = bt3c_hci_open; 587 hdev->close = bt3c_hci_close; 588 hdev->flush = bt3c_hci_flush; 589 hdev->send = bt3c_hci_send_frame; 590 hdev->destruct = bt3c_hci_destruct; 591 hdev->ioctl = bt3c_hci_ioctl; 592 593 hdev->owner = THIS_MODULE; 594 595 /* Load firmware */ 596 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev); 597 if (err < 0) { 598 BT_ERR("Firmware request failed"); 599 goto error; 600 } 601 602 err = bt3c_load_firmware(info, firmware->data, firmware->size); 603 604 release_firmware(firmware); 605 606 if (err < 0) { 607 BT_ERR("Firmware loading failed"); 608 goto error; 609 } 610 611 /* Timeout before it is safe to send the first HCI packet */ 612 msleep(1000); 613 614 /* Register HCI device */ 615 err = hci_register_dev(hdev); 616 if (err < 0) { 617 BT_ERR("Can't register HCI device"); 618 goto error; 619 } 620 621 return 0; 622 623 error: 624 info->hdev = NULL; 625 hci_free_dev(hdev); 626 return err; 627 } 628 629 630 static int bt3c_close(bt3c_info_t *info) 631 { 632 struct hci_dev *hdev = info->hdev; 633 634 if (!hdev) 635 return -ENODEV; 636 637 bt3c_hci_close(hdev); 638 639 if (hci_unregister_dev(hdev) < 0) 640 BT_ERR("Can't unregister HCI device %s", hdev->name); 641 642 hci_free_dev(hdev); 643 644 return 0; 645 } 646 647 static int bt3c_probe(struct pcmcia_device *link) 648 { 649 bt3c_info_t *info; 650 651 /* Create new info device */ 652 info = kzalloc(sizeof(*info), GFP_KERNEL); 653 if (!info) 654 return -ENOMEM; 655 656 info->p_dev = link; 657 link->priv = info; 658 659 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 660 link->io.NumPorts1 = 8; 661 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT; 662 link->irq.IRQInfo1 = IRQ_LEVEL_ID; 663 664 link->irq.Handler = bt3c_interrupt; 665 link->irq.Instance = info; 666 667 link->conf.Attributes = CONF_ENABLE_IRQ; 668 link->conf.IntType = INT_MEMORY_AND_IO; 669 670 return bt3c_config(link); 671 } 672 673 674 static void bt3c_detach(struct pcmcia_device *link) 675 { 676 bt3c_info_t *info = link->priv; 677 678 bt3c_release(link); 679 kfree(info); 680 } 681 682 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse) 683 { 684 int i; 685 686 i = pcmcia_get_tuple_data(handle, tuple); 687 if (i != CS_SUCCESS) 688 return i; 689 690 return pcmcia_parse_tuple(handle, tuple, parse); 691 } 692 693 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse) 694 { 695 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS) 696 return CS_NO_MORE_ITEMS; 697 return get_tuple(handle, tuple, parse); 698 } 699 700 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse) 701 { 702 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS) 703 return CS_NO_MORE_ITEMS; 704 return get_tuple(handle, tuple, parse); 705 } 706 707 static int bt3c_config(struct pcmcia_device *link) 708 { 709 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 }; 710 bt3c_info_t *info = link->priv; 711 tuple_t tuple; 712 u_short buf[256]; 713 cisparse_t parse; 714 cistpl_cftable_entry_t *cf = &parse.cftable_entry; 715 int i, j, try; 716 717 /* First pass: look for a config entry that looks normal. */ 718 tuple.TupleData = (cisdata_t *)buf; 719 tuple.TupleOffset = 0; 720 tuple.TupleDataMax = 255; 721 tuple.Attributes = 0; 722 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; 723 /* Two tries: without IO aliases, then with aliases */ 724 for (try = 0; try < 2; try++) { 725 i = first_tuple(link, &tuple, &parse); 726 while (i != CS_NO_MORE_ITEMS) { 727 if (i != CS_SUCCESS) 728 goto next_entry; 729 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM)) 730 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000; 731 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) { 732 link->conf.ConfigIndex = cf->index; 733 link->io.BasePort1 = cf->io.win[0].base; 734 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK; 735 i = pcmcia_request_io(link, &link->io); 736 if (i == CS_SUCCESS) 737 goto found_port; 738 } 739 next_entry: 740 i = next_tuple(link, &tuple, &parse); 741 } 742 } 743 744 /* Second pass: try to find an entry that isn't picky about 745 its base address, then try to grab any standard serial port 746 address, and finally try to get any free port. */ 747 i = first_tuple(link, &tuple, &parse); 748 while (i != CS_NO_MORE_ITEMS) { 749 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) { 750 link->conf.ConfigIndex = cf->index; 751 for (j = 0; j < 5; j++) { 752 link->io.BasePort1 = base[j]; 753 link->io.IOAddrLines = base[j] ? 16 : 3; 754 i = pcmcia_request_io(link, &link->io); 755 if (i == CS_SUCCESS) 756 goto found_port; 757 } 758 } 759 i = next_tuple(link, &tuple, &parse); 760 } 761 762 found_port: 763 if (i != CS_SUCCESS) { 764 BT_ERR("No usable port range found"); 765 cs_error(link, RequestIO, i); 766 goto failed; 767 } 768 769 i = pcmcia_request_irq(link, &link->irq); 770 if (i != CS_SUCCESS) { 771 cs_error(link, RequestIRQ, i); 772 link->irq.AssignedIRQ = 0; 773 } 774 775 i = pcmcia_request_configuration(link, &link->conf); 776 if (i != CS_SUCCESS) { 777 cs_error(link, RequestConfiguration, i); 778 goto failed; 779 } 780 781 if (bt3c_open(info) != 0) 782 goto failed; 783 784 strcpy(info->node.dev_name, info->hdev->name); 785 link->dev_node = &info->node; 786 787 return 0; 788 789 failed: 790 bt3c_release(link); 791 return -ENODEV; 792 } 793 794 795 static void bt3c_release(struct pcmcia_device *link) 796 { 797 bt3c_info_t *info = link->priv; 798 799 bt3c_close(info); 800 801 pcmcia_disable_device(link); 802 } 803 804 805 static struct pcmcia_device_id bt3c_ids[] = { 806 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02), 807 PCMCIA_DEVICE_NULL 808 }; 809 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids); 810 811 static struct pcmcia_driver bt3c_driver = { 812 .owner = THIS_MODULE, 813 .drv = { 814 .name = "bt3c_cs", 815 }, 816 .probe = bt3c_probe, 817 .remove = bt3c_detach, 818 .id_table = bt3c_ids, 819 }; 820 821 static int __init init_bt3c_cs(void) 822 { 823 return pcmcia_register_driver(&bt3c_driver); 824 } 825 826 827 static void __exit exit_bt3c_cs(void) 828 { 829 pcmcia_unregister_driver(&bt3c_driver); 830 } 831 832 module_init(init_bt3c_cs); 833 module_exit(exit_bt3c_cs); 834