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 <linux/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) {
 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                         hci_skb_pkt_type(info->rx_skb) = inb(iobase + UART_RX);
 204
 205                         switch (hci_skb_pkt_type(info->rx_skb)) {
 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",
 225                                        hci_skb_pkt_type(info->rx_skb));
 226                                 info->hdev->stat.err_rx++;
 227
 228                                 kfree_skb(info->rx_skb);
 229                                 info->rx_skb = NULL;
 230                                 break;
 231
 232                         }
 233
 234                 } else {
 235
 236                         skb_put_u8(info->rx_skb, 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         return 0;
 413 }
 414
 415
 416 static int btuart_hci_close(struct hci_dev *hdev)
 417 {
 418         btuart_hci_flush(hdev);
 419
 420         return 0;
 421 }
 422
 423
 424 static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 425 {
 426         struct btuart_info *info = hci_get_drvdata(hdev);
 427
 428         switch (hci_skb_pkt_type(skb)) {
 429         case HCI_COMMAND_PKT:
 430                 hdev->stat.cmd_tx++;
 431                 break;
 432         case HCI_ACLDATA_PKT:
 433                 hdev->stat.acl_tx++;
 434                 break;
 435         case HCI_SCODATA_PKT:
 436                 hdev->stat.sco_tx++;
 437                 break;
 438         }
 439
 440         /* Prepend skb with frame type */
 441         memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
 442         skb_queue_tail(&(info->txq), skb);
 443
 444         btuart_write_wakeup(info);
 445
 446         return 0;
 447 }
 448
 449
 450
 451 /* ======================== Card services HCI interaction ======================== */
 452
 453
 454 static int btuart_open(struct btuart_info *info)
 455 {
 456         unsigned long flags;
 457         unsigned int iobase = info->p_dev->resource[0]->start;
 458         struct hci_dev *hdev;
 459
 460         spin_lock_init(&(info->lock));
 461
 462         skb_queue_head_init(&(info->txq));
 463
 464         info->rx_state = RECV_WAIT_PACKET_TYPE;
 465         info->rx_count = 0;
 466         info->rx_skb = NULL;
 467
 468         /* Initialize HCI device */
 469         hdev = hci_alloc_dev();
 470         if (!hdev) {
 471                 BT_ERR("Can't allocate HCI device");
 472                 return -ENOMEM;
 473         }
 474
 475         info->hdev = hdev;
 476
 477         hdev->bus = HCI_PCCARD;
 478         hci_set_drvdata(hdev, info);
 479         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 480
 481         hdev->open  = btuart_hci_open;
 482         hdev->close = btuart_hci_close;
 483         hdev->flush = btuart_hci_flush;
 484         hdev->send  = btuart_hci_send_frame;
 485
 486         spin_lock_irqsave(&(info->lock), flags);
 487
 488         /* Reset UART */
 489         outb(0, iobase + UART_MCR);
 490
 491         /* Turn off interrupts */
 492         outb(0, iobase + UART_IER);
 493
 494         /* Initialize UART */
 495         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 496         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 497
 498         /* Turn on interrupts */
 499         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 500
 501         spin_unlock_irqrestore(&(info->lock), flags);
 502
 503         btuart_change_speed(info, DEFAULT_BAUD_RATE);
 504
 505         /* Timeout before it is safe to send the first HCI packet */
 506         msleep(1000);
 507
 508         /* Register HCI device */
 509         if (hci_register_dev(hdev) < 0) {
 510                 BT_ERR("Can't register HCI device");
 511                 info->hdev = NULL;
 512                 hci_free_dev(hdev);
 513                 return -ENODEV;
 514         }
 515
 516         return 0;
 517 }
 518
 519
 520 static int btuart_close(struct btuart_info *info)
 521 {
 522         unsigned long flags;
 523         unsigned int iobase = info->p_dev->resource[0]->start;
 524         struct hci_dev *hdev = info->hdev;
 525
 526         if (!hdev)
 527                 return -ENODEV;
 528
 529         btuart_hci_close(hdev);
 530
 531         spin_lock_irqsave(&(info->lock), flags);
 532
 533         /* Reset UART */
 534         outb(0, iobase + UART_MCR);
 535
 536         /* Turn off interrupts */
 537         outb(0, iobase + UART_IER);
 538
 539         spin_unlock_irqrestore(&(info->lock), flags);
 540
 541         hci_unregister_dev(hdev);
 542         hci_free_dev(hdev);
 543
 544         return 0;
 545 }
 546
 547 static int btuart_probe(struct pcmcia_device *link)
 548 {
 549         struct btuart_info *info;
 550
 551         /* Create new info device */
 552         info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
 553         if (!info)
 554                 return -ENOMEM;
 555
 556         info->p_dev = link;
 557         link->priv = info;
 558
 559         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 560                 CONF_AUTO_SET_IO;
 561
 562         return btuart_config(link);
 563 }
 564
 565
 566 static void btuart_detach(struct pcmcia_device *link)
 567 {
 568         btuart_release(link);
 569 }
 570
 571 static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
 572 {
 573         int *try = priv_data;
 574
 575         if (!try)
 576                 p_dev->io_lines = 16;
 577
 578         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 579                 return -EINVAL;
 580
 581         p_dev->resource[0]->end = 8;
 582         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 583         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 584
 585         return pcmcia_request_io(p_dev);
 586 }
 587
 588 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
 589                                         void *priv_data)
 590 {
 591         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 592         int j;
 593
 594         if (p_dev->io_lines > 3)
 595                 return -ENODEV;
 596
 597         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 598         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 599         p_dev->resource[0]->end = 8;
 600
 601         for (j = 0; j < 5; j++) {
 602                 p_dev->resource[0]->start = base[j];
 603                 p_dev->io_lines = base[j] ? 16 : 3;
 604                 if (!pcmcia_request_io(p_dev))
 605                         return 0;
 606         }
 607         return -ENODEV;
 608 }
 609
 610 static int btuart_config(struct pcmcia_device *link)
 611 {
 612         struct btuart_info *info = link->priv;
 613         int i;
 614         int try;
 615
 616         /* First pass: look for a config entry that looks normal.
 617          * Two tries: without IO aliases, then with aliases
 618          */
 619         for (try = 0; try < 2; try++)
 620                 if (!pcmcia_loop_config(link, btuart_check_config, &try))
 621                         goto found_port;
 622
 623         /* Second pass: try to find an entry that isn't picky about
 624          * its base address, then try to grab any standard serial port
 625          * address, and finally try to get any free port.
 626          */
 627         if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
 628                 goto found_port;
 629
 630         BT_ERR("No usable port range found");
 631         goto failed;
 632
 633 found_port:
 634         i = pcmcia_request_irq(link, btuart_interrupt);
 635         if (i != 0)
 636                 goto failed;
 637
 638         i = pcmcia_enable_device(link);
 639         if (i != 0)
 640                 goto failed;
 641
 642         if (btuart_open(info) != 0)
 643                 goto failed;
 644
 645         return 0;
 646
 647 failed:
 648         btuart_release(link);
 649         return -ENODEV;
 650 }
 651
 652
 653 static void btuart_release(struct pcmcia_device *link)
 654 {
 655         struct btuart_info *info = link->priv;
 656
 657         btuart_close(info);
 658
 659         pcmcia_disable_device(link);
 660 }
 661
 662 static const struct pcmcia_device_id btuart_ids[] = {
 663         /* don't use this driver. Use serial_cs + hci_uart instead */
 664         PCMCIA_DEVICE_NULL
 665 };
 666 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 667
 668 static struct pcmcia_driver btuart_driver = {
 669         .owner          = THIS_MODULE,
 670         .name           = "btuart_cs",
 671         .probe          = btuart_probe,
 672         .remove         = btuart_detach,
 673         .id_table       = btuart_ids,
 674 };
 675 module_pcmcia_driver(btuart_driver);