[deliverable/linux.git] / drivers / isdn / hysdn / boardergo.c

/* $Id: boardergo.c,v 1.5.6.7 2001/11/06 21:58:19 kai Exp $
 *
 * Linux driver for HYSDN cards, specific routines for ergo type boards.
 *
 * Author    Werner Cornelius (werner@titro.de) for Hypercope GmbH
 * Copyright 1999 by Werner Cornelius (werner@titro.de)
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * As all Linux supported cards Champ2, Ergo and Metro2/4 use the same
 * DPRAM interface and layout with only minor differences all related
 * stuff is done here, not in separate modules.
 *
 */

#include <linux/signal.h>
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/vmalloc.h>
#include <linux/delay.h>
#include <asm/io.h>

#include "hysdn_defs.h"
#include "boardergo.h"

#define byteout(addr, val) outb(val, addr)
#define bytein(addr) inb(addr)

/***************************************************/
/* The cards interrupt handler. Called from system */
/***************************************************/
static irqreturn_t
ergo_interrupt(int intno, void *dev_id)
{
	hysdn_card *card = dev_id;	/* parameter from irq */
	tErgDpram *dpr;
	unsigned long flags;
	unsigned char volatile b;

	if (!card)
		return IRQ_NONE;		/* error -> spurious interrupt */
	if (!card->irq_enabled)
		return IRQ_NONE;		/* other device interrupting or irq switched off */

	spin_lock_irqsave(&card->hysdn_lock, flags); /* no further irqs allowed */

	if (!(bytein(card->iobase + PCI9050_INTR_REG) & PCI9050_INTR_REG_STAT1)) {
		spin_unlock_irqrestore(&card->hysdn_lock, flags);	/* restore old state */
		return IRQ_NONE;		/* no interrupt requested by E1 */
	}
	/* clear any pending ints on the board */
	dpr = card->dpram;
	b = dpr->ToPcInt;	/* clear for ergo */
	b |= dpr->ToPcIntMetro;	/* same for metro */
	b |= dpr->ToHyInt;	/* and for champ */

	/* start kernel task immediately after leaving all interrupts */
	if (!card->hw_lock)
		schedule_work(&card->irq_queue);
	spin_unlock_irqrestore(&card->hysdn_lock, flags);
	return IRQ_HANDLED;
}				/* ergo_interrupt */

/******************************************************************************/
/* ergo_irq_bh will be called as part of the kernel clearing its shared work  */
/* queue sometime after a call to schedule_work has been made passing our     */
/* work_struct. This task is the only one handling data transfer from or to   */
/* the card after booting. The task may be queued from everywhere             */
/* (interrupts included).                                                     */
/******************************************************************************/
static void
ergo_irq_bh(struct work_struct *ugli_api)
{
	hysdn_card *card = container_of(ugli_api, hysdn_card, irq_queue);
	tErgDpram *dpr;
	int again;
	unsigned long flags;

	if (card->state != CARD_STATE_RUN)
		return;		/* invalid call */

	dpr = card->dpram;	/* point to DPRAM */

	spin_lock_irqsave(&card->hysdn_lock, flags);
	if (card->hw_lock) {
		spin_unlock_irqrestore(&card->hysdn_lock, flags);	/* hardware currently unavailable */
		return;
	}
	card->hw_lock = 1;	/* we now lock the hardware */

	do {
		again = 0;	/* assume loop not to be repeated */

		if (!dpr->ToHyFlag) {
			/* we are able to send a buffer */

			if (hysdn_sched_tx(card, dpr->ToHyBuf, &dpr->ToHySize, &dpr->ToHyChannel,
					   ERG_TO_HY_BUF_SIZE)) {
				dpr->ToHyFlag = 1;	/* enable tx */
				again = 1;	/* restart loop */
			}
		}		/* we are able to send a buffer */
		if (dpr->ToPcFlag) {
			/* a message has arrived for us, handle it */

			if (hysdn_sched_rx(card, dpr->ToPcBuf, dpr->ToPcSize, dpr->ToPcChannel)) {
				dpr->ToPcFlag = 0;	/* we worked the data */
				again = 1;	/* restart loop */
			}
		}		/* a message has arrived for us */
		if (again) {
			dpr->ToHyInt = 1;
			dpr->ToPcInt = 1;	/* interrupt to E1 for all cards */
		} else
			card->hw_lock = 0;	/* free hardware again */
	} while (again);	/* until nothing more to do */

	spin_unlock_irqrestore(&card->hysdn_lock, flags);
}				/* ergo_irq_bh */


/*********************************************************/
/* stop the card (hardware reset) and disable interrupts */
/*********************************************************/
static void
ergo_stopcard(hysdn_card *card)
{
	unsigned long flags;
	unsigned char val;

	hysdn_net_release(card);	/* first release the net device if existing */
#ifdef CONFIG_HYSDN_CAPI
	hycapi_capi_stop(card);
#endif /* CONFIG_HYSDN_CAPI */
	spin_lock_irqsave(&card->hysdn_lock, flags);
	val = bytein(card->iobase + PCI9050_INTR_REG);	/* get actual value */
	val &= ~(PCI9050_INTR_REG_ENPCI | PCI9050_INTR_REG_EN1);	/* mask irq */
	byteout(card->iobase + PCI9050_INTR_REG, val);
	card->irq_enabled = 0;
	byteout(card->iobase + PCI9050_USER_IO, PCI9050_E1_RESET);	/* reset E1 processor */
	card->state = CARD_STATE_UNUSED;
	card->err_log_state = ERRLOG_STATE_OFF;		/* currently no log active */

	spin_unlock_irqrestore(&card->hysdn_lock, flags);
}				/* ergo_stopcard */

/**************************************************************************/
/* enable or disable the cards error log. The event is queued if possible */
/**************************************************************************/
static void
ergo_set_errlog_state(hysdn_card *card, int on)
{
	unsigned long flags;

	if (card->state != CARD_STATE_RUN) {
		card->err_log_state = ERRLOG_STATE_OFF;		/* must be off */
		return;
	}
	spin_lock_irqsave(&card->hysdn_lock, flags);

	if (((card->err_log_state == ERRLOG_STATE_OFF) && !on) ||
	    ((card->err_log_state == ERRLOG_STATE_ON) && on)) {
		spin_unlock_irqrestore(&card->hysdn_lock, flags);
		return;		/* nothing to do */
	}
	if (on)
		card->err_log_state = ERRLOG_STATE_START;	/* request start */
	else
		card->err_log_state = ERRLOG_STATE_STOP;	/* request stop */

	spin_unlock_irqrestore(&card->hysdn_lock, flags);
	schedule_work(&card->irq_queue);
}				/* ergo_set_errlog_state */

/******************************************/
/* test the cards RAM and return 0 if ok. */
/******************************************/
static const char TestText[36] = "This Message is filler, why read it";

static int
ergo_testram(hysdn_card *card)
{
	tErgDpram *dpr = card->dpram;

	memset(dpr->TrapTable, 0, sizeof(dpr->TrapTable));	/* clear all Traps */
	dpr->ToHyInt = 1;	/* E1 INTR state forced */

	memcpy(&dpr->ToHyBuf[ERG_TO_HY_BUF_SIZE - sizeof(TestText)], TestText,
	       sizeof(TestText));
	if (memcmp(&dpr->ToHyBuf[ERG_TO_HY_BUF_SIZE - sizeof(TestText)], TestText,
		   sizeof(TestText)))
		return (-1);

	memcpy(&dpr->ToPcBuf[ERG_TO_PC_BUF_SIZE - sizeof(TestText)], TestText,
	       sizeof(TestText));
	if (memcmp(&dpr->ToPcBuf[ERG_TO_PC_BUF_SIZE - sizeof(TestText)], TestText,
		   sizeof(TestText)))
		return (-1);

	return (0);
}				/* ergo_testram */

/*****************************************************************************/
/* this function is intended to write stage 1 boot image to the cards buffer */
/* this is done in two steps. First the 1024 hi-words are written (offs=0),  */
/* then the 1024 lo-bytes are written. The remaining DPRAM is cleared, the   */
/* PCI-write-buffers flushed and the card is taken out of reset.             */
/* The function then waits for a reaction of the E1 processor or a timeout.  */
/* Negative return values are interpreted as errors.                         */
/*****************************************************************************/
static int
ergo_writebootimg(struct HYSDN_CARD *card, unsigned char *buf,
		  unsigned long offs)
{
	unsigned char *dst;
	tErgDpram *dpram;
	int cnt = (BOOT_IMG_SIZE >> 2);		/* number of words to move and swap (byte order!) */

	if (card->debug_flags & LOG_POF_CARD)
		hysdn_addlog(card, "ERGO: write bootldr offs=0x%lx ", offs);

	dst = card->dpram;	/* pointer to start of DPRAM */
	dst += (offs + ERG_DPRAM_FILL_SIZE);	/* offset in the DPRAM */
	while (cnt--) {
		*dst++ = *(buf + 1);	/* high byte */
		*dst++ = *buf;	/* low byte */
		dst += 2;	/* point to next longword */
		buf += 2;	/* buffer only filled with words */
	}

	/* if low words (offs = 2) have been written, clear the rest of the DPRAM, */
	/* flush the PCI-write-buffer and take the E1 out of reset */
	if (offs) {
		memset(card->dpram, 0, ERG_DPRAM_FILL_SIZE);	/* fill the DPRAM still not cleared */
		dpram = card->dpram;	/* get pointer to dpram structure */
		dpram->ToHyNoDpramErrLog = 0xFF;	/* write a dpram register */
		while (!dpram->ToHyNoDpramErrLog);	/* reread volatile register to flush PCI */

		byteout(card->iobase + PCI9050_USER_IO, PCI9050_E1_RUN);	/* start E1 processor */
		/* the interrupts are still masked */

		msleep_interruptible(20);		/* Timeout 20ms */

		if (((tDpramBootSpooler *) card->dpram)->Len != DPRAM_SPOOLER_DATA_SIZE) {
			if (card->debug_flags & LOG_POF_CARD)
				hysdn_addlog(card, "ERGO: write bootldr no answer");
			return (-ERR_BOOTIMG_FAIL);
		}
	}			/* start_boot_img */
	return (0);		/* successful */
}				/* ergo_writebootimg */

/********************************************************************************/
/* ergo_writebootseq writes the buffer containing len bytes to the E1 processor */
/* using the boot spool mechanism. If everything works fine 0 is returned. In   */
/* case of errors a negative error value is returned.                           */
/********************************************************************************/
static int
ergo_writebootseq(struct HYSDN_CARD *card, unsigned char *buf, int len)
{
	tDpramBootSpooler *sp = (tDpramBootSpooler *) card->dpram;
	unsigned char *dst;
	unsigned char buflen;
	int nr_write;
	unsigned char tmp_rdptr;
	unsigned char wr_mirror;
	int i;

	if (card->debug_flags & LOG_POF_CARD)
		hysdn_addlog(card, "ERGO: write boot seq len=%d ", len);

	dst = sp->Data;		/* point to data in spool structure */
	buflen = sp->Len;	/* maximum len of spooled data */
	wr_mirror = sp->WrPtr;	/* only once read */

	/* try until all bytes written or error */
	i = 0x1000;		/* timeout value */
	while (len) {

		/* first determine the number of bytes that may be buffered */
		do {
			tmp_rdptr = sp->RdPtr;	/* first read the pointer */
			i--;	/* decrement timeout */
		} while (i && (tmp_rdptr != sp->RdPtr));	/* wait for stable pointer */

		if (!i) {
			if (card->debug_flags & LOG_POF_CARD)
				hysdn_addlog(card, "ERGO: write boot seq timeout");
			return (-ERR_BOOTSEQ_FAIL);	/* value not stable -> timeout */
		}
		if ((nr_write = tmp_rdptr - wr_mirror - 1) < 0)
			nr_write += buflen;	/* now we got number of free bytes - 1 in buffer */

		if (!nr_write)
			continue;	/* no free bytes in buffer */

		if (nr_write > len)
			nr_write = len;		/* limit if last few bytes */
		i = 0x1000;	/* reset timeout value */

		/* now we know how much bytes we may put in the puffer */
		len -= nr_write;	/* we savely could adjust len before output */
		while (nr_write--) {
			*(dst + wr_mirror) = *buf++;	/* output one byte */
			if (++wr_mirror >= buflen)
				wr_mirror = 0;
			sp->WrPtr = wr_mirror;	/* announce the next byte to E1 */
		}		/* while (nr_write) */

	}			/* while (len) */
	return (0);
}				/* ergo_writebootseq */

/***********************************************************************************/
/* ergo_waitpofready waits for a maximum of 10 seconds for the completition of the */
/* boot process. If the process has been successful 0 is returned otherwise a     */
/* negative error code is returned.                                                */
/***********************************************************************************/
static int
ergo_waitpofready(struct HYSDN_CARD *card)
{
	tErgDpram *dpr = card->dpram;	/* pointer to DPRAM structure */
	int timecnt = 10000 / 50;	/* timeout is 10 secs max. */
	unsigned long flags;
	int msg_size;
	int i;

	if (card->debug_flags & LOG_POF_CARD)
		hysdn_addlog(card, "ERGO: waiting for pof ready");
	while (timecnt--) {
		/* wait until timeout  */

		if (dpr->ToPcFlag) {
			/* data has arrived */

			if ((dpr->ToPcChannel != CHAN_SYSTEM) ||
			    (dpr->ToPcSize < MIN_RDY_MSG_SIZE) ||
			    (dpr->ToPcSize > MAX_RDY_MSG_SIZE) ||
			    ((*(unsigned long *) dpr->ToPcBuf) != RDY_MAGIC))
				break;	/* an error occurred */

			/* Check for additional data delivered during SysReady */
			msg_size = dpr->ToPcSize - RDY_MAGIC_SIZE;
			if (msg_size > 0)
				if (EvalSysrTokData(card, dpr->ToPcBuf + RDY_MAGIC_SIZE, msg_size))
					break;

			if (card->debug_flags & LOG_POF_RECORD)
				hysdn_addlog(card, "ERGO: pof boot success");
			spin_lock_irqsave(&card->hysdn_lock, flags);

			card->state = CARD_STATE_RUN;	/* now card is running */
			/* enable the cards interrupt */
			byteout(card->iobase + PCI9050_INTR_REG,
				bytein(card->iobase + PCI9050_INTR_REG) |
				(PCI9050_INTR_REG_ENPCI | PCI9050_INTR_REG_EN1));
			card->irq_enabled = 1;	/* we are ready to receive interrupts */

			dpr->ToPcFlag = 0;	/* reset data indicator */
			dpr->ToHyInt = 1;
			dpr->ToPcInt = 1;	/* interrupt to E1 for all cards */

			spin_unlock_irqrestore(&card->hysdn_lock, flags);
			if ((hynet_enable & (1 << card->myid))
			    && (i = hysdn_net_create(card)))
			{
				ergo_stopcard(card);
				card->state = CARD_STATE_BOOTERR;
				return (i);
			}
#ifdef CONFIG_HYSDN_CAPI
			if ((i = hycapi_capi_create(card))) {
				printk(KERN_WARNING "HYSDN: failed to create capi-interface.\n");
			}
#endif /* CONFIG_HYSDN_CAPI */
			return (0);	/* success */
		}		/* data has arrived */
		msleep_interruptible(50);		/* Timeout 50ms */
	}			/* wait until timeout */

	if (card->debug_flags & LOG_POF_CARD)
		hysdn_addlog(card, "ERGO: pof boot ready timeout");
	return (-ERR_POF_TIMEOUT);
}				/* ergo_waitpofready */


/************************************************************************************/
/* release the cards hardware. Before releasing do a interrupt disable and hardware */
/* reset. Also unmap dpram.                                                         */
/* Use only during module release.                                                  */
/************************************************************************************/
static void
ergo_releasehardware(hysdn_card *card)
{
	ergo_stopcard(card);	/* first stop the card if not already done */
	free_irq(card->irq, card);	/* release interrupt */
	release_region(card->iobase + PCI9050_INTR_REG, 1);	/* release all io ports */
	release_region(card->iobase + PCI9050_USER_IO, 1);
	iounmap(card->dpram);
	card->dpram = NULL;	/* release shared mem */
}				/* ergo_releasehardware */


/*********************************************************************************/
/* acquire the needed hardware ports and map dpram. If an error occurs a nonzero */
/* value is returned.                                                            */
/* Use only during module init.                                                  */
/*********************************************************************************/
int
ergo_inithardware(hysdn_card *card)
{
	if (!request_region(card->iobase + PCI9050_INTR_REG, 1, "HYSDN"))
		return (-1);
	if (!request_region(card->iobase + PCI9050_USER_IO, 1, "HYSDN")) {
		release_region(card->iobase + PCI9050_INTR_REG, 1);
		return (-1);	/* ports already in use */
	}
	card->memend = card->membase + ERG_DPRAM_PAGE_SIZE - 1;
	if (!(card->dpram = ioremap(card->membase, ERG_DPRAM_PAGE_SIZE))) {
		release_region(card->iobase + PCI9050_INTR_REG, 1);
		release_region(card->iobase + PCI9050_USER_IO, 1);
		return (-1);
	}

	ergo_stopcard(card);	/* disable interrupts */
	if (request_irq(card->irq, ergo_interrupt, IRQF_SHARED, "HYSDN", card)) {
		ergo_releasehardware(card); /* return the acquired hardware */
		return (-1);
	}
	/* success, now setup the function pointers */
	card->stopcard = ergo_stopcard;
	card->releasehardware = ergo_releasehardware;
	card->testram = ergo_testram;
	card->writebootimg = ergo_writebootimg;
	card->writebootseq = ergo_writebootseq;
	card->waitpofready = ergo_waitpofready;
	card->set_errlog_state = ergo_set_errlog_state;
	INIT_WORK(&card->irq_queue, ergo_irq_bh);
	spin_lock_init(&card->hysdn_lock);

	return (0);
}				/* ergo_inithardware */
Commit	Line	Data
1da177e4 LT	1	/* $Id: boardergo.c,v 1.5.6.7 2001/11/06 21:58:19 kai Exp $
	2	*
	3	* Linux driver for HYSDN cards, specific routines for ergo type boards.
	4	*
	5	* Author Werner Cornelius (werner@titro.de) for Hypercope GmbH
	6	* Copyright 1999 by Werner Cornelius (werner@titro.de)
	7	*
	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	* As all Linux supported cards Champ2, Ergo and Metro2/4 use the same
	12	* DPRAM interface and layout with only minor differences all related
	13	* stuff is done here, not in separate modules.
	14	*
	15	*/
	16
1da177e4 LT	17	#include <linux/signal.h>
	18	#include <linux/kernel.h>
	19	#include <linux/ioport.h>
	20	#include <linux/interrupt.h>
	21	#include <linux/vmalloc.h>
	22	#include <linux/delay.h>
	23	#include <asm/io.h>
	24
	25	#include "hysdn_defs.h"
	26	#include "boardergo.h"
	27
475be4d8	28	#define byteout(addr, val) outb(val, addr)
1da177e4 LT	29	#define bytein(addr) inb(addr)
	30
	31	/***************************************************/
	32	/* The cards interrupt handler. Called from system */
	33	/***************************************************/
	34	static irqreturn_t
7d12e780	35	ergo_interrupt(int intno, void *dev_id)
1da177e4 LT	36	{
	37	hysdn_card card = dev_id; / parameter from irq */
	38	tErgDpram *dpr;
c721bcce AM	39	unsigned long flags;
c721bcce AM	40	unsigned char volatile b;
1da177e4 LT	41
	42	if (!card)
	43	return IRQ_NONE; /* error -> spurious interrupt */
	44	if (!card->irq_enabled)
	45	return IRQ_NONE; /* other device interrupting or irq switched off */
	46
0d9ba869	47	spin_lock_irqsave(&card->hysdn_lock, flags); /* no further irqs allowed */
1da177e4 LT	48
1da177e4 LT	49	if (!(bytein(card->iobase + PCI9050_INTR_REG) & PCI9050_INTR_REG_STAT1)) {
0d9ba869	50	spin_unlock_irqrestore(&card->hysdn_lock, flags); /* restore old state */
1da177e4 LT	51	return IRQ_NONE; /* no interrupt requested by E1 */
	52	}
	53	/* clear any pending ints on the board */
	54	dpr = card->dpram;
	55	b = dpr->ToPcInt; /* clear for ergo */
	56	b \|= dpr->ToPcIntMetro; /* same for metro */
	57	b \|= dpr->ToHyInt; /* and for champ */
	58
	59	/* start kernel task immediately after leaving all interrupts */
	60	if (!card->hw_lock)
	61	schedule_work(&card->irq_queue);
0d9ba869	62	spin_unlock_irqrestore(&card->hysdn_lock, flags);
1da177e4 LT	63	return IRQ_HANDLED;
	64	} /* ergo_interrupt */
	65
	66	/******************************************************************************/
a9dd7fe2 MA	67	/* ergo_irq_bh will be called as part of the kernel clearing its shared work */
	68	/* queue sometime after a call to schedule_work has been made passing our */
	69	/* work_struct. This task is the only one handling data transfer from or to */
	70	/* the card after booting. The task may be queued from everywhere */
	71	/* (interrupts included). */
1da177e4 LT	72	/******************************************************************************/
1da177e4 LT	73	static void
3e577a80	74	ergo_irq_bh(struct work_struct *ugli_api)
1da177e4	75	{
475be4d8	76	hysdn_card *card = container_of(ugli_api, hysdn_card, irq_queue);
1da177e4 LT	77	tErgDpram *dpr;
1da177e4 LT	78	int again;
c721bcce	79	unsigned long flags;
1da177e4 LT	80
	81	if (card->state != CARD_STATE_RUN)
	82	return; /* invalid call */
	83
	84	dpr = card->dpram; /* point to DPRAM */
	85
0d9ba869	86	spin_lock_irqsave(&card->hysdn_lock, flags);
1da177e4	87	if (card->hw_lock) {
0d9ba869	88	spin_unlock_irqrestore(&card->hysdn_lock, flags); /* hardware currently unavailable */
1da177e4 LT	89	return;
	90	}
	91	card->hw_lock = 1; /* we now lock the hardware */
	92
	93	do {
1da177e4 LT	94	again = 0; /* assume loop not to be repeated */
	95
	96	if (!dpr->ToHyFlag) {
	97	/* we are able to send a buffer */
	98
	99	if (hysdn_sched_tx(card, dpr->ToHyBuf, &dpr->ToHySize, &dpr->ToHyChannel,
	100	ERG_TO_HY_BUF_SIZE)) {
	101	dpr->ToHyFlag = 1; /* enable tx */
	102	again = 1; /* restart loop */
	103	}
	104	} /* we are able to send a buffer */
	105	if (dpr->ToPcFlag) {
	106	/* a message has arrived for us, handle it */
	107
	108	if (hysdn_sched_rx(card, dpr->ToPcBuf, dpr->ToPcSize, dpr->ToPcChannel)) {
	109	dpr->ToPcFlag = 0; /* we worked the data */
	110	again = 1; /* restart loop */
	111	}
	112	} /* a message has arrived for us */
1da177e4 LT	113	if (again) {
	114	dpr->ToHyInt = 1;
	115	dpr->ToPcInt = 1; /* interrupt to E1 for all cards */
	116	} else
	117	card->hw_lock = 0; /* free hardware again */
	118	} while (again); /* until nothing more to do */
	119
0d9ba869	120	spin_unlock_irqrestore(&card->hysdn_lock, flags);
1da177e4 LT	121	} /* ergo_irq_bh */
	122
	123
	124	/*********************************************************/
	125	/* stop the card (hardware reset) and disable interrupts */
	126	/*********************************************************/
	127	static void
475be4d8	128	ergo_stopcard(hysdn_card *card)
1da177e4	129	{
c721bcce AM	130	unsigned long flags;
c721bcce AM	131	unsigned char val;
1da177e4 LT	132
	133	hysdn_net_release(card); /* first release the net device if existing */
	134	#ifdef CONFIG_HYSDN_CAPI
	135	hycapi_capi_stop(card);
	136	#endif /* CONFIG_HYSDN_CAPI */
0d9ba869	137	spin_lock_irqsave(&card->hysdn_lock, flags);
1da177e4 LT	138	val = bytein(card->iobase + PCI9050_INTR_REG); /* get actual value */
	139	val &= ~(PCI9050_INTR_REG_ENPCI \| PCI9050_INTR_REG_EN1); /* mask irq */
	140	byteout(card->iobase + PCI9050_INTR_REG, val);
	141	card->irq_enabled = 0;
	142	byteout(card->iobase + PCI9050_USER_IO, PCI9050_E1_RESET); /* reset E1 processor */
	143	card->state = CARD_STATE_UNUSED;
	144	card->err_log_state = ERRLOG_STATE_OFF; /* currently no log active */
	145
0d9ba869	146	spin_unlock_irqrestore(&card->hysdn_lock, flags);
1da177e4 LT	147	} /* ergo_stopcard */
	148
	149	/**************************************************************************/
	150	/* enable or disable the cards error log. The event is queued if possible */
	151	/**************************************************************************/
	152	static void
475be4d8	153	ergo_set_errlog_state(hysdn_card *card, int on)
1da177e4	154	{
c721bcce	155	unsigned long flags;
1da177e4 LT	156
	157	if (card->state != CARD_STATE_RUN) {
	158	card->err_log_state = ERRLOG_STATE_OFF; /* must be off */
	159	return;
	160	}
0d9ba869	161	spin_lock_irqsave(&card->hysdn_lock, flags);
1da177e4 LT	162
	163	if (((card->err_log_state == ERRLOG_STATE_OFF) && !on) \|\|
	164	((card->err_log_state == ERRLOG_STATE_ON) && on)) {
0d9ba869	165	spin_unlock_irqrestore(&card->hysdn_lock, flags);
1da177e4 LT	166	return; /* nothing to do */
	167	}
	168	if (on)
	169	card->err_log_state = ERRLOG_STATE_START; /* request start */
	170	else
	171	card->err_log_state = ERRLOG_STATE_STOP; /* request stop */
	172
0d9ba869	173	spin_unlock_irqrestore(&card->hysdn_lock, flags);
1da177e4 LT	174	schedule_work(&card->irq_queue);
	175	} /* ergo_set_errlog_state */
	176
	177	/******************************************/
	178	/* test the cards RAM and return 0 if ok. */
	179	/******************************************/
	180	static const char TestText[36] = "This Message is filler, why read it";
	181
	182	static int
475be4d8	183	ergo_testram(hysdn_card *card)
1da177e4 LT	184	{
	185	tErgDpram *dpr = card->dpram;
	186
	187	memset(dpr->TrapTable, 0, sizeof(dpr->TrapTable)); /* clear all Traps */
	188	dpr->ToHyInt = 1; /* E1 INTR state forced */
	189
	190	memcpy(&dpr->ToHyBuf[ERG_TO_HY_BUF_SIZE - sizeof(TestText)], TestText,
	191	sizeof(TestText));
	192	if (memcmp(&dpr->ToHyBuf[ERG_TO_HY_BUF_SIZE - sizeof(TestText)], TestText,
	193	sizeof(TestText)))
	194	return (-1);
	195
	196	memcpy(&dpr->ToPcBuf[ERG_TO_PC_BUF_SIZE - sizeof(TestText)], TestText,
	197	sizeof(TestText));
	198	if (memcmp(&dpr->ToPcBuf[ERG_TO_PC_BUF_SIZE - sizeof(TestText)], TestText,
	199	sizeof(TestText)))
	200	return (-1);
	201
	202	return (0);
	203	} /* ergo_testram */
	204
	205	/*****************************************************************************/
	206	/* this function is intended to write stage 1 boot image to the cards buffer */
	207	/* this is done in two steps. First the 1024 hi-words are written (offs=0), */
	208	/* then the 1024 lo-bytes are written. The remaining DPRAM is cleared, the */
	209	/* PCI-write-buffers flushed and the card is taken out of reset. */
	210	/* The function then waits for a reaction of the E1 processor or a timeout. */
	211	/* Negative return values are interpreted as errors. */
	212	/*****************************************************************************/
	213	static int
c721bcce	214	ergo_writebootimg(struct HYSDN_CARD card, unsigned char buf,
475be4d8	215	unsigned long offs)
1da177e4	216	{
c721bcce	217	unsigned char *dst;
1da177e4 LT	218	tErgDpram *dpram;
1da177e4 LT	219	int cnt = (BOOT_IMG_SIZE >> 2); /* number of words to move and swap (byte order!) */
475be4d8	220
1da177e4 LT	221	if (card->debug_flags & LOG_POF_CARD)
	222	hysdn_addlog(card, "ERGO: write bootldr offs=0x%lx ", offs);
	223
	224	dst = card->dpram; /* pointer to start of DPRAM */
	225	dst += (offs + ERG_DPRAM_FILL_SIZE); /* offset in the DPRAM */
	226	while (cnt--) {
	227	dst++ = (buf + 1); /* high byte */
	228	dst++ = buf; /* low byte */
	229	dst += 2; /* point to next longword */
	230	buf += 2; /* buffer only filled with words */
	231	}
	232
	233	/* if low words (offs = 2) have been written, clear the rest of the DPRAM, */
	234	/* flush the PCI-write-buffer and take the E1 out of reset */
	235	if (offs) {
	236	memset(card->dpram, 0, ERG_DPRAM_FILL_SIZE); /* fill the DPRAM still not cleared */
	237	dpram = card->dpram; /* get pointer to dpram structure */
	238	dpram->ToHyNoDpramErrLog = 0xFF; /* write a dpram register */
	239	while (!dpram->ToHyNoDpramErrLog); /* reread volatile register to flush PCI */
	240
	241	byteout(card->iobase + PCI9050_USER_IO, PCI9050_E1_RUN); /* start E1 processor */
	242	/* the interrupts are still masked */
	243
1da177e4 LT	244	msleep_interruptible(20); /* Timeout 20ms */
	245
	246	if (((tDpramBootSpooler *) card->dpram)->Len != DPRAM_SPOOLER_DATA_SIZE) {
	247	if (card->debug_flags & LOG_POF_CARD)
	248	hysdn_addlog(card, "ERGO: write bootldr no answer");
	249	return (-ERR_BOOTIMG_FAIL);
	250	}
	251	} /* start_boot_img */
	252	return (0); /* successful */
	253	} /* ergo_writebootimg */
	254
	255	/********************************************************************************/
	256	/* ergo_writebootseq writes the buffer containing len bytes to the E1 processor */
	257	/* using the boot spool mechanism. If everything works fine 0 is returned. In */
	258	/* case of errors a negative error value is returned. */
	259	/********************************************************************************/
	260	static int
c721bcce	261	ergo_writebootseq(struct HYSDN_CARD card, unsigned char buf, int len)
1da177e4 LT	262	{
1da177e4 LT	263	tDpramBootSpooler sp = (tDpramBootSpooler ) card->dpram;
c721bcce AM	264	unsigned char *dst;
c721bcce AM	265	unsigned char buflen;
1da177e4	266	int nr_write;
c721bcce AM	267	unsigned char tmp_rdptr;
c721bcce AM	268	unsigned char wr_mirror;
1da177e4 LT	269	int i;
	270
	271	if (card->debug_flags & LOG_POF_CARD)
	272	hysdn_addlog(card, "ERGO: write boot seq len=%d ", len);
	273
	274	dst = sp->Data; /* point to data in spool structure */
	275	buflen = sp->Len; /* maximum len of spooled data */
	276	wr_mirror = sp->WrPtr; /* only once read */
1da177e4 LT	277
	278	/* try until all bytes written or error */
	279	i = 0x1000; /* timeout value */
	280	while (len) {
	281
	282	/* first determine the number of bytes that may be buffered */
	283	do {
	284	tmp_rdptr = sp->RdPtr; /* first read the pointer */
	285	i--; /* decrement timeout */
	286	} while (i && (tmp_rdptr != sp->RdPtr)); /* wait for stable pointer */
	287
	288	if (!i) {
	289	if (card->debug_flags & LOG_POF_CARD)
	290	hysdn_addlog(card, "ERGO: write boot seq timeout");
	291	return (-ERR_BOOTSEQ_FAIL); /* value not stable -> timeout */
	292	}
	293	if ((nr_write = tmp_rdptr - wr_mirror - 1) < 0)
	294	nr_write += buflen; /* now we got number of free bytes - 1 in buffer */
	295
	296	if (!nr_write)
	297	continue; /* no free bytes in buffer */
	298
	299	if (nr_write > len)
	300	nr_write = len; /* limit if last few bytes */
	301	i = 0x1000; /* reset timeout value */
	302
	303	/* now we know how much bytes we may put in the puffer */
	304	len -= nr_write; /* we savely could adjust len before output */
	305	while (nr_write--) {
	306	(dst + wr_mirror) = buf++; /* output one byte */
	307	if (++wr_mirror >= buflen)
	308	wr_mirror = 0;
	309	sp->WrPtr = wr_mirror; /* announce the next byte to E1 */
	310	} /* while (nr_write) */
	311
	312	} /* while (len) */
	313	return (0);
	314	} /* ergo_writebootseq */
	315
	316	/***********************************************************************************/
	317	/* ergo_waitpofready waits for a maximum of 10 seconds for the completition of the */
	318	/* boot process. If the process has been successful 0 is returned otherwise a */
	319	/* negative error code is returned. */
	320	/***********************************************************************************/
	321	static int
	322	ergo_waitpofready(struct HYSDN_CARD *card)
	323	{
	324	tErgDpram dpr = card->dpram; / pointer to DPRAM structure */
	325	int timecnt = 10000 / 50; /* timeout is 10 secs max. */
c721bcce	326	unsigned long flags;
1da177e4 LT	327	int msg_size;
	328	int i;
	329
	330	if (card->debug_flags & LOG_POF_CARD)
	331	hysdn_addlog(card, "ERGO: waiting for pof ready");
	332	while (timecnt--) {
	333	/* wait until timeout */
	334
	335	if (dpr->ToPcFlag) {
	336	/* data has arrived */
	337
	338	if ((dpr->ToPcChannel != CHAN_SYSTEM) \|\|
	339	(dpr->ToPcSize < MIN_RDY_MSG_SIZE) \|\|
	340	(dpr->ToPcSize > MAX_RDY_MSG_SIZE) \|\|
c721bcce	341	(((unsigned long ) dpr->ToPcBuf) != RDY_MAGIC))
1da177e4 LT	342	break; /* an error occurred */
	343
	344	/* Check for additional data delivered during SysReady */
	345	msg_size = dpr->ToPcSize - RDY_MAGIC_SIZE;
	346	if (msg_size > 0)
	347	if (EvalSysrTokData(card, dpr->ToPcBuf + RDY_MAGIC_SIZE, msg_size))
	348	break;
	349
	350	if (card->debug_flags & LOG_POF_RECORD)
	351	hysdn_addlog(card, "ERGO: pof boot success");
0d9ba869	352	spin_lock_irqsave(&card->hysdn_lock, flags);
1da177e4 LT	353
	354	card->state = CARD_STATE_RUN; /* now card is running */
	355	/* enable the cards interrupt */
	356	byteout(card->iobase + PCI9050_INTR_REG,
	357	bytein(card->iobase + PCI9050_INTR_REG) \|
475be4d8	358	(PCI9050_INTR_REG_ENPCI \| PCI9050_INTR_REG_EN1));
1da177e4 LT	359	card->irq_enabled = 1; /* we are ready to receive interrupts */
	360
	361	dpr->ToPcFlag = 0; /* reset data indicator */
	362	dpr->ToHyInt = 1;
	363	dpr->ToPcInt = 1; /* interrupt to E1 for all cards */
	364
0d9ba869	365	spin_unlock_irqrestore(&card->hysdn_lock, flags);
475be4d8 JP	366	if ((hynet_enable & (1 << card->myid))
475be4d8 JP	367	&& (i = hysdn_net_create(card)))
1da177e4 LT	368	{
	369	ergo_stopcard(card);
	370	card->state = CARD_STATE_BOOTERR;
	371	return (i);
	372	}
	373	#ifdef CONFIG_HYSDN_CAPI
475be4d8	374	if ((i = hycapi_capi_create(card))) {
1da177e4 LT	375	printk(KERN_WARNING "HYSDN: failed to create capi-interface.\n");
	376	}
	377	#endif /* CONFIG_HYSDN_CAPI */
	378	return (0); /* success */
	379	} /* data has arrived */
1da177e4 LT	380	msleep_interruptible(50); /* Timeout 50ms */
	381	} /* wait until timeout */
	382
	383	if (card->debug_flags & LOG_POF_CARD)
	384	hysdn_addlog(card, "ERGO: pof boot ready timeout");
	385	return (-ERR_POF_TIMEOUT);
	386	} /* ergo_waitpofready */
	387
	388
	389
	390	/************************************************************************************/
	391	/* release the cards hardware. Before releasing do a interrupt disable and hardware */
	392	/* reset. Also unmap dpram. */
	393	/* Use only during module release. */
	394	/************************************************************************************/
	395	static void
475be4d8	396	ergo_releasehardware(hysdn_card *card)
1da177e4 LT	397	{
	398	ergo_stopcard(card); /* first stop the card if not already done */
	399	free_irq(card->irq, card); /* release interrupt */
	400	release_region(card->iobase + PCI9050_INTR_REG, 1); /* release all io ports */
	401	release_region(card->iobase + PCI9050_USER_IO, 1);
fca4edb4	402	iounmap(card->dpram);
1da177e4 LT	403	card->dpram = NULL; /* release shared mem */
	404	} /* ergo_releasehardware */
	405
	406
	407	/*********************************************************************************/
	408	/* acquire the needed hardware ports and map dpram. If an error occurs a nonzero */
	409	/* value is returned. */
	410	/* Use only during module init. */
	411	/*********************************************************************************/
	412	int
475be4d8	413	ergo_inithardware(hysdn_card *card)
1da177e4	414	{
475be4d8	415	if (!request_region(card->iobase + PCI9050_INTR_REG, 1, "HYSDN"))
1da177e4 LT	416	return (-1);
	417	if (!request_region(card->iobase + PCI9050_USER_IO, 1, "HYSDN")) {
	418	release_region(card->iobase + PCI9050_INTR_REG, 1);
	419	return (-1); /* ports already in use */
	420	}
	421	card->memend = card->membase + ERG_DPRAM_PAGE_SIZE - 1;
	422	if (!(card->dpram = ioremap(card->membase, ERG_DPRAM_PAGE_SIZE))) {
	423	release_region(card->iobase + PCI9050_INTR_REG, 1);
	424	release_region(card->iobase + PCI9050_USER_IO, 1);
	425	return (-1);
	426	}
	427
	428	ergo_stopcard(card); /* disable interrupts */
9ba02bec	429	if (request_irq(card->irq, ergo_interrupt, IRQF_SHARED, "HYSDN", card)) {
1da177e4 LT	430	ergo_releasehardware(card); /* return the acquired hardware */
	431	return (-1);
	432	}
	433	/* success, now setup the function pointers */
	434	card->stopcard = ergo_stopcard;
	435	card->releasehardware = ergo_releasehardware;
	436	card->testram = ergo_testram;
	437	card->writebootimg = ergo_writebootimg;
	438	card->writebootseq = ergo_writebootseq;
	439	card->waitpofready = ergo_waitpofready;
	440	card->set_errlog_state = ergo_set_errlog_state;
3e577a80	441	INIT_WORK(&card->irq_queue, ergo_irq_bh);
2bd7e20e	442	spin_lock_init(&card->hysdn_lock);
1da177e4 LT	443
	444	return (0);
	445	} /* ergo_inithardware */