Kernel

Kernel Git Source Tree

Root/drivers/bluetooth/bluecard_cs.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/bluetooth/bluecard_cs.c

interactive