dtl1_cs.c revision 5a0b8159e1c65ce25382d3f5189b6a462422f065 
1/*
2 *
3 *  A driver for Nokia Connectivity Card DTL-1 devices
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
57MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
58MODULE_DESCRIPTION("Bluetooth driver for Nokia Connectivity Card DTL-1");
59MODULE_LICENSE("GPL");
60
61
62
63/* ======================== Local structures ======================== */
64
65
66typedef struct dtl1_info_t {
67	struct pcmcia_device *p_dev;
68
69	struct hci_dev *hdev;
70
71	spinlock_t lock;		/* For serializing operations */
72
73	unsigned long flowmask;		/* HCI flow mask */
74	int ri_latch;
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} dtl1_info_t;
83
84
85static int dtl1_config(struct pcmcia_device *link);
86
87
88/* Transmit states  */
89#define XMIT_SENDING  1
90#define XMIT_WAKEUP   2
91#define XMIT_WAITING  8
92
93/* Receiver States */
94#define RECV_WAIT_NSH   0
95#define RECV_WAIT_DATA  1
96
97
98typedef struct {
99	u8 type;
100	u8 zero;
101	u16 len;
102} __packed nsh_t;	/* Nokia Specific Header */
103
104#define NSHL  4				/* Nokia Specific Header Length */
105
106
107
108/* ======================== Interrupt handling ======================== */
109
110
111static int dtl1_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
112{
113	int actual = 0;
114
115	/* Tx FIFO should be empty */
116	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
117		return 0;
118
119	/* Fill FIFO with current frame */
120	while ((fifo_size-- > 0) && (actual < len)) {
121		/* Transmit next byte */
122		outb(buf[actual], iobase + UART_TX);
123		actual++;
124	}
125
126	return actual;
127}
128
129
130static void dtl1_write_wakeup(dtl1_info_t *info)
131{
132	if (!info) {
133		BT_ERR("Unknown device");
134		return;
135	}
136
137	if (test_bit(XMIT_WAITING, &(info->tx_state))) {
138		set_bit(XMIT_WAKEUP, &(info->tx_state));
139		return;
140	}
141
142	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
143		set_bit(XMIT_WAKEUP, &(info->tx_state));
144		return;
145	}
146
147	do {
148		register unsigned int iobase = info->p_dev->resource[0]->start;
149		register struct sk_buff *skb;
150		register int len;
151
152		clear_bit(XMIT_WAKEUP, &(info->tx_state));
153
154		if (!pcmcia_dev_present(info->p_dev))
155			return;
156
157		if (!(skb = skb_dequeue(&(info->txq))))
158			break;
159
160		/* Send frame */
161		len = dtl1_write(iobase, 32, skb->data, skb->len);
162
163		if (len == skb->len) {
164			set_bit(XMIT_WAITING, &(info->tx_state));
165			kfree_skb(skb);
166		} else {
167			skb_pull(skb, len);
168			skb_queue_head(&(info->txq), skb);
169		}
170
171		info->hdev->stat.byte_tx += len;
172
173	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
174
175	clear_bit(XMIT_SENDING, &(info->tx_state));
176}
177
178
179static void dtl1_control(dtl1_info_t *info, struct sk_buff *skb)
180{
181	u8 flowmask = *(u8 *)skb->data;
182	int i;
183
184	printk(KERN_INFO "Bluetooth: Nokia control data =");
185	for (i = 0; i < skb->len; i++) {
186		printk(" %02x", skb->data[i]);
187	}
188	printk("\n");
189
190	/* transition to active state */
191	if (((info->flowmask & 0x07) == 0) && ((flowmask & 0x07) != 0)) {
192		clear_bit(XMIT_WAITING, &(info->tx_state));
193		dtl1_write_wakeup(info);
194	}
195
196	info->flowmask = flowmask;
197
198	kfree_skb(skb);
199}
200
201
202static void dtl1_receive(dtl1_info_t *info)
203{
204	unsigned int iobase;
205	nsh_t *nsh;
206	int boguscount = 0;
207
208	if (!info) {
209		BT_ERR("Unknown device");
210		return;
211	}
212
213	iobase = info->p_dev->resource[0]->start;
214
215	do {
216		info->hdev->stat.byte_rx++;
217
218		/* Allocate packet */
219		if (info->rx_skb == NULL)
220			if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
221				BT_ERR("Can't allocate mem for new packet");
222				info->rx_state = RECV_WAIT_NSH;
223				info->rx_count = NSHL;
224				return;
225			}
226
227		*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
228		nsh = (nsh_t *)info->rx_skb->data;
229
230		info->rx_count--;
231
232		if (info->rx_count == 0) {
233
234			switch (info->rx_state) {
235			case RECV_WAIT_NSH:
236				info->rx_state = RECV_WAIT_DATA;
237				info->rx_count = nsh->len + (nsh->len & 0x0001);
238				break;
239			case RECV_WAIT_DATA:
240				bt_cb(info->rx_skb)->pkt_type = nsh->type;
241
242				/* remove PAD byte if it exists */
243				if (nsh->len & 0x0001) {
244					info->rx_skb->tail--;
245					info->rx_skb->len--;
246				}
247
248				/* remove NSH */
249				skb_pull(info->rx_skb, NSHL);
250
251				switch (bt_cb(info->rx_skb)->pkt_type) {
252				case 0x80:
253					/* control data for the Nokia Card */
254					dtl1_control(info, info->rx_skb);
255					break;
256				case 0x82:
257				case 0x83:
258				case 0x84:
259					/* send frame to the HCI layer */
260					info->rx_skb->dev = (void *) info->hdev;
261					bt_cb(info->rx_skb)->pkt_type &= 0x0f;
262					hci_recv_frame(info->rx_skb);
263					break;
264				default:
265					/* unknown packet */
266					BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
267					kfree_skb(info->rx_skb);
268					break;
269				}
270
271				info->rx_state = RECV_WAIT_NSH;
272				info->rx_count = NSHL;
273				info->rx_skb = NULL;
274				break;
275			}
276
277		}
278
279		/* Make sure we don't stay here too long */
280		if (boguscount++ > 32)
281			break;
282
283	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
284}
285
286
287static irqreturn_t dtl1_interrupt(int irq, void *dev_inst)
288{
289	dtl1_info_t *info = dev_inst;
290	unsigned int iobase;
291	unsigned char msr;
292	int boguscount = 0;
293	int iir, lsr;
294	irqreturn_t r = IRQ_NONE;
295
296	if (!info || !info->hdev)
297		/* our irq handler is shared */
298		return IRQ_NONE;
299
300	iobase = info->p_dev->resource[0]->start;
301
302	spin_lock(&(info->lock));
303
304	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
305	while (iir) {
306
307		r = IRQ_HANDLED;
308		/* Clear interrupt */
309		lsr = inb(iobase + UART_LSR);
310
311		switch (iir) {
312		case UART_IIR_RLSI:
313			BT_ERR("RLSI");
314			break;
315		case UART_IIR_RDI:
316			/* Receive interrupt */
317			dtl1_receive(info);
318			break;
319		case UART_IIR_THRI:
320			if (lsr & UART_LSR_THRE) {
321				/* Transmitter ready for data */
322				dtl1_write_wakeup(info);
323			}
324			break;
325		default:
326			BT_ERR("Unhandled IIR=%#x", iir);
327			break;
328		}
329
330		/* Make sure we don't stay here too long */
331		if (boguscount++ > 100)
332			break;
333
334		iir = inb(iobase + UART_IIR) & UART_IIR_ID;
335
336	}
337
338	msr = inb(iobase + UART_MSR);
339
340	if (info->ri_latch ^ (msr & UART_MSR_RI)) {
341		info->ri_latch = msr & UART_MSR_RI;
342		clear_bit(XMIT_WAITING, &(info->tx_state));
343		dtl1_write_wakeup(info);
344		r = IRQ_HANDLED;
345	}
346
347	spin_unlock(&(info->lock));
348
349	return r;
350}
351
352
353
354/* ======================== HCI interface ======================== */
355
356
357static int dtl1_hci_open(struct hci_dev *hdev)
358{
359	set_bit(HCI_RUNNING, &(hdev->flags));
360
361	return 0;
362}
363
364
365static int dtl1_hci_flush(struct hci_dev *hdev)
366{
367	dtl1_info_t *info = (dtl1_info_t *)(hdev->driver_data);
368
369	/* Drop TX queue */
370	skb_queue_purge(&(info->txq));
371
372	return 0;
373}
374
375
376static int dtl1_hci_close(struct hci_dev *hdev)
377{
378	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
379		return 0;
380
381	dtl1_hci_flush(hdev);
382
383	return 0;
384}
385
386
387static int dtl1_hci_send_frame(struct sk_buff *skb)
388{
389	dtl1_info_t *info;
390	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
391	struct sk_buff *s;
392	nsh_t nsh;
393
394	if (!hdev) {
395		BT_ERR("Frame for unknown HCI device (hdev=NULL)");
396		return -ENODEV;
397	}
398
399	info = (dtl1_info_t *)(hdev->driver_data);
400
401	switch (bt_cb(skb)->pkt_type) {
402	case HCI_COMMAND_PKT:
403		hdev->stat.cmd_tx++;
404		nsh.type = 0x81;
405		break;
406	case HCI_ACLDATA_PKT:
407		hdev->stat.acl_tx++;
408		nsh.type = 0x82;
409		break;
410	case HCI_SCODATA_PKT:
411		hdev->stat.sco_tx++;
412		nsh.type = 0x83;
413		break;
414	default:
415		return -EILSEQ;
416	};
417
418	nsh.zero = 0;
419	nsh.len = skb->len;
420
421	s = bt_skb_alloc(NSHL + skb->len + 1, GFP_ATOMIC);
422	if (!s)
423		return -ENOMEM;
424
425	skb_reserve(s, NSHL);
426	skb_copy_from_linear_data(skb, skb_put(s, skb->len), skb->len);
427	if (skb->len & 0x0001)
428		*skb_put(s, 1) = 0;	/* PAD */
429
430	/* Prepend skb with Nokia frame header and queue */
431	memcpy(skb_push(s, NSHL), &nsh, NSHL);
432	skb_queue_tail(&(info->txq), s);
433
434	dtl1_write_wakeup(info);
435
436	kfree_skb(skb);
437
438	return 0;
439}
440
441
442static void dtl1_hci_destruct(struct hci_dev *hdev)
443{
444}
445
446
447static int dtl1_hci_ioctl(struct hci_dev *hdev, unsigned int cmd,  unsigned long arg)
448{
449	return -ENOIOCTLCMD;
450}
451
452
453
454/* ======================== Card services HCI interaction ======================== */
455
456
457static int dtl1_open(dtl1_info_t *info)
458{
459	unsigned long flags;
460	unsigned int iobase = info->p_dev->resource[0]->start;
461	struct hci_dev *hdev;
462
463	spin_lock_init(&(info->lock));
464
465	skb_queue_head_init(&(info->txq));
466
467	info->rx_state = RECV_WAIT_NSH;
468	info->rx_count = NSHL;
469	info->rx_skb = NULL;
470
471	set_bit(XMIT_WAITING, &(info->tx_state));
472
473	/* Initialize HCI device */
474	hdev = hci_alloc_dev();
475	if (!hdev) {
476		BT_ERR("Can't allocate HCI device");
477		return -ENOMEM;
478	}
479
480	info->hdev = hdev;
481
482	hdev->bus = HCI_PCCARD;
483	hdev->driver_data = info;
484	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
485
486	hdev->open     = dtl1_hci_open;
487	hdev->close    = dtl1_hci_close;
488	hdev->flush    = dtl1_hci_flush;
489	hdev->send     = dtl1_hci_send_frame;
490	hdev->destruct = dtl1_hci_destruct;
491	hdev->ioctl    = dtl1_hci_ioctl;
492
493	hdev->owner = THIS_MODULE;
494
495	spin_lock_irqsave(&(info->lock), flags);
496
497	/* Reset UART */
498	outb(0, iobase + UART_MCR);
499
500	/* Turn off interrupts */
501	outb(0, iobase + UART_IER);
502
503	/* Initialize UART */
504	outb(UART_LCR_WLEN8, iobase + UART_LCR);	/* Reset DLAB */
505	outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
506
507	info->ri_latch = inb(info->p_dev->resource[0]->start + UART_MSR)
508				& UART_MSR_RI;
509
510	/* Turn on interrupts */
511	outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
512
513	spin_unlock_irqrestore(&(info->lock), flags);
514
515	/* Timeout before it is safe to send the first HCI packet */
516	msleep(2000);
517
518	/* Register HCI device */
519	if (hci_register_dev(hdev) < 0) {
520		BT_ERR("Can't register HCI device");
521		info->hdev = NULL;
522		hci_free_dev(hdev);
523		return -ENODEV;
524	}
525
526	return 0;
527}
528
529
530static int dtl1_close(dtl1_info_t *info)
531{
532	unsigned long flags;
533	unsigned int iobase = info->p_dev->resource[0]->start;
534	struct hci_dev *hdev = info->hdev;
535
536	if (!hdev)
537		return -ENODEV;
538
539	dtl1_hci_close(hdev);
540
541	spin_lock_irqsave(&(info->lock), flags);
542
543	/* Reset UART */
544	outb(0, iobase + UART_MCR);
545
546	/* Turn off interrupts */
547	outb(0, iobase + UART_IER);
548
549	spin_unlock_irqrestore(&(info->lock), flags);
550
551	hci_unregister_dev(hdev);
552	hci_free_dev(hdev);
553
554	return 0;
555}
556
557static int dtl1_probe(struct pcmcia_device *link)
558{
559	dtl1_info_t *info;
560
561	/* Create new info device */
562	info = kzalloc(sizeof(*info), GFP_KERNEL);
563	if (!info)
564		return -ENOMEM;
565
566	info->p_dev = link;
567	link->priv = info;
568
569	link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
570
571	return dtl1_config(link);
572}
573
574
575static void dtl1_detach(struct pcmcia_device *link)
576{
577	dtl1_info_t *info = link->priv;
578
579	dtl1_close(info);
580	pcmcia_disable_device(link);
581	kfree(info);
582}
583
584static int dtl1_confcheck(struct pcmcia_device *p_dev, void *priv_data)
585{
586	if ((p_dev->resource[1]->end) || (p_dev->resource[1]->end < 8))
587		return -ENODEV;
588
589	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
590	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
591
592	return pcmcia_request_io(p_dev);
593}
594
595static int dtl1_config(struct pcmcia_device *link)
596{
597	dtl1_info_t *info = link->priv;
598	int i;
599
600	/* Look for a generic full-sized window */
601	link->resource[0]->end = 8;
602	if (pcmcia_loop_config(link, dtl1_confcheck, NULL) < 0)
603		goto failed;
604
605	i = pcmcia_request_irq(link, dtl1_interrupt);
606	if (i != 0)
607		goto failed;
608
609	i = pcmcia_enable_device(link);
610	if (i != 0)
611		goto failed;
612
613	if (dtl1_open(info) != 0)
614		goto failed;
615
616	return 0;
617
618failed:
619	dtl1_detach(link);
620	return -ENODEV;
621}
622
623static const struct pcmcia_device_id dtl1_ids[] = {
624	PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-1", 0xe1bfdd64, 0xe168480d),
625	PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-4", 0xe1bfdd64, 0x9102bc82),
626	PCMCIA_DEVICE_PROD_ID12("Socket", "CF", 0xb38bcc2e, 0x44ebf863),
627	PCMCIA_DEVICE_PROD_ID12("Socket", "CF+ Personal Network Card", 0xb38bcc2e, 0xe732bae3),
628	PCMCIA_DEVICE_NULL
629};
630MODULE_DEVICE_TABLE(pcmcia, dtl1_ids);
631
632static struct pcmcia_driver dtl1_driver = {
633	.owner		= THIS_MODULE,
634	.name		= "dtl1_cs",
635	.probe		= dtl1_probe,
636	.remove		= dtl1_detach,
637	.id_table	= dtl1_ids,
638};
639
640static int __init init_dtl1_cs(void)
641{
642	return pcmcia_register_driver(&dtl1_driver);
643}
644
645
646static void __exit exit_dtl1_cs(void)
647{
648	pcmcia_unregister_driver(&dtl1_driver);
649}
650
651module_init(init_dtl1_cs);
652module_exit(exit_dtl1_cs);
653