/* * *  Driver for the 3Com Bluetooth PCMCIA card * *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org> *                           Jose Orlando Pereira <jop@di.uminho.pt> * * *  This program is free software; you can redistribute it and/or modify *  it under the terms of the GNU General Public License version 2 as *  published by the Free Software Foundation; * *  Software distributed under the License is distributed on an "AS *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or *  implied. See the License for the specific language governing *  rights and limitations under the License. * *  The initial developer of the original code is David A. Hinds *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved. * */#include <linux/config.h>#include <linux/module.h>#define __KERNEL_SYSCALLS__#include <linux/kernel.h>#include <linux/kmod.h>#include <linux/init.h>#include <linux/slab.h>#include <linux/types.h>#include <linux/sched.h>#include <linux/delay.h>#include <linux/timer.h>#include <linux/errno.h>#include <linux/unistd.h>#include <linux/ptrace.h>#include <linux/ioport.h>#include <linux/spinlock.h>#include <linux/skbuff.h>#include <linux/string.h>#include <linux/serial.h>#include <linux/serial_reg.h>#include <asm/system.h>#include <asm/bitops.h>#include <asm/io.h>#include <pcmcia/version.h>#include <pcmcia/cs_types.h>#include <pcmcia/cs.h>#include <pcmcia/cistpl.h>#include <pcmcia/ciscode.h>#include <pcmcia/ds.h>#include <pcmcia/cisreg.h>#include <net/bluetooth/bluetooth.h>#include <net/bluetooth/hci_core.h>/* ======================== Module parameters ======================== *//* Bit map of interrupts to choose from */static u_int irq_mask = 0xffff;static int irq_list[4] = { -1 };MODULE_PARM(irq_mask, "i");MODULE_PARM(irq_list, "1-4i");MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");MODULE_DESCRIPTION("BlueZ driver for the 3Com Bluetooth PCMCIA card");MODULE_LICENSE("GPL");/* ======================== Local structures ======================== */typedef struct bt3c_info_t {	dev_link_t link;	dev_node_t node;	struct hci_dev hdev;	spinlock_t lock;		/* For serializing operations */	struct sk_buff_head txq;	unsigned long tx_state;	unsigned long rx_state;	unsigned long rx_count;	struct sk_buff *rx_skb;} bt3c_info_t;void bt3c_config(dev_link_t *link);void bt3c_release(u_long arg);int bt3c_event(event_t event, int priority, event_callback_args_t *args);static dev_info_t dev_info = "bt3c_cs";dev_link_t *bt3c_attach(void);void bt3c_detach(dev_link_t *);static dev_link_t *dev_list = NULL;/* Transmit states  */#define XMIT_SENDING  1#define XMIT_WAKEUP   2#define XMIT_WAITING  8/* Receiver states */#define RECV_WAIT_PACKET_TYPE   0#define RECV_WAIT_EVENT_HEADER  1#define RECV_WAIT_ACL_HEADER    2#define RECV_WAIT_SCO_HEADER    3#define RECV_WAIT_DATA          4/* ======================== Special I/O functions ======================== */#define DATA_L   0#define DATA_H   1#define ADDR_L   2#define ADDR_H   3#define CONTROL  4inline void bt3c_address(unsigned int iobase, unsigned short addr){	outb(addr & 0xff, iobase + ADDR_L);	outb((addr >> 8) & 0xff, iobase + ADDR_H);}inline void bt3c_put(unsigned int iobase, unsigned short value){	outb(value & 0xff, iobase + DATA_L);	outb((value >> 8) & 0xff, iobase + DATA_H);}inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value){	bt3c_address(iobase, addr);	bt3c_put(iobase, value);}inline unsigned short bt3c_get(unsigned int iobase){	unsigned short value = inb(iobase + DATA_L);	value |= inb(iobase + DATA_H) << 8;	return value;}inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr){	bt3c_address(iobase, addr);	return bt3c_get(iobase);}/* ======================== Interrupt handling ======================== */static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len){	int actual = 0;	bt3c_address(iobase, 0x7080);	/* Fill FIFO with current frame */	while (actual < len) {		/* Transmit next byte */		bt3c_put(iobase, buf[actual]);		actual++;	}	bt3c_io_write(iobase, 0x7005, actual);	return actual;}static void bt3c_write_wakeup(bt3c_info_t *info, int from){	unsigned long flags;	if (!info) {		printk(KERN_WARNING "bt3c_cs: Call of write_wakeup for unknown device.\n");		return;	}	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))		return;	spin_lock_irqsave(&(info->lock), flags);	do {		register unsigned int iobase = info->link.io.BasePort1;		register struct sk_buff *skb;		register int len;		if (!(info->link.state & DEV_PRESENT))			break;		if (!(skb = skb_dequeue(&(info->txq)))) {			clear_bit(XMIT_SENDING, &(info->tx_state));			break;		}		/* Send frame */		len = bt3c_write(iobase, 256, skb->data, skb->len);		if (len != skb->len) {			printk(KERN_WARNING "bt3c_cs: very strange\n");		}		kfree_skb(skb);		info->hdev.stat.byte_tx += len;	} while (0);	spin_unlock_irqrestore(&(info->lock), flags);}static void bt3c_receive(bt3c_info_t *info){	unsigned int iobase;	int size = 0, avail;	if (!info) {		printk(KERN_WARNING "bt3c_cs: Call of receive for unknown device.\n");		return;	}	iobase = info->link.io.BasePort1;	avail = bt3c_read(iobase, 0x7006);	//printk("bt3c_cs: receiving %d bytes\n", avail);	bt3c_address(iobase, 0x7480);	while (size < avail) {		size++;		info->hdev.stat.byte_rx++;		/* Allocate packet */		if (info->rx_skb == NULL) {			info->rx_state = RECV_WAIT_PACKET_TYPE;			info->rx_count = 0;			if (!(info->rx_skb = bluez_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {				printk(KERN_WARNING "bt3c_cs: Can't allocate mem for new packet.\n");				return;			}		}		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {			info->rx_skb->dev = (void *)&(info->hdev);			info->rx_skb->pkt_type = inb(iobase + DATA_L);			inb(iobase + DATA_H);			//printk("bt3c: PACKET_TYPE=%02x\n", info->rx_skb->pkt_type);			switch (info->rx_skb->pkt_type) {			case HCI_EVENT_PKT:				info->rx_state = RECV_WAIT_EVENT_HEADER;				info->rx_count = HCI_EVENT_HDR_SIZE;				break;			case HCI_ACLDATA_PKT:				info->rx_state = RECV_WAIT_ACL_HEADER;				info->rx_count = HCI_ACL_HDR_SIZE;				break;			case HCI_SCODATA_PKT:				info->rx_state = RECV_WAIT_SCO_HEADER;				info->rx_count = HCI_SCO_HDR_SIZE;				break;			default:				/* Unknown packet */				printk(KERN_WARNING "bt3c_cs: Unknown HCI packet with type 0x%02x received.\n", info->rx_skb->pkt_type);				info->hdev.stat.err_rx++;				clear_bit(HCI_RUNNING, &(info->hdev.flags));				kfree_skb(info->rx_skb);				info->rx_skb = NULL;				break;			}		} else {			__u8 x = inb(iobase + DATA_L);			*skb_put(info->rx_skb, 1) = x;			inb(iobase + DATA_H);			info->rx_count--;			if (info->rx_count == 0) {				int dlen;				hci_event_hdr *eh;				hci_acl_hdr *ah;				hci_sco_hdr *sh;				switch (info->rx_state) {				case RECV_WAIT_EVENT_HEADER:					eh = (hci_event_hdr *)(info->rx_skb->data);					info->rx_state = RECV_WAIT_DATA;					info->rx_count = eh->plen;					break;				case RECV_WAIT_ACL_HEADER:					ah = (hci_acl_hdr *)(info->rx_skb->data);					dlen = __le16_to_cpu(ah->dlen);					info->rx_state = RECV_WAIT_DATA;					info->rx_count = dlen;					break;				case RECV_WAIT_SCO_HEADER:					sh = (hci_sco_hdr *)(info->rx_skb->data);					info->rx_state = RECV_WAIT_DATA;					info->rx_count = sh->dlen;					break;				case RECV_WAIT_DATA:					hci_recv_frame(info->rx_skb);					info->rx_skb = NULL;					break;				}			}		}	}	bt3c_io_write(iobase, 0x7006, 0x0000);}void bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs){	bt3c_info_t *info = dev_inst;	unsigned int iobase;	int iir;	if (!info) {		printk(KERN_WARNING "bt3c_cs: Call of irq %d for unknown device.\n", irq);		return;	}	iobase = info->link.io.BasePort1;	spin_lock(&(info->lock));	iir = inb(iobase + CONTROL);	if (iir & 0x80) {		int stat = bt3c_read(iobase, 0x7001);		if ((stat & 0xff) == 0x7f) {			printk(KERN_WARNING "bt3c_cs: STRANGE stat=%04x\n", stat);		} else if ((stat & 0xff) != 0xff) {			if (stat & 0x0020) {				int stat = bt3c_read(iobase, 0x7002) & 0x10;				printk(KERN_WARNING "bt3c_cs: antena %s\n", stat ? "OUT" : "IN");			}			if (stat & 0x0001)				bt3c_receive(info);			if (stat & 0x0002) {				//printk("bt3c_cs: ACK %04x\n", stat);				clear_bit(XMIT_SENDING, &(info->tx_state));				bt3c_write_wakeup(info, 1);			}			bt3c_io_write(iobase, 0x7001, 0x0000);			outb(iir, iobase + CONTROL);		}	}	spin_unlock(&(info->lock));}/* ======================== HCI interface ======================== */static int bt3c_hci_flush(struct hci_dev *hdev){	bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);	/* Drop TX queue */	skb_queue_purge(&(info->txq));	return 0;}static int bt3c_hci_open(struct hci_dev *hdev){	set_bit(HCI_RUNNING, &(hdev->flags));	return 0;}static int bt3c_hci_close(struct hci_dev *hdev){	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))		return 0;	bt3c_hci_flush(hdev);	return 0;}static int bt3c_hci_send_frame(struct sk_buff *skb){	bt3c_info_t *info;	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);	if (!hdev) {		printk(KERN_WARNING "bt3c_cs: Frame for unknown HCI device (hdev=NULL).");		return -ENODEV;	}	info = (bt3c_info_t *) (hdev->driver_data);	switch (skb->pkt_type) {	case HCI_COMMAND_PKT:		hdev->stat.cmd_tx++;		break;	case HCI_ACLDATA_PKT:		hdev->stat.acl_tx++;		break;	case HCI_SCODATA_PKT:		hdev->stat.sco_tx++;		break;	};	/* Prepend skb with frame type */	memcpy(skb_push(skb, 1), &(skb->pkt_type), 1);	skb_queue_tail(&(info->txq), skb);	bt3c_write_wakeup(info, 0);	return 0;}