/* * *  Driver for Bluetooth PCMCIA cards with HCI UART interface * * */#include <linux/config.h>#include <linux/module.h>#include <linux/kernel.h>#include <linux/init.h>#include <linux/slab.h>#include <linux/types.h>#include <linux/sched.h>#include <linux/timer.h>#include <linux/errno.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>");MODULE_DESCRIPTION("BlueZ driver for Bluetooth PCMCIA cards with HCI UART interface");MODULE_LICENSE("GPL");/* ======================== Local structures ======================== */typedef struct btuart_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;} btuart_info_t;void btuart_config(dev_link_t *link);void btuart_release(u_long arg);int btuart_event(event_t event, int priority, event_callback_args_t *args);static dev_info_t dev_info = "btuart_cs";dev_link_t *btuart_attach(void);void btuart_detach(dev_link_t *);static dev_link_t *dev_list = NULL;/* Maximum baud rate */#define SPEED_MAX  115200/* Default baud rate: 57600, 115200, 230400 or 460800 */#define DEFAULT_BAUD_RATE  115200/* 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/* ======================== Interrupt handling ======================== */static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len){	int actual = 0;	/* Tx FIFO should be empty */	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))		return 0;	/* Fill FIFO with current frame */	while ((fifo_size-- > 0) && (actual < len)) {		/* Transmit next byte */		outb(buf[actual], iobase + UART_TX);		actual++;	}	return actual;}static void btuart_write_wakeup(btuart_info_t *info){	if (!info) {		printk(KERN_WARNING "btuart_cs: Call of write_wakeup for unknown device.\n");		return;	}	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {		set_bit(XMIT_WAKEUP, &(info->tx_state));		return;	}	do {		register unsigned int iobase = info->link.io.BasePort1;		register struct sk_buff *skb;		register int len;		clear_bit(XMIT_WAKEUP, &(info->tx_state));		if (!(info->link.state & DEV_PRESENT))			return;		if (!(skb = skb_dequeue(&(info->txq))))			break;		/* Send frame */		len = btuart_write(iobase, 16, skb->data, skb->len);		set_bit(XMIT_WAKEUP, &(info->tx_state));		if (len == skb->len) {			kfree_skb(skb);		} else {			skb_pull(skb, len);			skb_queue_head(&(info->txq), skb);		}		info->hdev.stat.byte_tx += len;	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));	clear_bit(XMIT_SENDING, &(info->tx_state));}static void btuart_receive(btuart_info_t *info){	unsigned int iobase;	int boguscount = 0;	if (!info) {		printk(KERN_WARNING "btuart_cs: Call of receive for unknown device.\n");		return;	}	iobase = info->link.io.BasePort1;	do {		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 "btuart_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 + UART_RX);			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 "btuart_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 {			*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);			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;				}			}		}		/* Make sure we don't stay here to long */		if (boguscount++ > 16)			break;	} while (inb(iobase + UART_LSR) & UART_LSR_DR);}void btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs){	btuart_info_t *info = dev_inst;	unsigned int iobase;	int boguscount = 0;	int iir, lsr;	if (!info) {		printk(KERN_WARNING "btuart_cs: Call of irq %d for unknown device.\n", irq);		return;	}	iobase = info->link.io.BasePort1;	spin_lock(&(info->lock));	iir = inb(iobase + UART_IIR) & UART_IIR_ID;	while (iir) {		/* Clear interrupt */		lsr = inb(iobase + UART_LSR);		switch (iir) {		case UART_IIR_RLSI:			printk(KERN_NOTICE "btuart_cs: RLSI\n");			break;		case UART_IIR_RDI:			/* Receive interrupt */			btuart_receive(info);			break;		case UART_IIR_THRI:			if (lsr & UART_LSR_THRE) {				/* Transmitter ready for data */				btuart_write_wakeup(info);			}			break;		default:			printk(KERN_NOTICE "btuart_cs: Unhandled IIR=%#x\n", iir);			break;		}		/* Make sure we don't stay here to long */		if (boguscount++ > 100)			break;		iir = inb(iobase + UART_IIR) & UART_IIR_ID;	}	spin_unlock(&(info->lock));}static void btuart_change_speed(btuart_info_t *info, unsigned int speed){	unsigned long flags;	unsigned int iobase;	int fcr;		/* FIFO control reg */	int lcr;		/* Line control reg */	int divisor;	if (!info) {		printk(KERN_WARNING "btuart_cs: Call of change speed for unknown device.\n");		return;	}	iobase = info->link.io.BasePort1;	spin_lock_irqsave(&(info->lock), flags);	/* Turn off interrupts */	outb(0, iobase + UART_IER);	divisor = SPEED_MAX / speed;	fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;	/* 	 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and	 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget	 * about this timeout since it will always be fast enough. 	 */	if (speed < 38400)		fcr |= UART_FCR_TRIGGER_1;	else		fcr |= UART_FCR_TRIGGER_14;	/* Bluetooth cards use 8N1 */	lcr = UART_LCR_WLEN8;	outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);	/* Set DLAB */	outb(divisor & 0xff, iobase + UART_DLL);	/* Set speed */	outb(divisor >> 8, iobase + UART_DLM);	outb(lcr, iobase + UART_LCR);	/* Set 8N1  */	outb(fcr, iobase + UART_FCR);	/* Enable FIFO's */	/* Turn on interrups */	outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);	spin_unlock_irqrestore(&(info->lock), flags);}/* ======================== HCI interface ======================== */static int btuart_hci_flush(struct hci_dev *hdev){	btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);	/* Drop TX queue */	skb_queue_purge(&(info->txq));	return 0;}static int btuart_hci_open(struct hci_dev *hdev){	set_bit(HCI_RUNNING, &(hdev->flags));	return 0;}static int btuart_hci_close(struct hci_dev *hdev){	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))		return 0;	btuart_hci_flush(hdev);	return 0;}static int btuart_hci_send_frame(struct sk_buff *skb){	btuart_info_t *info;	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);	if (!hdev) {		printk(KERN_WARNING "btuart_cs: Frame for unknown HCI device (hdev=NULL).");		return -ENODEV;	}	info = (btuart_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++;