?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ALSA] ad1848 - Add PM support
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / bluetooth / bluecard_cs.c
blobf36c563d72c4f49f8334ee8e6a9ee3c8793f51a9
1 /*
2 *
3 * Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)
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/config.h>
24 #include <linux/module.h>
25
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/delay.h>
32 #include <linux/timer.h>
33 #include <linux/errno.h>
34 #include <linux/ptrace.h>
35 #include <linux/ioport.h>
36 #include <linux/spinlock.h>
37 #include <linux/moduleparam.h>
38 #include <linux/wait.h>
39
40 #include <linux/skbuff.h>
41 #include <asm/io.h>
42
43 #include <pcmcia/cs_types.h>
44 #include <pcmcia/cs.h>
45 #include <pcmcia/cistpl.h>
46 #include <pcmcia/ciscode.h>
47 #include <pcmcia/ds.h>
48 #include <pcmcia/cisreg.h>
49
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
52
53
54
55 /* ======================== Module parameters ======================== */
56
57
58 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
59 MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)");
60 MODULE_LICENSE("GPL");
61
62
63
64 /* ======================== Local structures ======================== */
65
66
67 typedef struct bluecard_info_t {
68 dev_link_t link;
69 dev_node_t node;
70
71 struct hci_dev *hdev;
72
73 spinlock_t lock; /* For serializing operations */
74 struct timer_list timer; /* For LED control */
75
76 struct sk_buff_head txq;
77 unsigned long tx_state;
78
79 unsigned long rx_state;
80 unsigned long rx_count;
81 struct sk_buff *rx_skb;
82
83 unsigned char ctrl_reg;
84 unsigned long hw_state; /* Status of the hardware and LED control */
85 } bluecard_info_t;
86
87
88 static void bluecard_config(dev_link_t *link);
89 static void bluecard_release(dev_link_t *link);
90 static int bluecard_event(event_t event, int priority, event_callback_args_t *args);
91
92 static dev_info_t dev_info = "bluecard_cs";
93
94 static dev_link_t *bluecard_attach(void);
95 static void bluecard_detach(dev_link_t *);
96
97 static dev_link_t *dev_list = NULL;
98
99
100 /* Default baud rate: 57600, 115200, 230400 or 460800 */
101 #define DEFAULT_BAUD_RATE 230400
102
103
104 /* Hardware states */
105 #define CARD_READY 1
106 #define CARD_HAS_PCCARD_ID 4
107 #define CARD_HAS_POWER_LED 5
108 #define CARD_HAS_ACTIVITY_LED 6
109
110 /* Transmit states */
111 #define XMIT_SENDING 1
112 #define XMIT_WAKEUP 2
113 #define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */
114 #define XMIT_BUF_ONE_READY 6
115 #define XMIT_BUF_TWO_READY 7
116 #define XMIT_SENDING_READY 8
117
118 /* Receiver states */
119 #define RECV_WAIT_PACKET_TYPE 0
120 #define RECV_WAIT_EVENT_HEADER 1
121 #define RECV_WAIT_ACL_HEADER 2
122 #define RECV_WAIT_SCO_HEADER 3
123 #define RECV_WAIT_DATA 4
124
125 /* Special packet types */
126 #define PKT_BAUD_RATE_57600 0x80
127 #define PKT_BAUD_RATE_115200 0x81
128 #define PKT_BAUD_RATE_230400 0x82
129 #define PKT_BAUD_RATE_460800 0x83
130
131
132 /* These are the register offsets */
133 #define REG_COMMAND 0x20
134 #define REG_INTERRUPT 0x21
135 #define REG_CONTROL 0x22
136 #define REG_RX_CONTROL 0x24
137 #define REG_CARD_RESET 0x30
138 #define REG_LED_CTRL 0x30
139
140 /* REG_COMMAND */
141 #define REG_COMMAND_TX_BUF_ONE 0x01
142 #define REG_COMMAND_TX_BUF_TWO 0x02
143 #define REG_COMMAND_RX_BUF_ONE 0x04
144 #define REG_COMMAND_RX_BUF_TWO 0x08
145 #define REG_COMMAND_RX_WIN_ONE 0x00
146 #define REG_COMMAND_RX_WIN_TWO 0x10
147
148 /* REG_CONTROL */
149 #define REG_CONTROL_BAUD_RATE_57600 0x00
150 #define REG_CONTROL_BAUD_RATE_115200 0x01
151 #define REG_CONTROL_BAUD_RATE_230400 0x02
152 #define REG_CONTROL_BAUD_RATE_460800 0x03
153 #define REG_CONTROL_RTS 0x04
154 #define REG_CONTROL_BT_ON 0x08
155 #define REG_CONTROL_BT_RESET 0x10
156 #define REG_CONTROL_BT_RES_PU 0x20
157 #define REG_CONTROL_INTERRUPT 0x40
158 #define REG_CONTROL_CARD_RESET 0x80
159
160 /* REG_RX_CONTROL */
161 #define RTS_LEVEL_SHIFT_BITS 0x02
162
163
164
165 /* ======================== LED handling routines ======================== */
166
167
168 static void bluecard_activity_led_timeout(u_long arg)
169 {
170 bluecard_info_t *info = (bluecard_info_t *)arg;
171 unsigned int iobase = info->link.io.BasePort1;
172
173 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
174 return;
175
176 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
177 /* Disable activity LED */
178 outb(0x08 | 0x20, iobase + 0x30);
179 } else {
180 /* Disable power LED */
181 outb(0x00, iobase + 0x30);
182 }
183 }
184
185
186 static void bluecard_enable_activity_led(bluecard_info_t *info)
187 {
188 unsigned int iobase = info->link.io.BasePort1;
189
190 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
191 return;
192
193 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
194 /* Enable activity LED */
195 outb(0x10 | 0x40, iobase + 0x30);
196
197 /* Stop the LED after HZ/4 */
198 mod_timer(&(info->timer), jiffies + HZ / 4);
199 } else {
200 /* Enable power LED */
201 outb(0x08 | 0x20, iobase + 0x30);
202
203 /* Stop the LED after HZ/2 */
204 mod_timer(&(info->timer), jiffies + HZ / 2);
205 }
206 }
207
208
209
210 /* ======================== Interrupt handling ======================== */
211
212
213 static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len)
214 {
215 int i, actual;
216
217 actual = (len > 15) ? 15 : len;
218
219 outb_p(actual, iobase + offset);
220
221 for (i = 0; i < actual; i++)
222 outb_p(buf[i], iobase + offset + i + 1);
223
224 return actual;
225 }
226
227
228 static void bluecard_write_wakeup(bluecard_info_t *info)
229 {
230 if (!info) {
231 BT_ERR("Unknown device");
232 return;
233 }
234
235 if (!test_bit(XMIT_SENDING_READY, &(info->tx_state)))
236 return;
237
238 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
239 set_bit(XMIT_WAKEUP, &(info->tx_state));
240 return;
241 }
242
243 do {
244 register unsigned int iobase = info->link.io.BasePort1;
245 register unsigned int offset;
246 register unsigned char command;
247 register unsigned long ready_bit;
248 register struct sk_buff *skb;
249 register int len;
250
251 clear_bit(XMIT_WAKEUP, &(info->tx_state));
252
253 if (!(info->link.state & DEV_PRESENT))
254 return;
255
256 if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) {
257 if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state)))
258 break;
259 offset = 0x10;
260 command = REG_COMMAND_TX_BUF_TWO;
261 ready_bit = XMIT_BUF_TWO_READY;
262 } else {
263 if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state)))
264 break;
265 offset = 0x00;
266 command = REG_COMMAND_TX_BUF_ONE;
267 ready_bit = XMIT_BUF_ONE_READY;
268 }
269
270 if (!(skb = skb_dequeue(&(info->txq))))
271 break;
272
273 if (bt_cb(skb)->pkt_type & 0x80) {
274 /* Disable RTS */
275 info->ctrl_reg |= REG_CONTROL_RTS;
276 outb(info->ctrl_reg, iobase + REG_CONTROL);
277 }
278
279 /* Activate LED */
280 bluecard_enable_activity_led(info);
281
282 /* Send frame */
283 len = bluecard_write(iobase, offset, skb->data, skb->len);
284
285 /* Tell the FPGA to send the data */
286 outb_p(command, iobase + REG_COMMAND);
287
288 /* Mark the buffer as dirty */
289 clear_bit(ready_bit, &(info->tx_state));
290
291 if (bt_cb(skb)->pkt_type & 0x80) {
292 DECLARE_WAIT_QUEUE_HEAD(wq);
293 DEFINE_WAIT(wait);
294
295 unsigned char baud_reg;
296
297 switch (bt_cb(skb)->pkt_type) {
298 case PKT_BAUD_RATE_460800:
299 baud_reg = REG_CONTROL_BAUD_RATE_460800;
300 break;
301 case PKT_BAUD_RATE_230400:
302 baud_reg = REG_CONTROL_BAUD_RATE_230400;
303 break;
304 case PKT_BAUD_RATE_115200:
305 baud_reg = REG_CONTROL_BAUD_RATE_115200;
306 break;
307 case PKT_BAUD_RATE_57600:
308 /* Fall through... */
309 default:
310 baud_reg = REG_CONTROL_BAUD_RATE_57600;
311 break;
312 }
313
314 /* Wait until the command reaches the baseband */
315 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
316 schedule_timeout(HZ/10);
317 finish_wait(&wq, &wait);
318
319 /* Set baud on baseband */
320 info->ctrl_reg &= ~0x03;
321 info->ctrl_reg |= baud_reg;
322 outb(info->ctrl_reg, iobase + REG_CONTROL);
323
324 /* Enable RTS */
325 info->ctrl_reg &= ~REG_CONTROL_RTS;
326 outb(info->ctrl_reg, iobase + REG_CONTROL);
327
328 /* Wait before the next HCI packet can be send */
329 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
330 schedule_timeout(HZ);
331 finish_wait(&wq, &wait);
332 }
333
334 if (len == skb->len) {
335 kfree_skb(skb);
336 } else {
337 skb_pull(skb, len);
338 skb_queue_head(&(info->txq), skb);
339 }
340
341 info->hdev->stat.byte_tx += len;
342
343 /* Change buffer */
344 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state));
345
346 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
347
348 clear_bit(XMIT_SENDING, &(info->tx_state));
349 }
350
351
352 static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size)
353 {
354 int i, n, len;
355
356 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND);
357
358 len = inb(iobase + offset);
359 n = 0;
360 i = 1;
361
362 while (n < len) {
363
364 if (i == 16) {
365 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND);
366 i = 0;
367 }
368
369 buf[n] = inb(iobase + offset + i);
370
371 n++;
372 i++;
373
374 }
375
376 return len;
377 }
378
379
380 static void bluecard_receive(bluecard_info_t *info, unsigned int offset)
381 {
382 unsigned int iobase;
383 unsigned char buf[31];
384 int i, len;
385
386 if (!info) {
387 BT_ERR("Unknown device");
388 return;
389 }
390
391 iobase = info->link.io.BasePort1;
392
393 if (test_bit(XMIT_SENDING_READY, &(info->tx_state)))
394 bluecard_enable_activity_led(info);
395
396 len = bluecard_read(iobase, offset, buf, sizeof(buf));
397
398 for (i = 0; i < len; i++) {
399
400 /* Allocate packet */
401 if (info->rx_skb == NULL) {
402 info->rx_state = RECV_WAIT_PACKET_TYPE;
403 info->rx_count = 0;
404 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
405 BT_ERR("Can't allocate mem for new packet");
406 return;
407 }
408 }
409
410 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
411
412 info->rx_skb->dev = (void *) info->hdev;
413 bt_cb(info->rx_skb)->pkt_type = buf[i];
414
415 switch (bt_cb(info->rx_skb)->pkt_type) {
416
417 case 0x00:
418 /* init packet */
419 if (offset != 0x00) {
420 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
421 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
422 set_bit(XMIT_SENDING_READY, &(info->tx_state));
423 bluecard_write_wakeup(info);
424 }
425
426 kfree_skb(info->rx_skb);
427 info->rx_skb = NULL;
428 break;
429
430 case HCI_EVENT_PKT:
431 info->rx_state = RECV_WAIT_EVENT_HEADER;
432 info->rx_count = HCI_EVENT_HDR_SIZE;
433 break;
434
435 case HCI_ACLDATA_PKT:
436 info->rx_state = RECV_WAIT_ACL_HEADER;
437 info->rx_count = HCI_ACL_HDR_SIZE;
438 break;
439
440 case HCI_SCODATA_PKT:
441 info->rx_state = RECV_WAIT_SCO_HEADER;
442 info->rx_count = HCI_SCO_HDR_SIZE;
443 break;
444
445 default:
446 /* unknown packet */
447 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
448 info->hdev->stat.err_rx++;
449
450 kfree_skb(info->rx_skb);
451 info->rx_skb = NULL;
452 break;
453
454 }
455
456 } else {
457
458 *skb_put(info->rx_skb, 1) = buf[i];
459 info->rx_count--;
460
461 if (info->rx_count == 0) {
462
463 int dlen;
464 struct hci_event_hdr *eh;
465 struct hci_acl_hdr *ah;
466 struct hci_sco_hdr *sh;
467
468 switch (info->rx_state) {
469
470 case RECV_WAIT_EVENT_HEADER:
471 eh = (struct hci_event_hdr *)(info->rx_skb->data);
472 info->rx_state = RECV_WAIT_DATA;
473 info->rx_count = eh->plen;
474 break;
475
476 case RECV_WAIT_ACL_HEADER:
477 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
478 dlen = __le16_to_cpu(ah->dlen);
479 info->rx_state = RECV_WAIT_DATA;
480 info->rx_count = dlen;
481 break;
482
483 case RECV_WAIT_SCO_HEADER:
484 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
485 info->rx_state = RECV_WAIT_DATA;
486 info->rx_count = sh->dlen;
487 break;
488
489 case RECV_WAIT_DATA:
490 hci_recv_frame(info->rx_skb);
491 info->rx_skb = NULL;
492 break;
493
494 }
495
496 }
497
498 }
499
500
501 }
502
503 info->hdev->stat.byte_rx += len;
504 }
505
506
507 static irqreturn_t bluecard_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
508 {
509 bluecard_info_t *info = dev_inst;
510 unsigned int iobase;
511 unsigned char reg;
512
513 if (!info || !info->hdev) {
514 BT_ERR("Call of irq %d for unknown device", irq);
515 return IRQ_NONE;
516 }
517
518 if (!test_bit(CARD_READY, &(info->hw_state)))
519 return IRQ_HANDLED;
520
521 iobase = info->link.io.BasePort1;
522
523 spin_lock(&(info->lock));
524
525 /* Disable interrupt */
526 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT;
527 outb(info->ctrl_reg, iobase + REG_CONTROL);
528
529 reg = inb(iobase + REG_INTERRUPT);
530
531 if ((reg != 0x00) && (reg != 0xff)) {
532
533 if (reg & 0x04) {
534 bluecard_receive(info, 0x00);
535 outb(0x04, iobase + REG_INTERRUPT);
536 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
537 }
538
539 if (reg & 0x08) {
540 bluecard_receive(info, 0x10);
541 outb(0x08, iobase + REG_INTERRUPT);
542 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
543 }
544
545 if (reg & 0x01) {
546 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
547 outb(0x01, iobase + REG_INTERRUPT);
548 bluecard_write_wakeup(info);
549 }
550
551 if (reg & 0x02) {
552 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
553 outb(0x02, iobase + REG_INTERRUPT);
554 bluecard_write_wakeup(info);
555 }
556
557 }
558
559 /* Enable interrupt */
560 info->ctrl_reg |= REG_CONTROL_INTERRUPT;
561 outb(info->ctrl_reg, iobase + REG_CONTROL);
562
563 spin_unlock(&(info->lock));
564
565 return IRQ_HANDLED;
566 }
567
568
569
570 /* ======================== Device specific HCI commands ======================== */
571
572
573 static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud)
574 {
575 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
576 struct sk_buff *skb;
577
578 /* Ericsson baud rate command */
579 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 };
580
581 if (!(skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
582 BT_ERR("Can't allocate mem for new packet");
583 return -1;
584 }
585
586 switch (baud) {
587 case 460800:
588 cmd[4] = 0x00;
589 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_460800;
590 break;
591 case 230400:
592 cmd[4] = 0x01;
593 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_230400;
594 break;
595 case 115200:
596 cmd[4] = 0x02;
597 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_115200;
598 break;
599 case 57600:
600 /* Fall through... */
601 default:
602 cmd[4] = 0x03;
603 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_57600;
604 break;
605 }
606
607 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
608
609 skb_queue_tail(&(info->txq), skb);
610
611 bluecard_write_wakeup(info);
612
613 return 0;
614 }
615
616
617
618 /* ======================== HCI interface ======================== */
619
620
621 static int bluecard_hci_flush(struct hci_dev *hdev)
622 {
623 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
624
625 /* Drop TX queue */
626 skb_queue_purge(&(info->txq));
627
628 return 0;
629 }
630
631
632 static int bluecard_hci_open(struct hci_dev *hdev)
633 {
634 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
635 unsigned int iobase = info->link.io.BasePort1;
636
637 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
638 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE);
639
640 if (test_and_set_bit(HCI_RUNNING, &(hdev->flags)))
641 return 0;
642
643 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
644 /* Enable LED */
645 outb(0x08 | 0x20, iobase + 0x30);
646 }
647
648 return 0;
649 }
650
651
652 static int bluecard_hci_close(struct hci_dev *hdev)
653 {
654 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
655 unsigned int iobase = info->link.io.BasePort1;
656
657 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
658 return 0;
659
660 bluecard_hci_flush(hdev);
661
662 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
663 /* Disable LED */
664 outb(0x00, iobase + 0x30);
665 }
666
667 return 0;
668 }
669
670
671 static int bluecard_hci_send_frame(struct sk_buff *skb)
672 {
673 bluecard_info_t *info;
674 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
675
676 if (!hdev) {
677 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
678 return -ENODEV;
679 }
680
681 info = (bluecard_info_t *)(hdev->driver_data);
682
683 switch (bt_cb(skb)->pkt_type) {
684 case HCI_COMMAND_PKT:
685 hdev->stat.cmd_tx++;
686 break;
687 case HCI_ACLDATA_PKT:
688 hdev->stat.acl_tx++;
689 break;
690 case HCI_SCODATA_PKT:
691 hdev->stat.sco_tx++;
692 break;
693 };
694
695 /* Prepend skb with frame type */
696 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
697 skb_queue_tail(&(info->txq), skb);
698
699 bluecard_write_wakeup(info);
700
701 return 0;
702 }
703
704
705 static void bluecard_hci_destruct(struct hci_dev *hdev)
706 {
707 }
708
709
710 static int bluecard_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
711 {
712 return -ENOIOCTLCMD;
713 }
714
715
716
717 /* ======================== Card services HCI interaction ======================== */
718
719
720 static int bluecard_open(bluecard_info_t *info)
721 {
722 unsigned int iobase = info->link.io.BasePort1;
723 struct hci_dev *hdev;
724 unsigned char id;
725
726 spin_lock_init(&(info->lock));
727
728 init_timer(&(info->timer));
729 info->timer.function = &bluecard_activity_led_timeout;
730 info->timer.data = (u_long)info;
731
732 skb_queue_head_init(&(info->txq));
733
734 info->rx_state = RECV_WAIT_PACKET_TYPE;
735 info->rx_count = 0;
736 info->rx_skb = NULL;
737
738 /* Initialize HCI device */
739 hdev = hci_alloc_dev();
740 if (!hdev) {
741 BT_ERR("Can't allocate HCI device");
742 return -ENOMEM;
743 }
744
745 info->hdev = hdev;
746
747 hdev->type = HCI_PCCARD;
748 hdev->driver_data = info;
749
750 hdev->open = bluecard_hci_open;
751 hdev->close = bluecard_hci_close;
752 hdev->flush = bluecard_hci_flush;
753 hdev->send = bluecard_hci_send_frame;
754 hdev->destruct = bluecard_hci_destruct;
755 hdev->ioctl = bluecard_hci_ioctl;
756
757 hdev->owner = THIS_MODULE;
758
759 id = inb(iobase + 0x30);
760
761 if ((id & 0x0f) == 0x02)
762 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state));
763
764 if (id & 0x10)
765 set_bit(CARD_HAS_POWER_LED, &(info->hw_state));
766
767 if (id & 0x20)
768 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state));
769
770 /* Reset card */
771 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
772 outb(info->ctrl_reg, iobase + REG_CONTROL);
773
774 /* Turn FPGA off */
775 outb(0x80, iobase + 0x30);
776
777 /* Wait some time */
778 msleep(10);
779
780 /* Turn FPGA on */
781 outb(0x00, iobase + 0x30);
782
783 /* Activate card */
784 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU;
785 outb(info->ctrl_reg, iobase + REG_CONTROL);
786
787 /* Enable interrupt */
788 outb(0xff, iobase + REG_INTERRUPT);
789 info->ctrl_reg |= REG_CONTROL_INTERRUPT;
790 outb(info->ctrl_reg, iobase + REG_CONTROL);
791
792 if ((id & 0x0f) == 0x03) {
793 /* Disable RTS */
794 info->ctrl_reg |= REG_CONTROL_RTS;
795 outb(info->ctrl_reg, iobase + REG_CONTROL);
796
797 /* Set baud rate */
798 info->ctrl_reg |= 0x03;
799 outb(info->ctrl_reg, iobase + REG_CONTROL);
800
801 /* Enable RTS */
802 info->ctrl_reg &= ~REG_CONTROL_RTS;
803 outb(info->ctrl_reg, iobase + REG_CONTROL);
804
805 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
806 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
807 set_bit(XMIT_SENDING_READY, &(info->tx_state));
808 }
809
810 /* Start the RX buffers */
811 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
812 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
813
814 /* Signal that the hardware is ready */
815 set_bit(CARD_READY, &(info->hw_state));
816
817 /* Drop TX queue */
818 skb_queue_purge(&(info->txq));
819
820 /* Control the point at which RTS is enabled */
821 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL);
822
823 /* Timeout before it is safe to send the first HCI packet */
824 msleep(1250);
825
826 /* Register HCI device */
827 if (hci_register_dev(hdev) < 0) {
828 BT_ERR("Can't register HCI device");
829 info->hdev = NULL;
830 hci_free_dev(hdev);
831 return -ENODEV;
832 }
833
834 return 0;
835 }
836
837
838 static int bluecard_close(bluecard_info_t *info)
839 {
840 unsigned int iobase = info->link.io.BasePort1;
841 struct hci_dev *hdev = info->hdev;
842
843 if (!hdev)
844 return -ENODEV;
845
846 bluecard_hci_close(hdev);
847
848 clear_bit(CARD_READY, &(info->hw_state));
849
850 /* Reset card */
851 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
852 outb(info->ctrl_reg, iobase + REG_CONTROL);
853
854 /* Turn FPGA off */
855 outb(0x80, iobase + 0x30);
856
857 if (hci_unregister_dev(hdev) < 0)
858 BT_ERR("Can't unregister HCI device %s", hdev->name);
859
860 hci_free_dev(hdev);
861
862 return 0;
863 }
864
865 static dev_link_t *bluecard_attach(void)
866 {
867 bluecard_info_t *info;
868 client_reg_t client_reg;
869 dev_link_t *link;
870 int ret;
871
872 /* Create new info device */
873 info = kzalloc(sizeof(*info), GFP_KERNEL);
874 if (!info)
875 return NULL;
876
877 link = &info->link;
878 link->priv = info;
879
880 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
881 link->io.NumPorts1 = 8;
882 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
883 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
884
885 link->irq.Handler = bluecard_interrupt;
886 link->irq.Instance = info;
887
888 link->conf.Attributes = CONF_ENABLE_IRQ;
889 link->conf.Vcc = 50;
890 link->conf.IntType = INT_MEMORY_AND_IO;
891
892 /* Register with Card Services */
893 link->next = dev_list;
894 dev_list = link;
895 client_reg.dev_info = &dev_info;
896 client_reg.Version = 0x0210;
897 client_reg.event_callback_args.client_data = link;
898
899 ret = pcmcia_register_client(&link->handle, &client_reg);
900 if (ret != CS_SUCCESS) {
901 cs_error(link->handle, RegisterClient, ret);
902 bluecard_detach(link);
903 return NULL;
904 }
905
906 return link;
907 }
908
909
910 static void bluecard_detach(dev_link_t *link)
911 {
912 bluecard_info_t *info = link->priv;
913 dev_link_t **linkp;
914 int ret;
915
916 /* Locate device structure */
917 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
918 if (*linkp == link)
919 break;
920
921 if (*linkp == NULL)
922 return;
923
924 if (link->state & DEV_CONFIG)
925 bluecard_release(link);
926
927 if (link->handle) {
928 ret = pcmcia_deregister_client(link->handle);
929 if (ret != CS_SUCCESS)
930 cs_error(link->handle, DeregisterClient, ret);
931 }
932
933 /* Unlink device structure, free bits */
934 *linkp = link->next;
935
936 kfree(info);
937 }
938
939
940 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
941 {
942 int i;
943
944 i = pcmcia_get_first_tuple(handle, tuple);
945 if (i != CS_SUCCESS)
946 return CS_NO_MORE_ITEMS;
947
948 i = pcmcia_get_tuple_data(handle, tuple);
949 if (i != CS_SUCCESS)
950 return i;
951
952 return pcmcia_parse_tuple(handle, tuple, parse);
953 }
954
955 static void bluecard_config(dev_link_t *link)
956 {
957 client_handle_t handle = link->handle;
958 bluecard_info_t *info = link->priv;
959 tuple_t tuple;
960 u_short buf[256];
961 cisparse_t parse;
962 config_info_t config;
963 int i, n, last_ret, last_fn;
964
965 tuple.TupleData = (cisdata_t *)buf;
966 tuple.TupleOffset = 0;
967 tuple.TupleDataMax = 255;
968 tuple.Attributes = 0;
969
970 /* Get configuration register information */
971 tuple.DesiredTuple = CISTPL_CONFIG;
972 last_ret = first_tuple(handle, &tuple, &parse);
973 if (last_ret != CS_SUCCESS) {
974 last_fn = ParseTuple;
975 goto cs_failed;
976 }
977 link->conf.ConfigBase = parse.config.base;
978 link->conf.Present = parse.config.rmask[0];
979
980 /* Configure card */
981 link->state |= DEV_CONFIG;
982 i = pcmcia_get_configuration_info(handle, &config);
983 link->conf.Vcc = config.Vcc;
984
985 link->conf.ConfigIndex = 0x20;
986 link->io.NumPorts1 = 64;
987 link->io.IOAddrLines = 6;
988
989 for (n = 0; n < 0x400; n += 0x40) {
990 link->io.BasePort1 = n ^ 0x300;
991 i = pcmcia_request_io(link->handle, &link->io);
992 if (i == CS_SUCCESS)
993 break;
994 }
995
996 if (i != CS_SUCCESS) {
997 cs_error(link->handle, RequestIO, i);
998 goto failed;
999 }
1000
1001 i = pcmcia_request_irq(link->handle, &link->irq);
1002 if (i != CS_SUCCESS) {
1003 cs_error(link->handle, RequestIRQ, i);
1004 link->irq.AssignedIRQ = 0;
1005 }
1006
1007 i = pcmcia_request_configuration(link->handle, &link->conf);
1008 if (i != CS_SUCCESS) {
1009 cs_error(link->handle, RequestConfiguration, i);
1010 goto failed;
1011 }
1012
1013 if (bluecard_open(info) != 0)
1014 goto failed;
1015
1016 strcpy(info->node.dev_name, info->hdev->name);
1017 link->dev = &info->node;
1018 link->state &= ~DEV_CONFIG_PENDING;
1019
1020 return;
1021
1022 cs_failed:
1023 cs_error(link->handle, last_fn, last_ret);
1024
1025 failed:
1026 bluecard_release(link);
1027 }
1028
1029
1030 static void bluecard_release(dev_link_t *link)
1031 {
1032 bluecard_info_t *info = link->priv;
1033
1034 if (link->state & DEV_PRESENT)
1035 bluecard_close(info);
1036
1037 del_timer(&(info->timer));
1038
1039 link->dev = NULL;
1040
1041 pcmcia_release_configuration(link->handle);
1042 pcmcia_release_io(link->handle, &link->io);
1043 pcmcia_release_irq(link->handle, &link->irq);
1044
1045 link->state &= ~DEV_CONFIG;
1046 }
1047
1048
1049 static int bluecard_event(event_t event, int priority, event_callback_args_t *args)
1050 {
1051 dev_link_t *link = args->client_data;
1052 bluecard_info_t *info = link->priv;
1053
1054 switch (event) {
1055 case CS_EVENT_CARD_REMOVAL:
1056 link->state &= ~DEV_PRESENT;
1057 if (link->state & DEV_CONFIG) {
1058 bluecard_close(info);
1059 bluecard_release(link);
1060 }
1061 break;
1062 case CS_EVENT_CARD_INSERTION:
1063 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
1064 bluecard_config(link);
1065 break;
1066 case CS_EVENT_PM_SUSPEND:
1067 link->state |= DEV_SUSPEND;
1068 /* Fall through... */
1069 case CS_EVENT_RESET_PHYSICAL:
1070 if (link->state & DEV_CONFIG)
1071 pcmcia_release_configuration(link->handle);
1072 break;
1073 case CS_EVENT_PM_RESUME:
1074 link->state &= ~DEV_SUSPEND;
1075 /* Fall through... */
1076 case CS_EVENT_CARD_RESET:
1077 if (DEV_OK(link))
1078 pcmcia_request_configuration(link->handle, &link->conf);
1079 break;
1080 }
1081
1082 return 0;
1083 }
1084
1085 static struct pcmcia_device_id bluecard_ids[] = {
1086 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e),
1087 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c),
1088 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab),
1089 PCMCIA_DEVICE_NULL
1090 };
1091 MODULE_DEVICE_TABLE(pcmcia, bluecard_ids);
1092
1093 static struct pcmcia_driver bluecard_driver = {
1094 .owner = THIS_MODULE,
1095 .drv = {
1096 .name = "bluecard_cs",
1097 },
1098 .attach = bluecard_attach,
1099 .event = bluecard_event,
1100 .detach = bluecard_detach,
1101 .id_table = bluecard_ids,
1102 };
1103
1104 static int __init init_bluecard_cs(void)
1105 {
1106 return pcmcia_register_driver(&bluecard_driver);
1107 }
1108
1109
1110 static void __exit exit_bluecard_cs(void)
1111 {
1112 pcmcia_unregister_driver(&bluecard_driver);
1113 BUG_ON(dev_list != NULL);
1114 }
1115
1116 module_init(init_bluecard_cs);
1117 module_exit(exit_bluecard_cs);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree