drivers/bluetooth/btuart_cs.c

   1 /*
   2  *
   3  *  Driver for Bluetooth PCMCIA cards with HCI UART interface
   4  *
   5  *  Copyright (C) 2001-2002  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 version 2 as
  10  *  published by the Free Software Foundation;
  11  *
  12  *  Software distributed under the License is distributed on an "AS
  13  *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  14  *  implied. See the License for the specific language governing
  15  *  rights and limitations under the License.
  16  *
  17  *  The initial developer of the original code is David A. Hinds
  18  *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  19  *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  20  *
  21  */
  22
  23 #include <linux/module.h>
  24
  25 #include <linux/kernel.h>
  26 #include <linux/init.h>
  27 #include <linux/slab.h>
  28 #include <linux/types.h>
  29 #include <linux/delay.h>
  30 #include <linux/errno.h>
  31 #include <linux/ptrace.h>
  32 #include <linux/ioport.h>
  33 #include <linux/spinlock.h>
  34 #include <linux/moduleparam.h>
  35
  36 #include <linux/skbuff.h>
  37 #include <linux/string.h>
  38 #include <linux/serial.h>
  39 #include <linux/serial_reg.h>
  40 #include <linux/bitops.h>
  41 #include <asm/system.h>
  42 #include <asm/io.h>
  43
  44 #include <pcmcia/cistpl.h>
  45 #include <pcmcia/ciscode.h>
  46 #include <pcmcia/ds.h>
  47 #include <pcmcia/cisreg.h>
  48
  49 #include <net/bluetooth/bluetooth.h>
  50 #include <net/bluetooth/hci_core.h>
  51
  52
  53
  54 /* ======================== Module parameters ======================== */
  55
  56
  57 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  58 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
  59 MODULE_LICENSE("GPL");
  60
  61
  62
  63 /* ======================== Local structures ======================== */
  64
  65
  66 typedef struct btuart_info_t {
  67         struct pcmcia_device *p_dev;
  68
  69         struct hci_dev *hdev;
  70
  71         spinlock_t lock;        /* For serializing operations */
  72
  73         struct sk_buff_head txq;
  74         unsigned long tx_state;
  75
  76         unsigned long rx_state;
  77         unsigned long rx_count;
  78         struct sk_buff *rx_skb;
  79 } btuart_info_t;
  80
  81
  82 static int btuart_config(struct pcmcia_device *link);
  83 static void btuart_release(struct pcmcia_device *link);
  84
  85 static void btuart_detach(struct pcmcia_device *p_dev);
  86
  87
  88 /* Maximum baud rate */
  89 #define SPEED_MAX  115200
  90
  91 /* Default baud rate: 57600, 115200, 230400 or 460800 */
  92 #define DEFAULT_BAUD_RATE  115200
  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 /* ======================== Interrupt handling ======================== */
 110
 111
 112 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 113 {
 114         int actual = 0;
 115
 116         /* Tx FIFO should be empty */
 117         if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
 118                 return 0;
 119
 120         /* Fill FIFO with current frame */
 121         while ((fifo_size-- > 0) && (actual < len)) {
 122                 /* Transmit next byte */
 123                 outb(buf[actual], iobase + UART_TX);
 124                 actual++;
 125         }
 126
 127         return actual;
 128 }
 129
 130
 131 static void btuart_write_wakeup(btuart_info_t *info)
 132 {
 133         if (!info) {
 134                 BT_ERR("Unknown device");
 135                 return;
 136         }
 137
 138         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
 139                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 140                 return;
 141         }
 142
 143         do {
 144                 register unsigned int iobase = info->p_dev->resource[0]->start;
 145                 register struct sk_buff *skb;
 146                 register int len;
 147
 148                 clear_bit(XMIT_WAKEUP, &(info->tx_state));
 149
 150                 if (!pcmcia_dev_present(info->p_dev))
 151                         return;
 152
 153                 if (!(skb = skb_dequeue(&(info->txq))))
 154                         break;
 155
 156                 /* Send frame */
 157                 len = btuart_write(iobase, 16, skb->data, skb->len);
 158                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 159
 160                 if (len == skb->len) {
 161                         kfree_skb(skb);
 162                 } else {
 163                         skb_pull(skb, len);
 164                         skb_queue_head(&(info->txq), skb);
 165                 }
 166
 167                 info->hdev->stat.byte_tx += len;
 168
 169         } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
 170
 171         clear_bit(XMIT_SENDING, &(info->tx_state));
 172 }
 173
 174
 175 static void btuart_receive(btuart_info_t *info)
 176 {
 177         unsigned int iobase;
 178         int boguscount = 0;
 179
 180         if (!info) {
 181                 BT_ERR("Unknown device");
 182                 return;
 183         }
 184
 185         iobase = info->p_dev->resource[0]->start;
 186
 187         do {
 188                 info->hdev->stat.byte_rx++;
 189
 190                 /* Allocate packet */
 191                 if (info->rx_skb == NULL) {
 192                         info->rx_state = RECV_WAIT_PACKET_TYPE;
 193                         info->rx_count = 0;
 194                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
 195                                 BT_ERR("Can't allocate mem for new packet");
 196                                 return;
 197                         }
 198                 }
 199
 200                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 201
 202                         info->rx_skb->dev = (void *) info->hdev;
 203                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
 204
 205                         switch (bt_cb(info->rx_skb)->pkt_type) {
 206
 207                         case HCI_EVENT_PKT:
 208                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
 209                                 info->rx_count = HCI_EVENT_HDR_SIZE;
 210                                 break;
 211
 212                         case HCI_ACLDATA_PKT:
 213                                 info->rx_state = RECV_WAIT_ACL_HEADER;
 214                                 info->rx_count = HCI_ACL_HDR_SIZE;
 215                                 break;
 216
 217                         case HCI_SCODATA_PKT:
 218                                 info->rx_state = RECV_WAIT_SCO_HEADER;
 219                                 info->rx_count = HCI_SCO_HDR_SIZE;
 220                                 break;
 221
 222                         default:
 223                                 /* Unknown packet */
 224                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 225                                 info->hdev->stat.err_rx++;
 226                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
 227
 228                                 kfree_skb(info->rx_skb);
 229                                 info->rx_skb = NULL;
 230                                 break;
 231
 232                         }
 233
 234                 } else {
 235
 236                         *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
 237                         info->rx_count--;
 238
 239                         if (info->rx_count == 0) {
 240
 241                                 int dlen;
 242                                 struct hci_event_hdr *eh;
 243                                 struct hci_acl_hdr *ah;
 244                                 struct hci_sco_hdr *sh;
 245
 246
 247                                 switch (info->rx_state) {
 248
 249                                 case RECV_WAIT_EVENT_HEADER:
 250                                         eh = hci_event_hdr(info->rx_skb);
 251                                         info->rx_state = RECV_WAIT_DATA;
 252                                         info->rx_count = eh->plen;
 253                                         break;
 254
 255                                 case RECV_WAIT_ACL_HEADER:
 256                                         ah = hci_acl_hdr(info->rx_skb);
 257                                         dlen = __le16_to_cpu(ah->dlen);
 258                                         info->rx_state = RECV_WAIT_DATA;
 259                                         info->rx_count = dlen;
 260                                         break;
 261
 262                                 case RECV_WAIT_SCO_HEADER:
 263                                         sh = hci_sco_hdr(info->rx_skb);
 264                                         info->rx_state = RECV_WAIT_DATA;
 265                                         info->rx_count = sh->dlen;
 266                                         break;
 267
 268                                 case RECV_WAIT_DATA:
 269                                         hci_recv_frame(info->rx_skb);
 270                                         info->rx_skb = NULL;
 271                                         break;
 272
 273                                 }
 274
 275                         }
 276
 277                 }
 278
 279                 /* Make sure we don't stay here too long */
 280                 if (boguscount++ > 16)
 281                         break;
 282
 283         } while (inb(iobase + UART_LSR) & UART_LSR_DR);
 284 }
 285
 286
 287 static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
 288 {
 289         btuart_info_t *info = dev_inst;
 290         unsigned int iobase;
 291         int boguscount = 0;
 292         int iir, lsr;
 293         irqreturn_t r = IRQ_NONE;
 294
 295         if (!info || !info->hdev)
 296                 /* our irq handler is shared */
 297                 return IRQ_NONE;
 298
 299         iobase = info->p_dev->resource[0]->start;
 300
 301         spin_lock(&(info->lock));
 302
 303         iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 304         while (iir) {
 305                 r = IRQ_HANDLED;
 306
 307                 /* Clear interrupt */
 308                 lsr = inb(iobase + UART_LSR);
 309
 310                 switch (iir) {
 311                 case UART_IIR_RLSI:
 312                         BT_ERR("RLSI");
 313                         break;
 314                 case UART_IIR_RDI:
 315                         /* Receive interrupt */
 316                         btuart_receive(info);
 317                         break;
 318                 case UART_IIR_THRI:
 319                         if (lsr & UART_LSR_THRE) {
 320                                 /* Transmitter ready for data */
 321                                 btuart_write_wakeup(info);
 322                         }
 323                         break;
 324                 default:
 325                         BT_ERR("Unhandled IIR=%#x", iir);
 326                         break;
 327                 }
 328
 329                 /* Make sure we don't stay here too long */
 330                 if (boguscount++ > 100)
 331                         break;
 332
 333                 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 334
 335         }
 336
 337         spin_unlock(&(info->lock));
 338
 339         return r;
 340 }
 341
 342
 343 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
 344 {
 345         unsigned long flags;
 346         unsigned int iobase;
 347         int fcr;                /* FIFO control reg */
 348         int lcr;                /* Line control reg */
 349         int divisor;
 350
 351         if (!info) {
 352                 BT_ERR("Unknown device");
 353                 return;
 354         }
 355
 356         iobase = info->p_dev->resource[0]->start;
 357
 358         spin_lock_irqsave(&(info->lock), flags);
 359
 360         /* Turn off interrupts */
 361         outb(0, iobase + UART_IER);
 362
 363         divisor = SPEED_MAX / speed;
 364
 365         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 366
 367         /*
 368          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 369          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 370          * about this timeout since it will always be fast enough.
 371          */
 372
 373         if (speed < 38400)
 374                 fcr |= UART_FCR_TRIGGER_1;
 375         else
 376                 fcr |= UART_FCR_TRIGGER_14;
 377
 378         /* Bluetooth cards use 8N1 */
 379         lcr = UART_LCR_WLEN8;
 380
 381         outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 382         outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 383         outb(divisor >> 8, iobase + UART_DLM);
 384         outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 385         outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 386
 387         /* Turn on interrupts */
 388         outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 389
 390         spin_unlock_irqrestore(&(info->lock), flags);
 391 }
 392
 393
 394
 395 /* ======================== HCI interface ======================== */
 396
 397
 398 static int btuart_hci_flush(struct hci_dev *hdev)
 399 {
 400         btuart_info_t *info = hci_get_drvdata(hdev);
 401
 402         /* Drop TX queue */
 403         skb_queue_purge(&(info->txq));
 404
 405         return 0;
 406 }
 407
 408
 409 static int btuart_hci_open(struct hci_dev *hdev)
 410 {
 411         set_bit(HCI_RUNNING, &(hdev->flags));
 412
 413         return 0;
 414 }
 415
 416
 417 static int btuart_hci_close(struct hci_dev *hdev)
 418 {
 419         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 420                 return 0;
 421
 422         btuart_hci_flush(hdev);
 423
 424         return 0;
 425 }
 426
 427
 428 static int btuart_hci_send_frame(struct sk_buff *skb)
 429 {
 430         btuart_info_t *info;
 431         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
 432
 433         if (!hdev) {
 434                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
 435                 return -ENODEV;
 436         }
 437
 438         info = hci_get_drvdata(hdev);
 439
 440         switch (bt_cb(skb)->pkt_type) {
 441         case HCI_COMMAND_PKT:
 442                 hdev->stat.cmd_tx++;
 443                 break;
 444         case HCI_ACLDATA_PKT:
 445                 hdev->stat.acl_tx++;
 446                 break;
 447         case HCI_SCODATA_PKT:
 448                 hdev->stat.sco_tx++;
 449                 break;
 450         };
 451
 452         /* Prepend skb with frame type */
 453         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 454         skb_queue_tail(&(info->txq), skb);
 455
 456         btuart_write_wakeup(info);
 457
 458         return 0;
 459 }
 460
 461
 462 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
 463 {
 464         return -ENOIOCTLCMD;
 465 }
 466
 467
 468
 469 /* ======================== Card services HCI interaction ======================== */
 470
 471
 472 static int btuart_open(btuart_info_t *info)
 473 {
 474         unsigned long flags;
 475         unsigned int iobase = info->p_dev->resource[0]->start;
 476         struct hci_dev *hdev;
 477
 478         spin_lock_init(&(info->lock));
 479
 480         skb_queue_head_init(&(info->txq));
 481
 482         info->rx_state = RECV_WAIT_PACKET_TYPE;
 483         info->rx_count = 0;
 484         info->rx_skb = NULL;
 485
 486         /* Initialize HCI device */
 487         hdev = hci_alloc_dev();
 488         if (!hdev) {
 489                 BT_ERR("Can't allocate HCI device");
 490                 return -ENOMEM;
 491         }
 492
 493         info->hdev = hdev;
 494
 495         hdev->bus = HCI_PCCARD;
 496         hci_set_drvdata(hdev, info);
 497         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 498
 499         hdev->open     = btuart_hci_open;
 500         hdev->close    = btuart_hci_close;
 501         hdev->flush    = btuart_hci_flush;
 502         hdev->send     = btuart_hci_send_frame;
 503         hdev->ioctl    = btuart_hci_ioctl;
 504
 505         spin_lock_irqsave(&(info->lock), flags);
 506
 507         /* Reset UART */
 508         outb(0, iobase + UART_MCR);
 509
 510         /* Turn off interrupts */
 511         outb(0, iobase + UART_IER);
 512
 513         /* Initialize UART */
 514         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 515         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 516
 517         /* Turn on interrupts */
 518         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 519
 520         spin_unlock_irqrestore(&(info->lock), flags);
 521
 522         btuart_change_speed(info, DEFAULT_BAUD_RATE);
 523
 524         /* Timeout before it is safe to send the first HCI packet */
 525         msleep(1000);
 526
 527         /* Register HCI device */
 528         if (hci_register_dev(hdev) < 0) {
 529                 BT_ERR("Can't register HCI device");
 530                 info->hdev = NULL;
 531                 hci_free_dev(hdev);
 532                 return -ENODEV;
 533         }
 534
 535         return 0;
 536 }
 537
 538
 539 static int btuart_close(btuart_info_t *info)
 540 {
 541         unsigned long flags;
 542         unsigned int iobase = info->p_dev->resource[0]->start;
 543         struct hci_dev *hdev = info->hdev;
 544
 545         if (!hdev)
 546                 return -ENODEV;
 547
 548         btuart_hci_close(hdev);
 549
 550         spin_lock_irqsave(&(info->lock), flags);
 551
 552         /* Reset UART */
 553         outb(0, iobase + UART_MCR);
 554
 555         /* Turn off interrupts */
 556         outb(0, iobase + UART_IER);
 557
 558         spin_unlock_irqrestore(&(info->lock), flags);
 559
 560         hci_unregister_dev(hdev);
 561         hci_free_dev(hdev);
 562
 563         return 0;
 564 }
 565
 566 static int btuart_probe(struct pcmcia_device *link)
 567 {
 568         btuart_info_t *info;
 569
 570         /* Create new info device */
 571         info = kzalloc(sizeof(*info), GFP_KERNEL);
 572         if (!info)
 573                 return -ENOMEM;
 574
 575         info->p_dev = link;
 576         link->priv = info;
 577
 578         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 579                 CONF_AUTO_SET_IO;
 580
 581         return btuart_config(link);
 582 }
 583
 584
 585 static void btuart_detach(struct pcmcia_device *link)
 586 {
 587         btuart_info_t *info = link->priv;
 588
 589         btuart_release(link);
 590         kfree(info);
 591 }
 592
 593 static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
 594 {
 595         int *try = priv_data;
 596
 597         if (try == 0)
 598                 p_dev->io_lines = 16;
 599
 600         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 601                 return -EINVAL;
 602
 603         p_dev->resource[0]->end = 8;
 604         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 605         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 606
 607         return pcmcia_request_io(p_dev);
 608 }
 609
 610 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
 611                                         void *priv_data)
 612 {
 613         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 614         int j;
 615
 616         if (p_dev->io_lines > 3)
 617                 return -ENODEV;
 618
 619         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 620         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 621         p_dev->resource[0]->end = 8;
 622
 623         for (j = 0; j < 5; j++) {
 624                 p_dev->resource[0]->start = base[j];
 625                 p_dev->io_lines = base[j] ? 16 : 3;
 626                 if (!pcmcia_request_io(p_dev))
 627                         return 0;
 628         }
 629         return -ENODEV;
 630 }
 631
 632 static int btuart_config(struct pcmcia_device *link)
 633 {
 634         btuart_info_t *info = link->priv;
 635         int i;
 636         int try;
 637
 638         /* First pass: look for a config entry that looks normal.
 639            Two tries: without IO aliases, then with aliases */
 640         for (try = 0; try < 2; try++)
 641                 if (!pcmcia_loop_config(link, btuart_check_config, &try))
 642                         goto found_port;
 643
 644         /* Second pass: try to find an entry that isn't picky about
 645            its base address, then try to grab any standard serial port
 646            address, and finally try to get any free port. */
 647         if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
 648                 goto found_port;
 649
 650         BT_ERR("No usable port range found");
 651         goto failed;
 652
 653 found_port:
 654         i = pcmcia_request_irq(link, btuart_interrupt);
 655         if (i != 0)
 656                 goto failed;
 657
 658         i = pcmcia_enable_device(link);
 659         if (i != 0)
 660                 goto failed;
 661
 662         if (btuart_open(info) != 0)
 663                 goto failed;
 664
 665         return 0;
 666
 667 failed:
 668         btuart_release(link);
 669         return -ENODEV;
 670 }
 671
 672
 673 static void btuart_release(struct pcmcia_device *link)
 674 {
 675         btuart_info_t *info = link->priv;
 676
 677         btuart_close(info);
 678
 679         pcmcia_disable_device(link);
 680 }
 681
 682 static const struct pcmcia_device_id btuart_ids[] = {
 683         /* don't use this driver. Use serial_cs + hci_uart instead */
 684         PCMCIA_DEVICE_NULL
 685 };
 686 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 687
 688 static struct pcmcia_driver btuart_driver = {
 689         .owner          = THIS_MODULE,
 690         .name           = "btuart_cs",
 691         .probe          = btuart_probe,
 692         .remove         = btuart_detach,
 693         .id_table       = btuart_ids,
 694 };
 695
 696 static int __init init_btuart_cs(void)
 697 {
 698         return pcmcia_register_driver(&btuart_driver);
 699 }
 700
 701
 702 static void __exit exit_btuart_cs(void)
 703 {
 704         pcmcia_unregister_driver(&btuart_driver);
 705 }
 706
 707 module_init(init_btuart_cs);
 708 module_exit(exit_btuart_cs);