3 * A driver for Nokia Connectivity Card DTL-1 devices
5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
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;
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.
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.
23 #include <linux/module.h>
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>
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>
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>
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
55 /* ======================== Module parameters ======================== */
58 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
59 MODULE_DESCRIPTION("Bluetooth driver for Nokia Connectivity Card DTL-1");
60 MODULE_LICENSE("GPL");
64 /* ======================== Local structures ======================== */
67 typedef struct dtl1_info_t
{
68 struct pcmcia_device
*p_dev
;
72 spinlock_t lock
; /* For serializing operations */
74 unsigned long flowmask
; /* HCI flow mask */
77 struct sk_buff_head txq
;
78 unsigned long tx_state
;
80 unsigned long rx_state
;
81 unsigned long rx_count
;
82 struct sk_buff
*rx_skb
;
86 static int dtl1_config(struct pcmcia_device
*link
);
87 static void dtl1_release(struct pcmcia_device
*link
);
89 static void dtl1_detach(struct pcmcia_device
*p_dev
);
93 #define XMIT_SENDING 1
95 #define XMIT_WAITING 8
98 #define RECV_WAIT_NSH 0
99 #define RECV_WAIT_DATA 1
106 } __packed nsh_t
; /* Nokia Specific Header */
108 #define NSHL 4 /* Nokia Specific Header Length */
112 /* ======================== Interrupt handling ======================== */
115 static int dtl1_write(unsigned int iobase
, int fifo_size
, __u8
*buf
, int len
)
119 /* Tx FIFO should be empty */
120 if (!(inb(iobase
+ UART_LSR
) & UART_LSR_THRE
))
123 /* Fill FIFO with current frame */
124 while ((fifo_size
-- > 0) && (actual
< len
)) {
125 /* Transmit next byte */
126 outb(buf
[actual
], iobase
+ UART_TX
);
134 static void dtl1_write_wakeup(dtl1_info_t
*info
)
137 BT_ERR("Unknown device");
141 if (test_bit(XMIT_WAITING
, &(info
->tx_state
))) {
142 set_bit(XMIT_WAKEUP
, &(info
->tx_state
));
146 if (test_and_set_bit(XMIT_SENDING
, &(info
->tx_state
))) {
147 set_bit(XMIT_WAKEUP
, &(info
->tx_state
));
152 register unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
153 register struct sk_buff
*skb
;
156 clear_bit(XMIT_WAKEUP
, &(info
->tx_state
));
158 if (!pcmcia_dev_present(info
->p_dev
))
161 if (!(skb
= skb_dequeue(&(info
->txq
))))
165 len
= dtl1_write(iobase
, 32, skb
->data
, skb
->len
);
167 if (len
== skb
->len
) {
168 set_bit(XMIT_WAITING
, &(info
->tx_state
));
172 skb_queue_head(&(info
->txq
), skb
);
175 info
->hdev
->stat
.byte_tx
+= len
;
177 } while (test_bit(XMIT_WAKEUP
, &(info
->tx_state
)));
179 clear_bit(XMIT_SENDING
, &(info
->tx_state
));
183 static void dtl1_control(dtl1_info_t
*info
, struct sk_buff
*skb
)
185 u8 flowmask
= *(u8
*)skb
->data
;
188 printk(KERN_INFO
"Bluetooth: Nokia control data =");
189 for (i
= 0; i
< skb
->len
; i
++) {
190 printk(" %02x", skb
->data
[i
]);
194 /* transition to active state */
195 if (((info
->flowmask
& 0x07) == 0) && ((flowmask
& 0x07) != 0)) {
196 clear_bit(XMIT_WAITING
, &(info
->tx_state
));
197 dtl1_write_wakeup(info
);
200 info
->flowmask
= flowmask
;
206 static void dtl1_receive(dtl1_info_t
*info
)
213 BT_ERR("Unknown device");
217 iobase
= info
->p_dev
->resource
[0]->start
;
220 info
->hdev
->stat
.byte_rx
++;
222 /* Allocate packet */
223 if (info
->rx_skb
== NULL
)
224 if (!(info
->rx_skb
= bt_skb_alloc(HCI_MAX_FRAME_SIZE
, GFP_ATOMIC
))) {
225 BT_ERR("Can't allocate mem for new packet");
226 info
->rx_state
= RECV_WAIT_NSH
;
227 info
->rx_count
= NSHL
;
231 *skb_put(info
->rx_skb
, 1) = inb(iobase
+ UART_RX
);
232 nsh
= (nsh_t
*)info
->rx_skb
->data
;
236 if (info
->rx_count
== 0) {
238 switch (info
->rx_state
) {
240 info
->rx_state
= RECV_WAIT_DATA
;
241 info
->rx_count
= nsh
->len
+ (nsh
->len
& 0x0001);
244 bt_cb(info
->rx_skb
)->pkt_type
= nsh
->type
;
246 /* remove PAD byte if it exists */
247 if (nsh
->len
& 0x0001) {
248 info
->rx_skb
->tail
--;
253 skb_pull(info
->rx_skb
, NSHL
);
255 switch (bt_cb(info
->rx_skb
)->pkt_type
) {
257 /* control data for the Nokia Card */
258 dtl1_control(info
, info
->rx_skb
);
263 /* send frame to the HCI layer */
264 info
->rx_skb
->dev
= (void *) info
->hdev
;
265 bt_cb(info
->rx_skb
)->pkt_type
&= 0x0f;
266 hci_recv_frame(info
->rx_skb
);
270 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info
->rx_skb
)->pkt_type
);
271 kfree_skb(info
->rx_skb
);
275 info
->rx_state
= RECV_WAIT_NSH
;
276 info
->rx_count
= NSHL
;
283 /* Make sure we don't stay here too long */
284 if (boguscount
++ > 32)
287 } while (inb(iobase
+ UART_LSR
) & UART_LSR_DR
);
291 static irqreturn_t
dtl1_interrupt(int irq
, void *dev_inst
)
293 dtl1_info_t
*info
= dev_inst
;
298 irqreturn_t r
= IRQ_NONE
;
300 if (!info
|| !info
->hdev
)
301 /* our irq handler is shared */
304 iobase
= info
->p_dev
->resource
[0]->start
;
306 spin_lock(&(info
->lock
));
308 iir
= inb(iobase
+ UART_IIR
) & UART_IIR_ID
;
312 /* Clear interrupt */
313 lsr
= inb(iobase
+ UART_LSR
);
320 /* Receive interrupt */
324 if (lsr
& UART_LSR_THRE
) {
325 /* Transmitter ready for data */
326 dtl1_write_wakeup(info
);
330 BT_ERR("Unhandled IIR=%#x", iir
);
334 /* Make sure we don't stay here too long */
335 if (boguscount
++ > 100)
338 iir
= inb(iobase
+ UART_IIR
) & UART_IIR_ID
;
342 msr
= inb(iobase
+ UART_MSR
);
344 if (info
->ri_latch
^ (msr
& UART_MSR_RI
)) {
345 info
->ri_latch
= msr
& UART_MSR_RI
;
346 clear_bit(XMIT_WAITING
, &(info
->tx_state
));
347 dtl1_write_wakeup(info
);
351 spin_unlock(&(info
->lock
));
358 /* ======================== HCI interface ======================== */
361 static int dtl1_hci_open(struct hci_dev
*hdev
)
363 set_bit(HCI_RUNNING
, &(hdev
->flags
));
369 static int dtl1_hci_flush(struct hci_dev
*hdev
)
371 dtl1_info_t
*info
= (dtl1_info_t
*)(hdev
->driver_data
);
374 skb_queue_purge(&(info
->txq
));
380 static int dtl1_hci_close(struct hci_dev
*hdev
)
382 if (!test_and_clear_bit(HCI_RUNNING
, &(hdev
->flags
)))
385 dtl1_hci_flush(hdev
);
391 static int dtl1_hci_send_frame(struct sk_buff
*skb
)
394 struct hci_dev
*hdev
= (struct hci_dev
*)(skb
->dev
);
399 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
403 info
= (dtl1_info_t
*)(hdev
->driver_data
);
405 switch (bt_cb(skb
)->pkt_type
) {
406 case HCI_COMMAND_PKT
:
410 case HCI_ACLDATA_PKT
:
414 case HCI_SCODATA_PKT
:
425 s
= bt_skb_alloc(NSHL
+ skb
->len
+ 1, GFP_ATOMIC
);
429 skb_reserve(s
, NSHL
);
430 skb_copy_from_linear_data(skb
, skb_put(s
, skb
->len
), skb
->len
);
431 if (skb
->len
& 0x0001)
432 *skb_put(s
, 1) = 0; /* PAD */
434 /* Prepend skb with Nokia frame header and queue */
435 memcpy(skb_push(s
, NSHL
), &nsh
, NSHL
);
436 skb_queue_tail(&(info
->txq
), s
);
438 dtl1_write_wakeup(info
);
446 static void dtl1_hci_destruct(struct hci_dev
*hdev
)
451 static int dtl1_hci_ioctl(struct hci_dev
*hdev
, unsigned int cmd
, unsigned long arg
)
458 /* ======================== Card services HCI interaction ======================== */
461 static int dtl1_open(dtl1_info_t
*info
)
464 unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
465 struct hci_dev
*hdev
;
467 spin_lock_init(&(info
->lock
));
469 skb_queue_head_init(&(info
->txq
));
471 info
->rx_state
= RECV_WAIT_NSH
;
472 info
->rx_count
= NSHL
;
475 set_bit(XMIT_WAITING
, &(info
->tx_state
));
477 /* Initialize HCI device */
478 hdev
= hci_alloc_dev();
480 BT_ERR("Can't allocate HCI device");
486 hdev
->bus
= HCI_PCCARD
;
487 hdev
->driver_data
= info
;
488 SET_HCIDEV_DEV(hdev
, &info
->p_dev
->dev
);
490 hdev
->open
= dtl1_hci_open
;
491 hdev
->close
= dtl1_hci_close
;
492 hdev
->flush
= dtl1_hci_flush
;
493 hdev
->send
= dtl1_hci_send_frame
;
494 hdev
->destruct
= dtl1_hci_destruct
;
495 hdev
->ioctl
= dtl1_hci_ioctl
;
497 hdev
->owner
= THIS_MODULE
;
499 spin_lock_irqsave(&(info
->lock
), flags
);
502 outb(0, iobase
+ UART_MCR
);
504 /* Turn off interrupts */
505 outb(0, iobase
+ UART_IER
);
507 /* Initialize UART */
508 outb(UART_LCR_WLEN8
, iobase
+ UART_LCR
); /* Reset DLAB */
509 outb((UART_MCR_DTR
| UART_MCR_RTS
| UART_MCR_OUT2
), iobase
+ UART_MCR
);
511 info
->ri_latch
= inb(info
->p_dev
->resource
[0]->start
+ UART_MSR
)
514 /* Turn on interrupts */
515 outb(UART_IER_RLSI
| UART_IER_RDI
| UART_IER_THRI
, iobase
+ UART_IER
);
517 spin_unlock_irqrestore(&(info
->lock
), flags
);
519 /* Timeout before it is safe to send the first HCI packet */
522 /* Register HCI device */
523 if (hci_register_dev(hdev
) < 0) {
524 BT_ERR("Can't register HCI device");
534 static int dtl1_close(dtl1_info_t
*info
)
537 unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
538 struct hci_dev
*hdev
= info
->hdev
;
543 dtl1_hci_close(hdev
);
545 spin_lock_irqsave(&(info
->lock
), flags
);
548 outb(0, iobase
+ UART_MCR
);
550 /* Turn off interrupts */
551 outb(0, iobase
+ UART_IER
);
553 spin_unlock_irqrestore(&(info
->lock
), flags
);
555 if (hci_unregister_dev(hdev
) < 0)
556 BT_ERR("Can't unregister HCI device %s", hdev
->name
);
563 static int dtl1_probe(struct pcmcia_device
*link
)
567 /* Create new info device */
568 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
575 link
->resource
[0]->flags
|= IO_DATA_PATH_WIDTH_8
;
576 link
->resource
[0]->end
= 8;
578 link
->conf
.Attributes
= CONF_ENABLE_IRQ
;
579 link
->conf
.IntType
= INT_MEMORY_AND_IO
;
581 return dtl1_config(link
);
585 static void dtl1_detach(struct pcmcia_device
*link
)
587 dtl1_info_t
*info
= link
->priv
;
594 static int dtl1_confcheck(struct pcmcia_device
*p_dev
,
595 cistpl_cftable_entry_t
*cf
,
596 cistpl_cftable_entry_t
*dflt
,
600 if ((cf
->io
.nwin
!= 1) || (cf
->io
.win
[0].len
<= 8))
603 p_dev
->resource
[0]->start
= cf
->io
.win
[0].base
;
604 p_dev
->resource
[0]->end
= cf
->io
.win
[0].len
; /*yo */
605 p_dev
->io_lines
= cf
->io
.flags
& CISTPL_IO_LINES_MASK
;
606 return pcmcia_request_io(p_dev
);
609 static int dtl1_config(struct pcmcia_device
*link
)
611 dtl1_info_t
*info
= link
->priv
;
614 /* Look for a generic full-sized window */
615 link
->resource
[0]->end
= 8;
616 if (pcmcia_loop_config(link
, dtl1_confcheck
, NULL
) < 0)
619 i
= pcmcia_request_irq(link
, dtl1_interrupt
);
623 i
= pcmcia_request_configuration(link
, &link
->conf
);
627 if (dtl1_open(info
) != 0)
638 static void dtl1_release(struct pcmcia_device
*link
)
640 dtl1_info_t
*info
= link
->priv
;
644 pcmcia_disable_device(link
);
648 static struct pcmcia_device_id dtl1_ids
[] = {
649 PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-1", 0xe1bfdd64, 0xe168480d),
650 PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-4", 0xe1bfdd64, 0x9102bc82),
651 PCMCIA_DEVICE_PROD_ID12("Socket", "CF", 0xb38bcc2e, 0x44ebf863),
652 PCMCIA_DEVICE_PROD_ID12("Socket", "CF+ Personal Network Card", 0xb38bcc2e, 0xe732bae3),
655 MODULE_DEVICE_TABLE(pcmcia
, dtl1_ids
);
657 static struct pcmcia_driver dtl1_driver
= {
658 .owner
= THIS_MODULE
,
663 .remove
= dtl1_detach
,
664 .id_table
= dtl1_ids
,
667 static int __init
init_dtl1_cs(void)
669 return pcmcia_register_driver(&dtl1_driver
);
673 static void __exit
exit_dtl1_cs(void)
675 pcmcia_unregister_driver(&dtl1_driver
);
678 module_init(init_dtl1_cs
);
679 module_exit(exit_dtl1_cs
);