blob: 194224d07f7c391cbdb86cc025d27f6386a88f3e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#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
57MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
58MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
59MODULE_LICENSE("GPL");
60
61
62
63/* ======================== Local structures ======================== */
64
65
66typedef struct btuart_info_t {
Dominik Brodowskifd238232006-03-05 10:45:09 +010067 struct pcmcia_device *p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
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
Dominik Brodowski15b99ac2006-03-31 17:26:06 +020082static int btuart_config(struct pcmcia_device *link);
Dominik Brodowskifba395e2006-03-31 17:21:06 +020083static void btuart_release(struct pcmcia_device *link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Dominik Brodowskicc3b4862005-11-14 21:23:14 +010085static void btuart_detach(struct pcmcia_device *p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
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
112static 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
131static 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 {
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200144 register unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 register struct sk_buff *skb;
146 register int len;
147
148 clear_bit(XMIT_WAKEUP, &(info->tx_state));
149
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100150 if (!pcmcia_dev_present(info->p_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 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
175static 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
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200185 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
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;
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700203 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700205 switch (bt_cb(info->rx_skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
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 */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700224 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 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:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300250 eh = hci_event_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 info->rx_state = RECV_WAIT_DATA;
252 info->rx_count = eh->plen;
253 break;
254
255 case RECV_WAIT_ACL_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300256 ah = hci_acl_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 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:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300263 sh = hci_sco_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 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
David Howells7d12e782006-10-05 14:55:46 +0100287static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 btuart_info_t *info = dev_inst;
290 unsigned int iobase;
291 int boguscount = 0;
292 int iir, lsr;
Alan Coxaafcf992008-10-05 17:35:41 +0100293 irqreturn_t r = IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Mike Frysinger74278472009-09-14 13:43:49 -0400295 if (!info || !info->hdev)
296 /* our irq handler is shared */
297 return IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200299 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301 spin_lock(&(info->lock));
302
303 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
304 while (iir) {
Alan Coxaafcf992008-10-05 17:35:41 +0100305 r = IRQ_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
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
Alan Coxaafcf992008-10-05 17:35:41 +0100339 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340}
341
342
343static 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
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200356 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
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
Joe Perchesb92b1c52008-02-03 17:10:31 +0200387 /* Turn on interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 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
398static int btuart_hci_flush(struct hci_dev *hdev)
399{
David Herrmann155961e2012-02-09 21:58:32 +0100400 btuart_info_t *info = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
402 /* Drop TX queue */
403 skb_queue_purge(&(info->txq));
404
405 return 0;
406}
407
408
409static int btuart_hci_open(struct hci_dev *hdev)
410{
411 set_bit(HCI_RUNNING, &(hdev->flags));
412
413 return 0;
414}
415
416
417static 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
428static 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
David Herrmann155961e2012-02-09 21:58:32 +0100438 info = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700440 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 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 */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700453 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 skb_queue_tail(&(info->txq), skb);
455
456 btuart_write_wakeup(info);
457
458 return 0;
459}
460
461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462static 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
472static int btuart_open(btuart_info_t *info)
473{
474 unsigned long flags;
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200475 unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 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
Marcel Holtmannc13854c2010-02-08 15:27:07 +0100495 hdev->bus = HCI_PCCARD;
David Herrmann155961e2012-02-09 21:58:32 +0100496 hci_set_drvdata(hdev, info);
Marcel Holtmann27d35282006-07-03 10:02:37 +0200497 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 hdev->ioctl = btuart_hci_ioctl;
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 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
539static int btuart_close(btuart_info_t *info)
540{
541 unsigned long flags;
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200542 unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 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
David Herrmann13ea4012011-10-26 10:43:18 +0200560 hci_unregister_dev(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 hci_free_dev(hdev);
562
563 return 0;
564}
565
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200566static int btuart_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
568 btuart_info_t *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 /* Create new info device */
Deepak Saxena089b1db2005-11-07 01:01:26 -0800571 info = kzalloc(sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if (!info)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100573 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200575 info->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 link->priv = info;
577
Dominik Brodowski00990e72010-07-30 13:13:46 +0200578 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
579 CONF_AUTO_SET_IO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200581 return btuart_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
584
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200585static void btuart_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
587 btuart_info_t *info = link->priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100589 btuart_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 kfree(info);
591}
592
Dominik Brodowski00990e72010-07-30 13:13:46 +0200593static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200595 int *try = priv_data;
Dominik Brodowski90abdc32010-07-24 17:23:51 +0200596
Dominik Brodowski00990e72010-07-30 13:13:46 +0200597 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
609
Dominik Brodowskied588722008-07-29 08:38:55 +0200610static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
Dominik Brodowskied588722008-07-29 08:38:55 +0200611 void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Dominik Brodowskied588722008-07-29 08:38:55 +0200613 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
614 int j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
Dominik Brodowski00990e72010-07-30 13:13:46 +0200616 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;
Dominik Brodowskied588722008-07-29 08:38:55 +0200628 }
629 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630}
631
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200632static int btuart_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 btuart_info_t *info = link->priv;
Dominik Brodowskied588722008-07-29 08:38:55 +0200635 int i;
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200636 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Dominik Brodowskied588722008-07-29 08:38:55 +0200638 /* 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++)
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200641 if (!pcmcia_loop_config(link, btuart_check_config, &try))
Dominik Brodowskied588722008-07-29 08:38:55 +0200642 goto found_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
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. */
Dominik Brodowskied588722008-07-29 08:38:55 +0200647 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
648 goto found_port;
649
650 BT_ERR("No usable port range found");
Dominik Brodowskied588722008-07-29 08:38:55 +0200651 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653found_port:
Dominik Brodowskieb141202010-03-07 12:21:16 +0100654 i = pcmcia_request_irq(link, btuart_interrupt);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200655 if (i != 0)
Dominik Brodowskieb141202010-03-07 12:21:16 +0100656 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Dominik Brodowski1ac71e52010-07-29 19:27:09 +0200658 i = pcmcia_enable_device(link);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200659 if (i != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662 if (btuart_open(info) != 0)
663 goto failed;
664
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200665 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667failed:
668 btuart_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200669 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670}
671
672
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200673static void btuart_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674{
675 btuart_info_t *info = link->priv;
676
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100677 btuart_close(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200679 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680}
681
Joe Perches25f8f542011-05-03 19:29:01 -0700682static const struct pcmcia_device_id btuart_ids[] = {
Dominik Brodowski279c9362005-06-27 16:28:38 -0700683 /* don't use this driver. Use serial_cs + hci_uart instead */
684 PCMCIA_DEVICE_NULL
685};
686MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
687
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688static struct pcmcia_driver btuart_driver = {
689 .owner = THIS_MODULE,
Dominik Brodowski2e9b9812010-08-08 11:36:26 +0200690 .name = "btuart_cs",
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200691 .probe = btuart_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100692 .remove = btuart_detach,
Dominik Brodowski279c9362005-06-27 16:28:38 -0700693 .id_table = btuart_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694};
695
696static int __init init_btuart_cs(void)
697{
698 return pcmcia_register_driver(&btuart_driver);
699}
700
701
702static void __exit exit_btuart_cs(void)
703{
704 pcmcia_unregister_driver(&btuart_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
707module_init(init_btuart_cs);
708module_exit(exit_btuart_cs);