/* * *  A driver for Nokia Connectivity Card DTL-1 devices * *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org> * * *  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>#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 Nokia Connectivity Card DTL-1");MODULE_LICENSE("GPL");/* ======================== Local structures ======================== */typedef struct dtl1_info_t {	dev_link_t link;	dev_node_t node;	struct hci_dev hdev;	spinlock_t lock;		/* For serializing operations */	unsigned long flowmask;		/* HCI flow mask */	int ri_latch;	struct sk_buff_head txq;	unsigned long tx_state;	unsigned long rx_state;	unsigned long rx_count;	struct sk_buff *rx_skb;} dtl1_info_t;void dtl1_config(dev_link_t *link);void dtl1_release(u_long arg);int dtl1_event(event_t event, int priority, event_callback_args_t *args);static dev_info_t dev_info = "dtl1_cs";dev_link_t *dtl1_attach(void);void dtl1_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_NSH   0#define RECV_WAIT_DATA  1typedef struct {	u8 type;	u8 zero;	u16 len;} __attribute__ ((packed)) nsh_t;	/* Nokia Specific Header */#define NSHL  4				/* Nokia Specific Header Length *//* ======================== Interrupt handling ======================== */static int dtl1_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 dtl1_write_wakeup(dtl1_info_t *info){	if (!info) {		printk(KERN_WARNING "dtl1_cs: Call of write_wakeup for unknown device.\n");		return;	}	if (test_bit(XMIT_WAITING, &(info->tx_state))) {		set_bit(XMIT_WAKEUP, &(info->tx_state));		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 = dtl1_write(iobase, 32, skb->data, skb->len);		if (len == skb->len) {			set_bit(XMIT_WAITING, &(info->tx_state));			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 dtl1_control(dtl1_info_t *info, struct sk_buff *skb){	u8 flowmask = *(u8 *)skb->data;	int i;	printk(KERN_INFO "dtl1_cs: Nokia control data = ");	for (i = 0; i < skb->len; i++) {		printk("%02x ", skb->data[i]);	}	printk("\n");	/* transition to active state */	if (((info->flowmask & 0x07) == 0) && ((flowmask & 0x07) != 0)) {		clear_bit(XMIT_WAITING, &(info->tx_state));		dtl1_write_wakeup(info);	}	info->flowmask = flowmask;	kfree_skb(skb);}static void dtl1_receive(dtl1_info_t *info){	unsigned int iobase;	nsh_t *nsh;	int boguscount = 0;	if (!info) {		printk(KERN_WARNING "dtl1_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)			if (!(info->rx_skb = bluez_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {				printk(KERN_WARNING "dtl1_cs: Can't allocate mem for new packet.\n");				info->rx_state = RECV_WAIT_NSH;				info->rx_count = NSHL;				return;			}		*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);		nsh = (nsh_t *)info->rx_skb->data;		info->rx_count--;		if (info->rx_count == 0) {			switch (info->rx_state) {			case RECV_WAIT_NSH:				info->rx_state = RECV_WAIT_DATA;				info->rx_count = nsh->len + (nsh->len & 0x0001);				break;			case RECV_WAIT_DATA:				info->rx_skb->pkt_type = nsh->type;				/* remove PAD byte if it exists */				if (nsh->len & 0x0001) {					info->rx_skb->tail--;					info->rx_skb->len--;				}				/* remove NSH */				skb_pull(info->rx_skb, NSHL);				switch (info->rx_skb->pkt_type) {				case 0x80:					/* control data for the Nokia Card */					dtl1_control(info, info->rx_skb);					break;				case 0x82:				case 0x83:				case 0x84:					/* send frame to the HCI layer */					info->rx_skb->dev = (void *)&(info->hdev);					info->rx_skb->pkt_type &= 0x0f;					hci_recv_frame(info->rx_skb);					break;				default:					/* unknown packet */					printk(KERN_WARNING "dtl1_cs: Unknown HCI packet with type 0x%02x received.\n", info->rx_skb->pkt_type);					kfree_skb(info->rx_skb);					break;				}				info->rx_state = RECV_WAIT_NSH;				info->rx_count = NSHL;				info->rx_skb = NULL;				break;			}		}		/* Make sure we don't stay here to long */		if (boguscount++ > 32)			break;	} while (inb(iobase + UART_LSR) & UART_LSR_DR);}void dtl1_interrupt(int irq, void *dev_inst, struct pt_regs *regs){	dtl1_info_t *info = dev_inst;	unsigned int iobase;	unsigned char msr;	int boguscount = 0;	int iir, lsr;	if (!info) {		printk(KERN_WARNING "dtl1_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 "dtl1_cs: RLSI\n");			break;		case UART_IIR_RDI:			/* Receive interrupt */			dtl1_receive(info);			break;		case UART_IIR_THRI:			if (lsr & UART_LSR_THRE) {				/* Transmitter ready for data */				dtl1_write_wakeup(info);			}			break;		default:			printk(KERN_NOTICE "dtl1_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;	}	msr = inb(iobase + UART_MSR);	if (info->ri_latch ^ (msr & UART_MSR_RI)) {		info->ri_latch = msr & UART_MSR_RI;		clear_bit(XMIT_WAITING, &(info->tx_state));		dtl1_write_wakeup(info);	}	spin_unlock(&(info->lock));}/* ======================== HCI interface ======================== */static int dtl1_hci_open(struct hci_dev *hdev){	set_bit(HCI_RUNNING, &(hdev->flags));	return 0;}static int dtl1_hci_flush(struct hci_dev *hdev){	dtl1_info_t *info = (dtl1_info_t *)(hdev->driver_data);	/* Drop TX queue */	skb_queue_purge(&(info->txq));	return 0;}static int dtl1_hci_close(struct hci_dev *hdev){	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))		return 0;	dtl1_hci_flush(hdev);	return 0;}static int dtl1_hci_send_frame(struct sk_buff *skb){	dtl1_info_t *info;	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);	struct sk_buff *s;	nsh_t nsh;	if (!hdev) {		printk(KERN_WARNING "dtl1_cs: Frame for unknown HCI device (hdev=NULL).");		return -ENODEV;	}	info = (dtl1_info_t *)(hdev->driver_data);	switch (skb->pkt_type) {	case HCI_COMMAND_PKT:		hdev->stat.cmd_tx++;		nsh.type = 0x81;		break;	case HCI_ACLDATA_PKT:		hdev->stat.acl_tx++;		nsh.type = 0x82;		break;	case HCI_SCODATA_PKT:		hdev->stat.sco_tx++;		nsh.type = 0x83;		break;