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