8a6864fc8c38c7d01cc6419e1ed458cac287647b
[linux-2.6.git] / 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 = (btuart_info_t *)(hdev->driver_data);
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 = (btuart_info_t *)(hdev->driver_data);
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 void btuart_hci_destruct(struct hci_dev *hdev)
463 {
464 }
465
466
467 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
468 {
469         return -ENOIOCTLCMD;
470 }
471
472
473
474 /* ======================== Card services HCI interaction ======================== */
475
476
477 static int btuart_open(btuart_info_t *info)
478 {
479         unsigned long flags;
480         unsigned int iobase = info->p_dev->resource[0]->start;
481         struct hci_dev *hdev;
482
483         spin_lock_init(&(info->lock));
484
485         skb_queue_head_init(&(info->txq));
486
487         info->rx_state = RECV_WAIT_PACKET_TYPE;
488         info->rx_count = 0;
489         info->rx_skb = NULL;
490
491         /* Initialize HCI device */
492         hdev = hci_alloc_dev();
493         if (!hdev) {
494                 BT_ERR("Can't allocate HCI device");
495                 return -ENOMEM;
496         }
497
498         info->hdev = hdev;
499
500         hdev->bus = HCI_PCCARD;
501         hdev->driver_data = info;
502         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
503
504         hdev->open     = btuart_hci_open;
505         hdev->close    = btuart_hci_close;
506         hdev->flush    = btuart_hci_flush;
507         hdev->send     = btuart_hci_send_frame;
508         hdev->destruct = btuart_hci_destruct;
509         hdev->ioctl    = btuart_hci_ioctl;
510
511         hdev->owner = THIS_MODULE;
512
513         spin_lock_irqsave(&(info->lock), flags);
514
515         /* Reset UART */
516         outb(0, iobase + UART_MCR);
517
518         /* Turn off interrupts */
519         outb(0, iobase + UART_IER);
520
521         /* Initialize UART */
522         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
523         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
524
525         /* Turn on interrupts */
526         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
527
528         spin_unlock_irqrestore(&(info->lock), flags);
529
530         btuart_change_speed(info, DEFAULT_BAUD_RATE);
531
532         /* Timeout before it is safe to send the first HCI packet */
533         msleep(1000);
534
535         /* Register HCI device */
536         if (hci_register_dev(hdev) < 0) {
537                 BT_ERR("Can't register HCI device");
538                 info->hdev = NULL;
539                 hci_free_dev(hdev);
540                 return -ENODEV;
541         }
542
543         return 0;
544 }
545
546
547 static int btuart_close(btuart_info_t *info)
548 {
549         unsigned long flags;
550         unsigned int iobase = info->p_dev->resource[0]->start;
551         struct hci_dev *hdev = info->hdev;
552
553         if (!hdev)
554                 return -ENODEV;
555
556         btuart_hci_close(hdev);
557
558         spin_lock_irqsave(&(info->lock), flags);
559
560         /* Reset UART */
561         outb(0, iobase + UART_MCR);
562
563         /* Turn off interrupts */
564         outb(0, iobase + UART_IER);
565
566         spin_unlock_irqrestore(&(info->lock), flags);
567
568         if (hci_unregister_dev(hdev) < 0)
569                 BT_ERR("Can't unregister HCI device %s", hdev->name);
570
571         hci_free_dev(hdev);
572
573         return 0;
574 }
575
576 static int btuart_probe(struct pcmcia_device *link)
577 {
578         btuart_info_t *info;
579
580         /* Create new info device */
581         info = kzalloc(sizeof(*info), GFP_KERNEL);
582         if (!info)
583                 return -ENOMEM;
584
585         info->p_dev = link;
586         link->priv = info;
587
588         link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
589         link->resource[0]->end = 8;
590
591         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP;
592
593         return btuart_config(link);
594 }
595
596
597 static void btuart_detach(struct pcmcia_device *link)
598 {
599         btuart_info_t *info = link->priv;
600
601         btuart_release(link);
602         kfree(info);
603 }
604
605 static int btuart_check_config(struct pcmcia_device *p_dev,
606                                cistpl_cftable_entry_t *cf,
607                                cistpl_cftable_entry_t *dflt,
608                                void *priv_data)
609 {
610         int *try = priv_data;
611         p_dev->io_lines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
612
613         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
614             (cf->io.win[0].base != 0)) {
615                 p_dev->resource[0]->start = cf->io.win[0].base;
616                 if (!pcmcia_request_io(p_dev))
617                         return 0;
618         }
619         return -ENODEV;
620 }
621
622 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
623                                         cistpl_cftable_entry_t *cf,
624                                         cistpl_cftable_entry_t *dflt,
625                                         void *priv_data)
626 {
627         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
628         int j;
629
630         if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
631                 for (j = 0; j < 5; j++) {
632                         p_dev->resource[0]->start = base[j];
633                         p_dev->io_lines = base[j] ? 16 : 3;
634                         if (!pcmcia_request_io(p_dev))
635                                 return 0;
636                 }
637         }
638         return -ENODEV;
639 }
640
641 static int btuart_config(struct pcmcia_device *link)
642 {
643         btuart_info_t *info = link->priv;
644         int i;
645         int try;
646
647         /* First pass: look for a config entry that looks normal.
648            Two tries: without IO aliases, then with aliases */
649         for (try = 0; try < 2; try++)
650                 if (!pcmcia_loop_config(link, btuart_check_config, &try))
651                         goto found_port;
652
653         /* Second pass: try to find an entry that isn't picky about
654            its base address, then try to grab any standard serial port
655            address, and finally try to get any free port. */
656         if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
657                 goto found_port;
658
659         BT_ERR("No usable port range found");
660         goto failed;
661
662 found_port:
663         i = pcmcia_request_irq(link, btuart_interrupt);
664         if (i != 0)
665                 goto failed;
666
667         i = pcmcia_enable_device(link);
668         if (i != 0)
669                 goto failed;
670
671         if (btuart_open(info) != 0)
672                 goto failed;
673
674         return 0;
675
676 failed:
677         btuart_release(link);
678         return -ENODEV;
679 }
680
681
682 static void btuart_release(struct pcmcia_device *link)
683 {
684         btuart_info_t *info = link->priv;
685
686         btuart_close(info);
687
688         pcmcia_disable_device(link);
689 }
690
691 static struct pcmcia_device_id btuart_ids[] = {
692         /* don't use this driver. Use serial_cs + hci_uart instead */
693         PCMCIA_DEVICE_NULL
694 };
695 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
696
697 static struct pcmcia_driver btuart_driver = {
698         .owner          = THIS_MODULE,
699         .drv            = {
700                 .name   = "btuart_cs",
701         },
702         .probe          = btuart_probe,
703         .remove         = btuart_detach,
704         .id_table       = btuart_ids,
705 };
706
707 static int __init init_btuart_cs(void)
708 {
709         return pcmcia_register_driver(&btuart_driver);
710 }
711
712
713 static void __exit exit_btuart_cs(void)
714 {
715         pcmcia_unregister_driver(&btuart_driver);
716 }
717
718 module_init(init_btuart_cs);
719 module_exit(exit_btuart_cs);