446 lines
16 KiB
C
446 lines
16 KiB
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 */
|