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/io.h>
  42
  43 #include <pcmcia/cistpl.h>
  44 #include <pcmcia/ciscode.h>
  45 #include <pcmcia/ds.h>
  46 #include <pcmcia/cisreg.h>
  47
  48 #include <net/bluetooth/bluetooth.h>
  49 #include <net/bluetooth/hci_core.h>
  50
  51
  52
  53 /* ======================== Module parameters ======================== */
  54
  55
  56 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  57 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
  58 MODULE_LICENSE("GPL");
  59
  60
  61
  62 /* ======================== Local structures ======================== */
  63
  64
  65 struct btuart_info {
  66         struct pcmcia_device *p_dev;
  67
  68         struct hci_dev *hdev;
  69
  70         spinlock_t lock;        /* For serializing operations */
  71
  72         struct sk_buff_head txq;
  73         unsigned long tx_state;
  74
  75         unsigned long rx_state;
  76         unsigned long rx_count;
  77         struct sk_buff *rx_skb;
  78 };
  79
  80
  81 static int btuart_config(struct pcmcia_device *link);
  82 static void btuart_release(struct pcmcia_device *link);
  83
  84 static void btuart_detach(struct pcmcia_device *p_dev);
  85
  86
  87 /* Maximum baud rate */
  88 #define SPEED_MAX  115200
  89
  90 /* Default baud rate: 57600, 115200, 230400 or 460800 */
  91 #define DEFAULT_BAUD_RATE  115200
  92
  93
  94 /* Transmit states  */
  95 #define XMIT_SENDING    1
  96 #define XMIT_WAKEUP     2
  97 #define XMIT_WAITING    8
  98
  99 /* Receiver states */
 100 #define RECV_WAIT_PACKET_TYPE   0
 101 #define RECV_WAIT_EVENT_HEADER  1
 102 #define RECV_WAIT_ACL_HEADER    2
 103 #define RECV_WAIT_SCO_HEADER    3
 104 #define RECV_WAIT_DATA          4
 105
 106
 107
 108 /* ======================== Interrupt handling ======================== */
 109
 110
 111 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 112 {
 113         int actual = 0;
 114
 115         /* Tx FIFO should be empty */
 116         if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
 117                 return 0;
 118
 119         /* Fill FIFO with current frame */
 120         while ((fifo_size-- > 0) && (actual < len)) {
 121                 /* Transmit next byte */
 122                 outb(buf[actual], iobase + UART_TX);
 123                 actual++;
 124         }
 125
 126         return actual;
 127 }
 128
 129
 130 static void btuart_write_wakeup(struct btuart_info *info)
 131 {
 132         if (!info) {
 133                 BT_ERR("Unknown device");
 134                 return;
 135         }
 136
 137         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
 138                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 139                 return;
 140         }
 141
 142         do {
 143                 unsigned int iobase = info->p_dev->resource[0]->start;
 144                 register struct sk_buff *skb;
 145                 int len;
 146
 147                 clear_bit(XMIT_WAKEUP, &(info->tx_state));
 148
 149                 if (!pcmcia_dev_present(info->p_dev))
 150                         return;
 151
 152                 skb = skb_dequeue(&(info->txq));
 153                 if (!skb)
 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(struct btuart_info *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                         info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
 195                         if (!info->rx_skb) {
 196                                 BT_ERR("Can't allocate mem for new packet");
 197                                 return;
 198                         }
 199                 }
 200
 201                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 202
 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->hdev, 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         struct btuart_info *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(struct btuart_info *info,
 344                                 unsigned int speed)
 345 {
 346         unsigned long flags;
 347         unsigned int iobase;
 348         int fcr;                /* FIFO control reg */
 349         int lcr;                /* Line control reg */
 350         int divisor;
 351
 352         if (!info) {
 353                 BT_ERR("Unknown device");
 354                 return;
 355         }
 356
 357         iobase = info->p_dev->resource[0]->start;
 358
 359         spin_lock_irqsave(&(info->lock), flags);
 360
 361         /* Turn off interrupts */
 362         outb(0, iobase + UART_IER);
 363
 364         divisor = SPEED_MAX / speed;
 365
 366         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 367
 368         /*
 369          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 370          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 371          * about this timeout since it will always be fast enough.
 372          */
 373
 374         if (speed < 38400)
 375                 fcr |= UART_FCR_TRIGGER_1;
 376         else
 377                 fcr |= UART_FCR_TRIGGER_14;
 378
 379         /* Bluetooth cards use 8N1 */
 380         lcr = UART_LCR_WLEN8;
 381
 382         outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 383         outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 384         outb(divisor >> 8, iobase + UART_DLM);
 385         outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 386         outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 387
 388         /* Turn on interrupts */
 389         outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 390
 391         spin_unlock_irqrestore(&(info->lock), flags);
 392 }
 393
 394
 395
 396 /* ======================== HCI interface ======================== */
 397
 398
 399 static int btuart_hci_flush(struct hci_dev *hdev)
 400 {
 401         struct btuart_info *info = hci_get_drvdata(hdev);
 402
 403         /* Drop TX queue */
 404         skb_queue_purge(&(info->txq));
 405
 406         return 0;
 407 }
 408
 409
 410 static int btuart_hci_open(struct hci_dev *hdev)
 411 {
 412         set_bit(HCI_RUNNING, &(hdev->flags));
 413
 414         return 0;
 415 }
 416
 417
 418 static int btuart_hci_close(struct hci_dev *hdev)
 419 {
 420         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 421                 return 0;
 422
 423         btuart_hci_flush(hdev);
 424
 425         return 0;
 426 }
 427
 428
 429 static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 430 {
 431         struct btuart_info *info = hci_get_drvdata(hdev);
 432
 433         switch (bt_cb(skb)->pkt_type) {
 434         case HCI_COMMAND_PKT:
 435                 hdev->stat.cmd_tx++;
 436                 break;
 437         case HCI_ACLDATA_PKT:
 438                 hdev->stat.acl_tx++;
 439                 break;
 440         case HCI_SCODATA_PKT:
 441                 hdev->stat.sco_tx++;
 442                 break;
 443         }
 444
 445         /* Prepend skb with frame type */
 446         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 447         skb_queue_tail(&(info->txq), skb);
 448
 449         btuart_write_wakeup(info);
 450
 451         return 0;
 452 }
 453
 454
 455
 456 /* ======================== Card services HCI interaction ======================== */
 457
 458
 459 static int btuart_open(struct btuart_info *info)
 460 {
 461         unsigned long flags;
 462         unsigned int iobase = info->p_dev->resource[0]->start;
 463         struct hci_dev *hdev;
 464
 465         spin_lock_init(&(info->lock));
 466
 467         skb_queue_head_init(&(info->txq));
 468
 469         info->rx_state = RECV_WAIT_PACKET_TYPE;
 470         info->rx_count = 0;
 471         info->rx_skb = NULL;
 472
 473         /* Initialize HCI device */
 474         hdev = hci_alloc_dev();
 475         if (!hdev) {
 476                 BT_ERR("Can't allocate HCI device");
 477                 return -ENOMEM;
 478         }
 479
 480         info->hdev = hdev;
 481
 482         hdev->bus = HCI_PCCARD;
 483         hci_set_drvdata(hdev, info);
 484         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 485
 486         hdev->open  = btuart_hci_open;
 487         hdev->close = btuart_hci_close;
 488         hdev->flush = btuart_hci_flush;
 489         hdev->send  = btuart_hci_send_frame;
 490
 491         spin_lock_irqsave(&(info->lock), flags);
 492
 493         /* Reset UART */
 494         outb(0, iobase + UART_MCR);
 495
 496         /* Turn off interrupts */
 497         outb(0, iobase + UART_IER);
 498
 499         /* Initialize UART */
 500         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 501         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 502
 503         /* Turn on interrupts */
 504         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 505
 506         spin_unlock_irqrestore(&(info->lock), flags);
 507
 508         btuart_change_speed(info, DEFAULT_BAUD_RATE);
 509
 510         /* Timeout before it is safe to send the first HCI packet */
 511         msleep(1000);
 512
 513         /* Register HCI device */
 514         if (hci_register_dev(hdev) < 0) {
 515                 BT_ERR("Can't register HCI device");
 516                 info->hdev = NULL;
 517                 hci_free_dev(hdev);
 518                 return -ENODEV;
 519         }
 520
 521         return 0;
 522 }
 523
 524
 525 static int btuart_close(struct btuart_info *info)
 526 {
 527         unsigned long flags;
 528         unsigned int iobase = info->p_dev->resource[0]->start;
 529         struct hci_dev *hdev = info->hdev;
 530
 531         if (!hdev)
 532                 return -ENODEV;
 533
 534         btuart_hci_close(hdev);
 535
 536         spin_lock_irqsave(&(info->lock), flags);
 537
 538         /* Reset UART */
 539         outb(0, iobase + UART_MCR);
 540
 541         /* Turn off interrupts */
 542         outb(0, iobase + UART_IER);
 543
 544         spin_unlock_irqrestore(&(info->lock), flags);
 545
 546         hci_unregister_dev(hdev);
 547         hci_free_dev(hdev);
 548
 549         return 0;
 550 }
 551
 552 static int btuart_probe(struct pcmcia_device *link)
 553 {
 554         struct btuart_info *info;
 555
 556         /* Create new info device */
 557         info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
 558         if (!info)
 559                 return -ENOMEM;
 560
 561         info->p_dev = link;
 562         link->priv = info;
 563
 564         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 565                 CONF_AUTO_SET_IO;
 566
 567         return btuart_config(link);
 568 }
 569
 570
 571 static void btuart_detach(struct pcmcia_device *link)
 572 {
 573         btuart_release(link);
 574 }
 575
 576 static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
 577 {
 578         int *try = priv_data;
 579
 580         if (!try)
 581                 p_dev->io_lines = 16;
 582
 583         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 584                 return -EINVAL;
 585
 586         p_dev->resource[0]->end = 8;
 587         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 588         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 589
 590         return pcmcia_request_io(p_dev);
 591 }
 592
 593 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
 594                                         void *priv_data)
 595 {
 596         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 597         int j;
 598
 599         if (p_dev->io_lines > 3)
 600                 return -ENODEV;
 601
 602         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 603         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 604         p_dev->resource[0]->end = 8;
 605
 606         for (j = 0; j < 5; j++) {
 607                 p_dev->resource[0]->start = base[j];
 608                 p_dev->io_lines = base[j] ? 16 : 3;
 609                 if (!pcmcia_request_io(p_dev))
 610                         return 0;
 611         }
 612         return -ENODEV;
 613 }
 614
 615 static int btuart_config(struct pcmcia_device *link)
 616 {
 617         struct btuart_info *info = link->priv;
 618         int i;
 619         int try;
 620
 621         /* First pass: look for a config entry that looks normal.
 622            Two tries: without IO aliases, then with aliases */
 623         for (try = 0; try < 2; try++)
 624                 if (!pcmcia_loop_config(link, btuart_check_config, &try))
 625                         goto found_port;
 626
 627         /* Second pass: try to find an entry that isn't picky about
 628            its base address, then try to grab any standard serial port
 629            address, and finally try to get any free port. */
 630         if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
 631                 goto found_port;
 632
 633         BT_ERR("No usable port range found");
 634         goto failed;
 635
 636 found_port:
 637         i = pcmcia_request_irq(link, btuart_interrupt);
 638         if (i != 0)
 639                 goto failed;
 640
 641         i = pcmcia_enable_device(link);
 642         if (i != 0)
 643                 goto failed;
 644
 645         if (btuart_open(info) != 0)
 646                 goto failed;
 647
 648         return 0;
 649
 650 failed:
 651         btuart_release(link);
 652         return -ENODEV;
 653 }
 654
 655
 656 static void btuart_release(struct pcmcia_device *link)
 657 {
 658         struct btuart_info *info = link->priv;
 659
 660         btuart_close(info);
 661
 662         pcmcia_disable_device(link);
 663 }
 664
 665 static const struct pcmcia_device_id btuart_ids[] = {
 666         /* don't use this driver. Use serial_cs + hci_uart instead */
 667         PCMCIA_DEVICE_NULL
 668 };
 669 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 670
 671 static struct pcmcia_driver btuart_driver = {
 672         .owner          = THIS_MODULE,
 673         .name           = "btuart_cs",
 674         .probe          = btuart_probe,
 675         .remove         = btuart_detach,
 676         .id_table       = btuart_ids,
 677 };
 678 module_pcmcia_driver(btuart_driver);