[deliverable/linux.git] / drivers / staging / i4l / act2000 / act2000_isa.c

/* $Id: act2000_isa.c,v 1.11.6.3 2001/09/23 22:24:32 kai Exp $
 *
 * ISDN lowlevel-module for the IBM ISDN-S0 Active 2000 (ISA-Version).
 *
 * Author       Fritz Elfert
 * Copyright    by Fritz Elfert      <fritz@isdn4linux.de>
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * Thanks to Friedemann Baitinger and IBM Germany
 *
 */

#include "act2000.h"
#include "act2000_isa.h"
#include "capi.h"

/*
 * Reset Controller, then try to read the Card's signature.
 + Return:
 *   1 = Signature found.
 *   0 = Signature not found.
 */
static int
act2000_isa_reset(unsigned short portbase)
{
	unsigned char reg;
	int i;
	int found;
	int serial = 0;

	found = 0;
	reg = inb(portbase + ISA_COR);
	if (reg != 0xff) {
		outb(reg | ISA_COR_RESET, portbase + ISA_COR);
		mdelay(10);
		outb(reg, portbase + ISA_COR);
		mdelay(10);

		for (i = 0; i < 16; i++) {
			if (inb(portbase + ISA_ISR) & ISA_ISR_SERIAL)
				serial |= 0x10000;
			serial >>= 1;
		}
		if (serial == ISA_SER_ID)
			found++;
	}
	return found;
}

int
act2000_isa_detect(unsigned short portbase)
{
	int ret = 0;

	if (request_region(portbase, ACT2000_PORTLEN, "act2000isa")) {
		ret = act2000_isa_reset(portbase);
		release_region(portbase, ISA_REGION);
	}
	return ret;
}

static irqreturn_t
act2000_isa_interrupt(int dummy, void *dev_id)
{
	act2000_card *card = dev_id;
	u_char istatus;

	istatus = (inb(ISA_PORT_ISR) & 0x07);
	if (istatus & ISA_ISR_OUT) {
		/* RX fifo has data */
		istatus &= ISA_ISR_OUT_MASK;
		outb(0, ISA_PORT_SIS);
		act2000_isa_receive(card);
		outb(ISA_SIS_INT, ISA_PORT_SIS);
	}
	if (istatus & ISA_ISR_ERR) {
		/* Error Interrupt */
		istatus &= ISA_ISR_ERR_MASK;
		printk(KERN_WARNING "act2000: errIRQ\n");
	}
	if (istatus)
		printk(KERN_DEBUG "act2000: ?IRQ %d %02x\n", card->irq, istatus);
	return IRQ_HANDLED;
}

static void
act2000_isa_select_irq(act2000_card *card)
{
	unsigned char reg;

	reg = (inb(ISA_PORT_COR) & ~ISA_COR_IRQOFF) | ISA_COR_PERR;
	switch (card->irq) {
	case 3:
		reg = ISA_COR_IRQ03;
		break;
	case 5:
		reg = ISA_COR_IRQ05;
		break;
	case 7:
		reg = ISA_COR_IRQ07;
		break;
	case 10:
		reg = ISA_COR_IRQ10;
		break;
	case 11:
		reg = ISA_COR_IRQ11;
		break;
	case 12:
		reg = ISA_COR_IRQ12;
		break;
	case 15:
		reg = ISA_COR_IRQ15;
		break;
	}
	outb(reg, ISA_PORT_COR);
}

static void
act2000_isa_enable_irq(act2000_card *card)
{
	act2000_isa_select_irq(card);
	/* Enable READ irq */
	outb(ISA_SIS_INT, ISA_PORT_SIS);
}

/*
 * Install interrupt handler, enable irq on card.
 * If irq is -1, choose next free irq, else irq is given explicitly.
 */
int
act2000_isa_config_irq(act2000_card *card, short irq)
{
	int old_irq;

	if (card->flags & ACT2000_FLAGS_IVALID)
		free_irq(card->irq, card);

	card->flags &= ~ACT2000_FLAGS_IVALID;
	outb(ISA_COR_IRQOFF, ISA_PORT_COR);
	if (!irq)
		return 0;

	old_irq = card->irq;
	card->irq = irq;
	if (request_irq(irq, &act2000_isa_interrupt, 0, card->regname, card)) {
		card->irq = old_irq;
		card->flags |= ACT2000_FLAGS_IVALID;
		printk(KERN_WARNING
		       "act2000: Could not request irq %d\n", irq);
		return -EBUSY;
	} else {
		act2000_isa_select_irq(card);
		/* Disable READ and WRITE irq */
		outb(0, ISA_PORT_SIS);
		outb(0, ISA_PORT_SOS);
	}
	return 0;
}

int
act2000_isa_config_port(act2000_card *card, unsigned short portbase)
{
	if (card->flags & ACT2000_FLAGS_PVALID) {
		release_region(card->port, ISA_REGION);
		card->flags &= ~ACT2000_FLAGS_PVALID;
	}
	if (request_region(portbase, ACT2000_PORTLEN, card->regname) == NULL)
		return -EBUSY;
	else {
		card->port = portbase;
		card->flags |= ACT2000_FLAGS_PVALID;
		return 0;
	}
}

/*
 * Release ressources, used by an adaptor.
 */
void
act2000_isa_release(act2000_card *card)
{
	unsigned long flags;

	spin_lock_irqsave(&card->lock, flags);
	if (card->flags & ACT2000_FLAGS_IVALID)
		free_irq(card->irq, card);

	card->flags &= ~ACT2000_FLAGS_IVALID;
	if (card->flags & ACT2000_FLAGS_PVALID)
		release_region(card->port, ISA_REGION);
	card->flags &= ~ACT2000_FLAGS_PVALID;
	spin_unlock_irqrestore(&card->lock, flags);
}

static int
act2000_isa_writeb(act2000_card *card, u_char data)
{
	u_char timeout = 40;

	while (timeout) {
		if (inb(ISA_PORT_SOS) & ISA_SOS_READY) {
			outb(data, ISA_PORT_SDO);
			return 0;
		} else {
			timeout--;
			udelay(10);
		}
	}
	return 1;
}

static int
act2000_isa_readb(act2000_card *card, u_char *data)
{
	u_char timeout = 40;

	while (timeout) {
		if (inb(ISA_PORT_SIS) & ISA_SIS_READY) {
			*data = inb(ISA_PORT_SDI);
			return 0;
		} else {
			timeout--;
			udelay(10);
		}
	}
	return 1;
}

void
act2000_isa_receive(act2000_card *card)
{
	u_char c;

	if (test_and_set_bit(ACT2000_LOCK_RX, (void *)&card->ilock) != 0)
		return;
	while (!act2000_isa_readb(card, &c)) {
		if (card->idat.isa.rcvidx < 8) {
			card->idat.isa.rcvhdr[card->idat.isa.rcvidx++] = c;
			if (card->idat.isa.rcvidx == 8) {
				int valid = actcapi_chkhdr(card, (actcapi_msghdr *)&card->idat.isa.rcvhdr);

				if (valid) {
					card->idat.isa.rcvlen = ((actcapi_msghdr *)&card->idat.isa.rcvhdr)->len;
					card->idat.isa.rcvskb = dev_alloc_skb(card->idat.isa.rcvlen);
					if (card->idat.isa.rcvskb == NULL) {
						card->idat.isa.rcvignore = 1;
						printk(KERN_WARNING
						       "act2000_isa_receive: no memory\n");
						test_and_clear_bit(ACT2000_LOCK_RX, (void *)&card->ilock);
						return;
					}
					memcpy(skb_put(card->idat.isa.rcvskb, 8), card->idat.isa.rcvhdr, 8);
					card->idat.isa.rcvptr = skb_put(card->idat.isa.rcvskb, card->idat.isa.rcvlen - 8);
				} else {
					card->idat.isa.rcvidx = 0;
					printk(KERN_WARNING
					       "act2000_isa_receive: Invalid CAPI msg\n");
					{
						int i; __u8 *p; __u8 *t; __u8 tmp[30];
						for (i = 0, p = (__u8 *)&card->idat.isa.rcvhdr, t = tmp; i < 8; i++)
							t += sprintf(t, "%02x ", *(p++));
						printk(KERN_WARNING "act2000_isa_receive: %s\n", tmp);
					}
				}
			}
		} else {
			if (!card->idat.isa.rcvignore)
				*card->idat.isa.rcvptr++ = c;
			if (++card->idat.isa.rcvidx >= card->idat.isa.rcvlen) {
				if (!card->idat.isa.rcvignore) {
					skb_queue_tail(&card->rcvq, card->idat.isa.rcvskb);
					act2000_schedule_rx(card);
				}
				card->idat.isa.rcvidx = 0;
				card->idat.isa.rcvlen = 8;
				card->idat.isa.rcvignore = 0;
				card->idat.isa.rcvskb = NULL;
				card->idat.isa.rcvptr = card->idat.isa.rcvhdr;
			}
		}
	}
	if (!(card->flags & ACT2000_FLAGS_IVALID)) {
		/* In polling mode, schedule myself */
		if ((card->idat.isa.rcvidx) &&
		    (card->idat.isa.rcvignore ||
		     (card->idat.isa.rcvidx < card->idat.isa.rcvlen)))
			act2000_schedule_poll(card);
	}
	test_and_clear_bit(ACT2000_LOCK_RX, (void *)&card->ilock);
}

void
act2000_isa_send(act2000_card *card)
{
	unsigned long flags;
	struct sk_buff *skb;
	actcapi_msg *msg;
	int l;

	if (test_and_set_bit(ACT2000_LOCK_TX, (void *)&card->ilock) != 0)
		return;
	while (1) {
		spin_lock_irqsave(&card->lock, flags);
		if (!(card->sbuf)) {
			card->sbuf = skb_dequeue(&card->sndq);
			if (card->sbuf) {
				card->ack_msg = card->sbuf->data;
				msg = (actcapi_msg *)card->sbuf->data;
				if ((msg->hdr.cmd.cmd == 0x86) &&
				    (msg->hdr.cmd.subcmd == 0)) {
					/* Save flags in message */
					card->need_b3ack = msg->msg.data_b3_req.flags;
					msg->msg.data_b3_req.flags = 0;
				}
			}
		}
		spin_unlock_irqrestore(&card->lock, flags);
		if (!(card->sbuf)) {
			/* No more data to send */
			test_and_clear_bit(ACT2000_LOCK_TX, (void *)&card->ilock);
			return;
		}
		skb = card->sbuf;
		l = 0;
		while (skb->len) {
			if (act2000_isa_writeb(card, *(skb->data))) {
				/* Fifo is full, but more data to send */
				test_and_clear_bit(ACT2000_LOCK_TX, (void *)&card->ilock);
				/* Schedule myself */
				act2000_schedule_tx(card);
				return;
			}
			skb_pull(skb, 1);
			l++;
		}
		msg = (actcapi_msg *)card->ack_msg;
		if ((msg->hdr.cmd.cmd == 0x86) &&
		    (msg->hdr.cmd.subcmd == 0)) {
			/*
			 * If it's user data, reset data-ptr
			 * and put skb into ackq.
			 */
			skb->data = card->ack_msg;
			/* Restore flags in message */
			msg->msg.data_b3_req.flags = card->need_b3ack;
			skb_queue_tail(&card->ackq, skb);
		} else
			dev_kfree_skb(skb);
		card->sbuf = NULL;
	}
}

/*
 * Get firmware ID, check for 'ISDN' signature.
 */
static int
act2000_isa_getid(act2000_card *card)
{
	act2000_fwid fid;
	u_char *p = (u_char *)&fid;
	int count = 0;

	while (1) {
		if (count > 510)
			return -EPROTO;
		if (act2000_isa_readb(card, p++))
			break;
		count++;
	}
	if (count <= 20) {
		printk(KERN_WARNING "act2000: No Firmware-ID!\n");
		return -ETIME;
	}
	*p = '\0';
	fid.revlen[0] = '\0';
	if (strcmp(fid.isdn, "ISDN")) {
		printk(KERN_WARNING "act2000: Wrong Firmware-ID!\n");
		return -EPROTO;
	}
	p = strchr(fid.revision, '\n');
	if (p)
		*p = '\0';
	printk(KERN_INFO "act2000: Firmware-ID: %s\n", fid.revision);
	if (card->flags & ACT2000_FLAGS_IVALID) {
		printk(KERN_DEBUG "Enabling Interrupts ...\n");
		act2000_isa_enable_irq(card);
	}
	return 0;
}

/*
 * Download microcode into card, check Firmware signature.
 */
int
act2000_isa_download(act2000_card *card, act2000_ddef __user *cb)
{
	unsigned int length;
	int l;
	int c;
	long timeout;
	u_char *b;
	u_char __user *p;
	u_char *buf;
	act2000_ddef cblock;

	if (!act2000_isa_reset(card->port))
		return -ENXIO;
	msleep_interruptible(500);
	if (copy_from_user(&cblock, cb, sizeof(cblock)))
		return -EFAULT;
	length = cblock.length;
	p = cblock.buffer;
	if (!access_ok(VERIFY_READ, p, length))
		return -EFAULT;
	buf = kmalloc(1024, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	timeout = 0;
	while (length) {
		l = (length > 1024) ? 1024 : length;
		c = 0;
		b = buf;
		if (copy_from_user(buf, p, l)) {
			kfree(buf);
			return -EFAULT;
		}
		while (c < l) {
			if (act2000_isa_writeb(card, *b++)) {
				printk(KERN_WARNING
				       "act2000: loader timed out"
				       " len=%d c=%d\n", length, c);
				kfree(buf);
				return -ETIME;
			}
			c++;
		}
		length -= l;
		p += l;
	}
	kfree(buf);
	msleep_interruptible(500);
	return act2000_isa_getid(card);
}
Commit	Line	Data
1da177e4 LT	1	/* $Id: act2000_isa.c,v 1.11.6.3 2001/09/23 22:24:32 kai Exp $
	2	*
	3	* ISDN lowlevel-module for the IBM ISDN-S0 Active 2000 (ISA-Version).
	4	*
	5	* Author Fritz Elfert
	6	* Copyright by Fritz Elfert <fritz@isdn4linux.de>
475be4d8	7	*
1da177e4 LT	8	* This software may be used and distributed according to the terms
	9	* of the GNU General Public License, incorporated herein by reference.
	10	*
	11	* Thanks to Friedemann Baitinger and IBM Germany
	12	*
	13	*/
	14
	15	#include "act2000.h"
	16	#include "act2000_isa.h"
	17	#include "capi.h"
	18
1da177e4 LT	19	/*
	20	* Reset Controller, then try to read the Card's signature.
	21	+ Return:
	22	* 1 = Signature found.
	23	* 0 = Signature not found.
	24	*/
	25	static int
	26	act2000_isa_reset(unsigned short portbase)
	27	{
475be4d8 JP	28	unsigned char reg;
	29	int i;
	30	int found;
	31	int serial = 0;
	32
	33	found = 0;
360a63c8 SM	34	reg = inb(portbase + ISA_COR);
360a63c8 SM	35	if (reg != 0xff) {
475be4d8 JP	36	outb(reg \| ISA_COR_RESET, portbase + ISA_COR);
	37	mdelay(10);
	38	outb(reg, portbase + ISA_COR);
	39	mdelay(10);
	40
	41	for (i = 0; i < 16; i++) {
	42	if (inb(portbase + ISA_ISR) & ISA_ISR_SERIAL)
	43	serial \|= 0x10000;
	44	serial >>= 1;
	45	}
	46	if (serial == ISA_SER_ID)
	47	found++;
	48	}
	49	return found;
1da177e4 LT	50	}
	51
	52	int
	53	act2000_isa_detect(unsigned short portbase)
	54	{
475be4d8	55	int ret = 0;
1da177e4 LT	56
1da177e4 LT	57	if (request_region(portbase, ACT2000_PORTLEN, "act2000isa")) {
475be4d8	58	ret = act2000_isa_reset(portbase);
1da177e4 LT	59	release_region(portbase, ISA_REGION);
1da177e4 LT	60	}
475be4d8	61	return ret;
1da177e4 LT	62	}
	63
	64	static irqreturn_t
246f93f5	65	act2000_isa_interrupt(int dummy, void *dev_id)
1da177e4	66	{
475be4d8 JP	67	act2000_card *card = dev_id;
475be4d8 JP	68	u_char istatus;
1da177e4	69
475be4d8 JP	70	istatus = (inb(ISA_PORT_ISR) & 0x07);
	71	if (istatus & ISA_ISR_OUT) {
	72	/* RX fifo has data */
1da177e4 LT	73	istatus &= ISA_ISR_OUT_MASK;
	74	outb(0, ISA_PORT_SIS);
	75	act2000_isa_receive(card);
	76	outb(ISA_SIS_INT, ISA_PORT_SIS);
475be4d8 JP	77	}
	78	if (istatus & ISA_ISR_ERR) {
	79	/* Error Interrupt */
1da177e4	80	istatus &= ISA_ISR_ERR_MASK;
475be4d8 JP	81	printk(KERN_WARNING "act2000: errIRQ\n");
475be4d8 JP	82	}
1da177e4	83	if (istatus)
246f93f5	84	printk(KERN_DEBUG "act2000: ?IRQ %d %02x\n", card->irq, istatus);
1da177e4 LT	85	return IRQ_HANDLED;
	86	}
	87
	88	static void
475be4d8	89	act2000_isa_select_irq(act2000_card *card)
1da177e4 LT	90	{
	91	unsigned char reg;
	92
	93	reg = (inb(ISA_PORT_COR) & ~ISA_COR_IRQOFF) \| ISA_COR_PERR;
	94	switch (card->irq) {
475be4d8 JP	95	case 3:
	96	reg = ISA_COR_IRQ03;
	97	break;
	98	case 5:
	99	reg = ISA_COR_IRQ05;
	100	break;
	101	case 7:
	102	reg = ISA_COR_IRQ07;
	103	break;
	104	case 10:
	105	reg = ISA_COR_IRQ10;
	106	break;
	107	case 11:
	108	reg = ISA_COR_IRQ11;
	109	break;
	110	case 12:
	111	reg = ISA_COR_IRQ12;
	112	break;
	113	case 15:
	114	reg = ISA_COR_IRQ15;
	115	break;
1da177e4 LT	116	}
	117	outb(reg, ISA_PORT_COR);
	118	}
	119
	120	static void
475be4d8	121	act2000_isa_enable_irq(act2000_card *card)
1da177e4 LT	122	{
	123	act2000_isa_select_irq(card);
	124	/* Enable READ irq */
	125	outb(ISA_SIS_INT, ISA_PORT_SIS);
	126	}
	127
	128	/*
	129	* Install interrupt handler, enable irq on card.
c03983ac	130	* If irq is -1, choose next free irq, else irq is given explicitly.
1da177e4 LT	131	*/
1da177e4 LT	132	int
475be4d8	133	act2000_isa_config_irq(act2000_card *card, short irq)
1da177e4	134	{
246f93f5 JG	135	int old_irq;
246f93f5 JG	136
a554d48a	137	if (card->flags & ACT2000_FLAGS_IVALID)
475be4d8	138	free_irq(card->irq, card);
a554d48a	139
475be4d8 JP	140	card->flags &= ~ACT2000_FLAGS_IVALID;
	141	outb(ISA_COR_IRQOFF, ISA_PORT_COR);
	142	if (!irq)
	143	return 0;
1da177e4	144
246f93f5 JG	145	old_irq = card->irq;
	146	card->irq = irq;
	147	if (request_irq(irq, &act2000_isa_interrupt, 0, card->regname, card)) {
	148	card->irq = old_irq;
1da177e4	149	card->flags \|= ACT2000_FLAGS_IVALID;
475be4d8 JP	150	printk(KERN_WARNING
	151	"act2000: Could not request irq %d\n", irq);
	152	return -EBUSY;
	153	} else {
1da177e4	154	act2000_isa_select_irq(card);
475be4d8 JP	155	/* Disable READ and WRITE irq */
	156	outb(0, ISA_PORT_SIS);
	157	outb(0, ISA_PORT_SOS);
	158	}
	159	return 0;
1da177e4 LT	160	}
	161
	162	int
475be4d8	163	act2000_isa_config_port(act2000_card *card, unsigned short portbase)
1da177e4	164	{
475be4d8 JP	165	if (card->flags & ACT2000_FLAGS_PVALID) {
	166	release_region(card->port, ISA_REGION);
	167	card->flags &= ~ACT2000_FLAGS_PVALID;
	168	}
1da177e4 LT	169	if (request_region(portbase, ACT2000_PORTLEN, card->regname) == NULL)
	170	return -EBUSY;
	171	else {
475be4d8 JP	172	card->port = portbase;
	173	card->flags \|= ACT2000_FLAGS_PVALID;
	174	return 0;
	175	}
1da177e4 LT	176	}
	177
	178	/*
	179	* Release ressources, used by an adaptor.
	180	*/
	181	void
475be4d8	182	act2000_isa_release(act2000_card *card)
1da177e4	183	{
475be4d8	184	unsigned long flags;
1da177e4	185
475be4d8 JP	186	spin_lock_irqsave(&card->lock, flags);
	187	if (card->flags & ACT2000_FLAGS_IVALID)
	188	free_irq(card->irq, card);
d87dbede	189
475be4d8 JP	190	card->flags &= ~ACT2000_FLAGS_IVALID;
	191	if (card->flags & ACT2000_FLAGS_PVALID)
	192	release_region(card->port, ISA_REGION);
	193	card->flags &= ~ACT2000_FLAGS_PVALID;
	194	spin_unlock_irqrestore(&card->lock, flags);
1da177e4 LT	195	}
	196
	197	static int
475be4d8	198	act2000_isa_writeb(act2000_card *card, u_char data)
1da177e4	199	{
475be4d8 JP	200	u_char timeout = 40;
	201
	202	while (timeout) {
	203	if (inb(ISA_PORT_SOS) & ISA_SOS_READY) {
	204	outb(data, ISA_PORT_SDO);
	205	return 0;
	206	} else {
	207	timeout--;
	208	udelay(10);
	209	}
	210	}
	211	return 1;
1da177e4 LT	212	}
	213
	214	static int
475be4d8	215	act2000_isa_readb(act2000_card card, u_char data)
1da177e4	216	{
475be4d8 JP	217	u_char timeout = 40;
	218
	219	while (timeout) {
	220	if (inb(ISA_PORT_SIS) & ISA_SIS_READY) {
	221	*data = inb(ISA_PORT_SDI);
	222	return 0;
	223	} else {
	224	timeout--;
	225	udelay(10);
	226	}
	227	}
	228	return 1;
1da177e4 LT	229	}
	230
	231	void
	232	act2000_isa_receive(act2000_card *card)
	233	{
	234	u_char c;
	235
78481742	236	if (test_and_set_bit(ACT2000_LOCK_RX, (void *)&card->ilock) != 0)
1da177e4 LT	237	return;
	238	while (!act2000_isa_readb(card, &c)) {
	239	if (card->idat.isa.rcvidx < 8) {
475be4d8	240	card->idat.isa.rcvhdr[card->idat.isa.rcvidx++] = c;
1da177e4 LT	241	if (card->idat.isa.rcvidx == 8) {
	242	int valid = actcapi_chkhdr(card, (actcapi_msghdr *)&card->idat.isa.rcvhdr);
	243
	244	if (valid) {
	245	card->idat.isa.rcvlen = ((actcapi_msghdr *)&card->idat.isa.rcvhdr)->len;
	246	card->idat.isa.rcvskb = dev_alloc_skb(card->idat.isa.rcvlen);
	247	if (card->idat.isa.rcvskb == NULL) {
	248	card->idat.isa.rcvignore = 1;
	249	printk(KERN_WARNING
	250	"act2000_isa_receive: no memory\n");
78481742	251	test_and_clear_bit(ACT2000_LOCK_RX, (void *)&card->ilock);
1da177e4 LT	252	return;
	253	}
	254	memcpy(skb_put(card->idat.isa.rcvskb, 8), card->idat.isa.rcvhdr, 8);
	255	card->idat.isa.rcvptr = skb_put(card->idat.isa.rcvskb, card->idat.isa.rcvlen - 8);
	256	} else {
	257	card->idat.isa.rcvidx = 0;
	258	printk(KERN_WARNING
	259	"act2000_isa_receive: Invalid CAPI msg\n");
	260	{
cf80063a HE	261	int i; __u8 p; __u8 t; __u8 tmp[30];
	262	for (i = 0, p = (__u8 *)&card->idat.isa.rcvhdr, t = tmp; i < 8; i++)
	263	t += sprintf(t, "%02x ", *(p++));
1da177e4 LT	264	printk(KERN_WARNING "act2000_isa_receive: %s\n", tmp);
	265	}
	266	}
	267	}
	268	} else {
	269	if (!card->idat.isa.rcvignore)
	270	*card->idat.isa.rcvptr++ = c;
	271	if (++card->idat.isa.rcvidx >= card->idat.isa.rcvlen) {
	272	if (!card->idat.isa.rcvignore) {
	273	skb_queue_tail(&card->rcvq, card->idat.isa.rcvskb);
	274	act2000_schedule_rx(card);
	275	}
	276	card->idat.isa.rcvidx = 0;
	277	card->idat.isa.rcvlen = 8;
	278	card->idat.isa.rcvignore = 0;
	279	card->idat.isa.rcvskb = NULL;
	280	card->idat.isa.rcvptr = card->idat.isa.rcvhdr;
	281	}
	282	}
	283	}
	284	if (!(card->flags & ACT2000_FLAGS_IVALID)) {
	285	/* In polling mode, schedule myself */
	286	if ((card->idat.isa.rcvidx) &&
	287	(card->idat.isa.rcvignore \|\|
	288	(card->idat.isa.rcvidx < card->idat.isa.rcvlen)))
	289	act2000_schedule_poll(card);
	290	}
78481742	291	test_and_clear_bit(ACT2000_LOCK_RX, (void *)&card->ilock);
1da177e4 LT	292	}
	293
	294	void
475be4d8	295	act2000_isa_send(act2000_card *card)
1da177e4 LT	296	{
	297	unsigned long flags;
	298	struct sk_buff *skb;
	299	actcapi_msg *msg;
	300	int l;
	301
78481742	302	if (test_and_set_bit(ACT2000_LOCK_TX, (void *)&card->ilock) != 0)
1da177e4 LT	303	return;
	304	while (1) {
	305	spin_lock_irqsave(&card->lock, flags);
	306	if (!(card->sbuf)) {
360a63c8 SM	307	card->sbuf = skb_dequeue(&card->sndq);
360a63c8 SM	308	if (card->sbuf) {
1da177e4 LT	309	card->ack_msg = card->sbuf->data;
	310	msg = (actcapi_msg *)card->sbuf->data;
	311	if ((msg->hdr.cmd.cmd == 0x86) &&
475be4d8	312	(msg->hdr.cmd.subcmd == 0)) {
1da177e4 LT	313	/* Save flags in message */
	314	card->need_b3ack = msg->msg.data_b3_req.flags;
	315	msg->msg.data_b3_req.flags = 0;
	316	}
	317	}
	318	}
	319	spin_unlock_irqrestore(&card->lock, flags);
	320	if (!(card->sbuf)) {
	321	/* No more data to send */
78481742	322	test_and_clear_bit(ACT2000_LOCK_TX, (void *)&card->ilock);
1da177e4 LT	323	return;
	324	}
	325	skb = card->sbuf;
	326	l = 0;
	327	while (skb->len) {
	328	if (act2000_isa_writeb(card, *(skb->data))) {
	329	/* Fifo is full, but more data to send */
78481742	330	test_and_clear_bit(ACT2000_LOCK_TX, (void *)&card->ilock);
1da177e4 LT	331	/* Schedule myself */
	332	act2000_schedule_tx(card);
	333	return;
	334	}
	335	skb_pull(skb, 1);
	336	l++;
	337	}
	338	msg = (actcapi_msg *)card->ack_msg;
	339	if ((msg->hdr.cmd.cmd == 0x86) &&
475be4d8	340	(msg->hdr.cmd.subcmd == 0)) {
1da177e4 LT	341	/*
	342	* If it's user data, reset data-ptr
	343	* and put skb into ackq.
	344	*/
	345	skb->data = card->ack_msg;
	346	/* Restore flags in message */
	347	msg->msg.data_b3_req.flags = card->need_b3ack;
	348	skb_queue_tail(&card->ackq, skb);
	349	} else
	350	dev_kfree_skb(skb);
	351	card->sbuf = NULL;
	352	}
	353	}
	354
	355	/*
	356	* Get firmware ID, check for 'ISDN' signature.
	357	*/
	358	static int
475be4d8	359	act2000_isa_getid(act2000_card *card)
1da177e4	360	{
475be4d8 JP	361	act2000_fwid fid;
	362	u_char p = (u_char )&fid;
	363	int count = 0;
	364
	365	while (1) {
	366	if (count > 510)
	367	return -EPROTO;
	368	if (act2000_isa_readb(card, p++))
	369	break;
	370	count++;
	371	}
	372	if (count <= 20) {
	373	printk(KERN_WARNING "act2000: No Firmware-ID!\n");
	374	return -ETIME;
	375	}
	376	*p = '\0';
	377	fid.revlen[0] = '\0';
	378	if (strcmp(fid.isdn, "ISDN")) {
	379	printk(KERN_WARNING "act2000: Wrong Firmware-ID!\n");
	380	return -EPROTO;
	381	}
360a63c8 SM	382	p = strchr(fid.revision, '\n');
360a63c8 SM	383	if (p)
1da177e4	384	*p = '\0';
475be4d8	385	printk(KERN_INFO "act2000: Firmware-ID: %s\n", fid.revision);
1da177e4 LT	386	if (card->flags & ACT2000_FLAGS_IVALID) {
	387	printk(KERN_DEBUG "Enabling Interrupts ...\n");
	388	act2000_isa_enable_irq(card);
	389	}
475be4d8	390	return 0;
1da177e4 LT	391	}
	392
	393	/*
	394	* Download microcode into card, check Firmware signature.
	395	*/
	396	int
475be4d8	397	act2000_isa_download(act2000_card card, act2000_ddef __user cb)
1da177e4	398	{
475be4d8 JP	399	unsigned int length;
	400	int l;
	401	int c;
	402	long timeout;
	403	u_char *b;
	404	u_char __user *p;
	405	u_char *buf;
	406	act2000_ddef cblock;
	407
	408	if (!act2000_isa_reset(card->port))
	409	return -ENXIO;
	410	msleep_interruptible(500);
	411	if (copy_from_user(&cblock, cb, sizeof(cblock)))
	412	return -EFAULT;
	413	length = cblock.length;
	414	p = cblock.buffer;
	415	if (!access_ok(VERIFY_READ, p, length))
	416	return -EFAULT;
	417	buf = kmalloc(1024, GFP_KERNEL);
	418	if (!buf)
	419	return -ENOMEM;
	420	timeout = 0;
	421	while (length) {
	422	l = (length > 1024) ? 1024 : length;
	423	c = 0;
	424	b = buf;
	425	if (copy_from_user(buf, p, l)) {
	426	kfree(buf);
	427	return -EFAULT;
	428	}
	429	while (c < l) {
	430	if (act2000_isa_writeb(card, *b++)) {
	431	printk(KERN_WARNING
	432	"act2000: loader timed out"
	433	" len=%d c=%d\n", length, c);
	434	kfree(buf);
	435	return -ETIME;
	436	}
	437	c++;
	438	}
	439	length -= l;
	440	p += l;
	441	}
	442	kfree(buf);
	443	msleep_interruptible(500);
2c78f701	444	return act2000_isa_getid(card);
1da177e4	445	}