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/cistpl.h>
45 #include <pcmcia/ciscode.h>
46 #include <pcmcia/ds.h>
47 #include <pcmcia/cisreg.h>
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
54 /* ======================== Module parameters ======================== */
57 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
58 MODULE_DESCRIPTION("Bluetooth driver for Nokia Connectivity Card DTL-1");
59 MODULE_LICENSE("GPL");
63 /* ======================== Local structures ======================== */
66 typedef struct dtl1_info_t
{
67 struct pcmcia_device
*p_dev
;
71 spinlock_t lock
; /* For serializing operations */
73 unsigned long flowmask
; /* HCI flow mask */
76 struct sk_buff_head txq
;
77 unsigned long tx_state
;
79 unsigned long rx_state
;
80 unsigned long rx_count
;
81 struct sk_buff
*rx_skb
;
85 static int dtl1_config(struct pcmcia_device
*link
);
86 static void dtl1_release(struct pcmcia_device
*link
);
88 static void dtl1_detach(struct pcmcia_device
*p_dev
);
92 #define XMIT_SENDING 1
94 #define XMIT_WAITING 8
97 #define RECV_WAIT_NSH 0
98 #define RECV_WAIT_DATA 1
105 } __packed nsh_t
; /* Nokia Specific Header */
107 #define NSHL 4 /* Nokia Specific Header Length */
111 /* ======================== Interrupt handling ======================== */
114 static int dtl1_write(unsigned int iobase
, int fifo_size
, __u8
*buf
, int len
)
118 /* Tx FIFO should be empty */
119 if (!(inb(iobase
+ UART_LSR
) & UART_LSR_THRE
))
122 /* Fill FIFO with current frame */
123 while ((fifo_size
-- > 0) && (actual
< len
)) {
124 /* Transmit next byte */
125 outb(buf
[actual
], iobase
+ UART_TX
);
133 static void dtl1_write_wakeup(dtl1_info_t
*info
)
136 BT_ERR("Unknown device");
140 if (test_bit(XMIT_WAITING
, &(info
->tx_state
))) {
141 set_bit(XMIT_WAKEUP
, &(info
->tx_state
));
145 if (test_and_set_bit(XMIT_SENDING
, &(info
->tx_state
))) {
146 set_bit(XMIT_WAKEUP
, &(info
->tx_state
));
151 register unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
152 register struct sk_buff
*skb
;
155 clear_bit(XMIT_WAKEUP
, &(info
->tx_state
));
157 if (!pcmcia_dev_present(info
->p_dev
))
160 if (!(skb
= skb_dequeue(&(info
->txq
))))
164 len
= dtl1_write(iobase
, 32, skb
->data
, skb
->len
);
166 if (len
== skb
->len
) {
167 set_bit(XMIT_WAITING
, &(info
->tx_state
));
171 skb_queue_head(&(info
->txq
), skb
);
174 info
->hdev
->stat
.byte_tx
+= len
;
176 } while (test_bit(XMIT_WAKEUP
, &(info
->tx_state
)));
178 clear_bit(XMIT_SENDING
, &(info
->tx_state
));
182 static void dtl1_control(dtl1_info_t
*info
, struct sk_buff
*skb
)
184 u8 flowmask
= *(u8
*)skb
->data
;
187 printk(KERN_INFO
"Bluetooth: Nokia control data =");
188 for (i
= 0; i
< skb
->len
; i
++) {
189 printk(" %02x", skb
->data
[i
]);
193 /* transition to active state */
194 if (((info
->flowmask
& 0x07) == 0) && ((flowmask
& 0x07) != 0)) {
195 clear_bit(XMIT_WAITING
, &(info
->tx_state
));
196 dtl1_write_wakeup(info
);
199 info
->flowmask
= flowmask
;
205 static void dtl1_receive(dtl1_info_t
*info
)
212 BT_ERR("Unknown device");
216 iobase
= info
->p_dev
->resource
[0]->start
;
219 info
->hdev
->stat
.byte_rx
++;
221 /* Allocate packet */
222 if (info
->rx_skb
== NULL
)
223 if (!(info
->rx_skb
= bt_skb_alloc(HCI_MAX_FRAME_SIZE
, GFP_ATOMIC
))) {
224 BT_ERR("Can't allocate mem for new packet");
225 info
->rx_state
= RECV_WAIT_NSH
;
226 info
->rx_count
= NSHL
;
230 *skb_put(info
->rx_skb
, 1) = inb(iobase
+ UART_RX
);
231 nsh
= (nsh_t
*)info
->rx_skb
->data
;
235 if (info
->rx_count
== 0) {
237 switch (info
->rx_state
) {
239 info
->rx_state
= RECV_WAIT_DATA
;
240 info
->rx_count
= nsh
->len
+ (nsh
->len
& 0x0001);
243 bt_cb(info
->rx_skb
)->pkt_type
= nsh
->type
;
245 /* remove PAD byte if it exists */
246 if (nsh
->len
& 0x0001) {
247 info
->rx_skb
->tail
--;
252 skb_pull(info
->rx_skb
, NSHL
);
254 switch (bt_cb(info
->rx_skb
)->pkt_type
) {
256 /* control data for the Nokia Card */
257 dtl1_control(info
, info
->rx_skb
);
262 /* send frame to the HCI layer */
263 info
->rx_skb
->dev
= (void *) info
->hdev
;
264 bt_cb(info
->rx_skb
)->pkt_type
&= 0x0f;
265 hci_recv_frame(info
->rx_skb
);
269 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info
->rx_skb
)->pkt_type
);
270 kfree_skb(info
->rx_skb
);
274 info
->rx_state
= RECV_WAIT_NSH
;
275 info
->rx_count
= NSHL
;
282 /* Make sure we don't stay here too long */
283 if (boguscount
++ > 32)
286 } while (inb(iobase
+ UART_LSR
) & UART_LSR_DR
);
290 static irqreturn_t
dtl1_interrupt(int irq
, void *dev_inst
)
292 dtl1_info_t
*info
= dev_inst
;
297 irqreturn_t r
= IRQ_NONE
;
299 if (!info
|| !info
->hdev
)
300 /* our irq handler is shared */
303 iobase
= info
->p_dev
->resource
[0]->start
;
305 spin_lock(&(info
->lock
));
307 iir
= inb(iobase
+ UART_IIR
) & UART_IIR_ID
;
311 /* Clear interrupt */
312 lsr
= inb(iobase
+ UART_LSR
);
319 /* Receive interrupt */
323 if (lsr
& UART_LSR_THRE
) {
324 /* Transmitter ready for data */
325 dtl1_write_wakeup(info
);
329 BT_ERR("Unhandled IIR=%#x", iir
);
333 /* Make sure we don't stay here too long */
334 if (boguscount
++ > 100)
337 iir
= inb(iobase
+ UART_IIR
) & UART_IIR_ID
;
341 msr
= inb(iobase
+ UART_MSR
);
343 if (info
->ri_latch
^ (msr
& UART_MSR_RI
)) {
344 info
->ri_latch
= msr
& UART_MSR_RI
;
345 clear_bit(XMIT_WAITING
, &(info
->tx_state
));
346 dtl1_write_wakeup(info
);
350 spin_unlock(&(info
->lock
));
357 /* ======================== HCI interface ======================== */
360 static int dtl1_hci_open(struct hci_dev
*hdev
)
362 set_bit(HCI_RUNNING
, &(hdev
->flags
));
368 static int dtl1_hci_flush(struct hci_dev
*hdev
)
370 dtl1_info_t
*info
= (dtl1_info_t
*)(hdev
->driver_data
);
373 skb_queue_purge(&(info
->txq
));
379 static int dtl1_hci_close(struct hci_dev
*hdev
)
381 if (!test_and_clear_bit(HCI_RUNNING
, &(hdev
->flags
)))
384 dtl1_hci_flush(hdev
);
390 static int dtl1_hci_send_frame(struct sk_buff
*skb
)
393 struct hci_dev
*hdev
= (struct hci_dev
*)(skb
->dev
);
398 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
402 info
= (dtl1_info_t
*)(hdev
->driver_data
);
404 switch (bt_cb(skb
)->pkt_type
) {
405 case HCI_COMMAND_PKT
:
409 case HCI_ACLDATA_PKT
:
413 case HCI_SCODATA_PKT
:
424 s
= bt_skb_alloc(NSHL
+ skb
->len
+ 1, GFP_ATOMIC
);
428 skb_reserve(s
, NSHL
);
429 skb_copy_from_linear_data(skb
, skb_put(s
, skb
->len
), skb
->len
);
430 if (skb
->len
& 0x0001)
431 *skb_put(s
, 1) = 0; /* PAD */
433 /* Prepend skb with Nokia frame header and queue */
434 memcpy(skb_push(s
, NSHL
), &nsh
, NSHL
);
435 skb_queue_tail(&(info
->txq
), s
);
437 dtl1_write_wakeup(info
);
445 static void dtl1_hci_destruct(struct hci_dev
*hdev
)
450 static int dtl1_hci_ioctl(struct hci_dev
*hdev
, unsigned int cmd
, unsigned long arg
)
457 /* ======================== Card services HCI interaction ======================== */
460 static int dtl1_open(dtl1_info_t
*info
)
463 unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
464 struct hci_dev
*hdev
;
466 spin_lock_init(&(info
->lock
));
468 skb_queue_head_init(&(info
->txq
));
470 info
->rx_state
= RECV_WAIT_NSH
;
471 info
->rx_count
= NSHL
;
474 set_bit(XMIT_WAITING
, &(info
->tx_state
));
476 /* Initialize HCI device */
477 hdev
= hci_alloc_dev();
479 BT_ERR("Can't allocate HCI device");
485 hdev
->bus
= HCI_PCCARD
;
486 hdev
->driver_data
= info
;
487 SET_HCIDEV_DEV(hdev
, &info
->p_dev
->dev
);
489 hdev
->open
= dtl1_hci_open
;
490 hdev
->close
= dtl1_hci_close
;
491 hdev
->flush
= dtl1_hci_flush
;
492 hdev
->send
= dtl1_hci_send_frame
;
493 hdev
->destruct
= dtl1_hci_destruct
;
494 hdev
->ioctl
= dtl1_hci_ioctl
;
496 hdev
->owner
= THIS_MODULE
;
498 spin_lock_irqsave(&(info
->lock
), flags
);
501 outb(0, iobase
+ UART_MCR
);
503 /* Turn off interrupts */
504 outb(0, iobase
+ UART_IER
);
506 /* Initialize UART */
507 outb(UART_LCR_WLEN8
, iobase
+ UART_LCR
); /* Reset DLAB */
508 outb((UART_MCR_DTR
| UART_MCR_RTS
| UART_MCR_OUT2
), iobase
+ UART_MCR
);
510 info
->ri_latch
= inb(info
->p_dev
->resource
[0]->start
+ UART_MSR
)
513 /* Turn on interrupts */
514 outb(UART_IER_RLSI
| UART_IER_RDI
| UART_IER_THRI
, iobase
+ UART_IER
);
516 spin_unlock_irqrestore(&(info
->lock
), flags
);
518 /* Timeout before it is safe to send the first HCI packet */
521 /* Register HCI device */
522 if (hci_register_dev(hdev
) < 0) {
523 BT_ERR("Can't register HCI device");
533 static int dtl1_close(dtl1_info_t
*info
)
536 unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
537 struct hci_dev
*hdev
= info
->hdev
;
542 dtl1_hci_close(hdev
);
544 spin_lock_irqsave(&(info
->lock
), flags
);
547 outb(0, iobase
+ UART_MCR
);
549 /* Turn off interrupts */
550 outb(0, iobase
+ UART_IER
);
552 spin_unlock_irqrestore(&(info
->lock
), flags
);
554 if (hci_unregister_dev(hdev
) < 0)
555 BT_ERR("Can't unregister HCI device %s", hdev
->name
);
562 static int dtl1_probe(struct pcmcia_device
*link
)
566 /* Create new info device */
567 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
574 link
->config_flags
|= CONF_ENABLE_IRQ
| CONF_AUTO_SET_IO
;
576 return dtl1_config(link
);
580 static void dtl1_detach(struct pcmcia_device
*link
)
582 dtl1_info_t
*info
= link
->priv
;
589 static int dtl1_confcheck(struct pcmcia_device
*p_dev
, void *priv_data
)
591 if ((p_dev
->resource
[1]->end
) || (p_dev
->resource
[1]->end
< 8))
594 p_dev
->resource
[0]->flags
&= ~IO_DATA_PATH_WIDTH
;
595 p_dev
->resource
[0]->flags
|= IO_DATA_PATH_WIDTH_8
;
597 return pcmcia_request_io(p_dev
);
600 static int dtl1_config(struct pcmcia_device
*link
)
602 dtl1_info_t
*info
= link
->priv
;
605 /* Look for a generic full-sized window */
606 link
->resource
[0]->end
= 8;
607 if (pcmcia_loop_config(link
, dtl1_confcheck
, NULL
) < 0)
610 i
= pcmcia_request_irq(link
, dtl1_interrupt
);
614 i
= pcmcia_enable_device(link
);
618 if (dtl1_open(info
) != 0)
629 static void dtl1_release(struct pcmcia_device
*link
)
631 dtl1_info_t
*info
= link
->priv
;
635 pcmcia_disable_device(link
);
639 static struct pcmcia_device_id dtl1_ids
[] = {
640 PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-1", 0xe1bfdd64, 0xe168480d),
641 PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-4", 0xe1bfdd64, 0x9102bc82),
642 PCMCIA_DEVICE_PROD_ID12("Socket", "CF", 0xb38bcc2e, 0x44ebf863),
643 PCMCIA_DEVICE_PROD_ID12("Socket", "CF+ Personal Network Card", 0xb38bcc2e, 0xe732bae3),
646 MODULE_DEVICE_TABLE(pcmcia
, dtl1_ids
);
648 static struct pcmcia_driver dtl1_driver
= {
649 .owner
= THIS_MODULE
,
654 .remove
= dtl1_detach
,
655 .id_table
= dtl1_ids
,
658 static int __init
init_dtl1_cs(void)
660 return pcmcia_register_driver(&dtl1_driver
);
664 static void __exit
exit_dtl1_cs(void)
666 pcmcia_unregister_driver(&dtl1_driver
);
669 module_init(init_dtl1_cs
);
670 module_exit(exit_dtl1_cs
);