2005-04-17 06:20:36 +08:00
|
|
|
/* $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/sched.h>
|
|
|
|
#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
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
ergo_interrupt(int intno, void *dev_id)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
hysdn_card *card = dev_id; /* parameter from irq */
|
|
|
|
tErgDpram *dpr;
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned long flags;
|
|
|
|
unsigned char volatile b;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!card)
|
|
|
|
return IRQ_NONE; /* error -> spurious interrupt */
|
|
|
|
if (!card->irq_enabled)
|
|
|
|
return IRQ_NONE; /* other device interrupting or irq switched off */
|
|
|
|
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_lock_irqsave(&card->hysdn_lock, flags); /* no further irqs allowed */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!(bytein(card->iobase + PCI9050_INTR_REG) & PCI9050_INTR_REG_STAT1)) {
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags); /* restore old state */
|
2005-04-17 06:20:36 +08:00
|
|
|
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);
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
} /* ergo_interrupt */
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
/* ergo_irq_bh is the function called by the immediate kernel task list after */
|
|
|
|
/* being activated with queue_task and no interrupts active. 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(hysdn_card * card)
|
|
|
|
{
|
|
|
|
tErgDpram *dpr;
|
|
|
|
int again;
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (card->state != CARD_STATE_RUN)
|
|
|
|
return; /* invalid call */
|
|
|
|
|
|
|
|
dpr = card->dpram; /* point to DPRAM */
|
|
|
|
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_lock_irqsave(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (card->hw_lock) {
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags); /* hardware currently unavailable */
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
card->hw_lock = 1; /* we now lock the hardware */
|
|
|
|
|
|
|
|
do {
|
|
|
|
sti(); /* reenable other ints */
|
|
|
|
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 */
|
|
|
|
cli(); /* no further ints */
|
|
|
|
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 */
|
|
|
|
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
} /* ergo_irq_bh */
|
|
|
|
|
|
|
|
|
|
|
|
/*********************************************************/
|
|
|
|
/* stop the card (hardware reset) and disable interrupts */
|
|
|
|
/*********************************************************/
|
|
|
|
static void
|
|
|
|
ergo_stopcard(hysdn_card * card)
|
|
|
|
{
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned long flags;
|
|
|
|
unsigned char val;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
hysdn_net_release(card); /* first release the net device if existing */
|
|
|
|
#ifdef CONFIG_HYSDN_CAPI
|
|
|
|
hycapi_capi_stop(card);
|
|
|
|
#endif /* CONFIG_HYSDN_CAPI */
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_lock_irqsave(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
|
|
|
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
} /* 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)
|
|
|
|
{
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (card->state != CARD_STATE_RUN) {
|
|
|
|
card->err_log_state = ERRLOG_STATE_OFF; /* must be off */
|
|
|
|
return;
|
|
|
|
}
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_lock_irqsave(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (((card->err_log_state == ERRLOG_STATE_OFF) && !on) ||
|
|
|
|
((card->err_log_state == ERRLOG_STATE_ON) && on)) {
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
|
|
|
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
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
|
2006-03-25 19:07:04 +08:00
|
|
|
ergo_writebootimg(struct HYSDN_CARD *card, unsigned char *buf,
|
|
|
|
unsigned long offs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned char *dst;
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
|
|
|
|
|
|
|
sti();
|
|
|
|
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
|
2006-03-25 19:07:04 +08:00
|
|
|
ergo_writebootseq(struct HYSDN_CARD *card, unsigned char *buf, int len)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
tDpramBootSpooler *sp = (tDpramBootSpooler *) card->dpram;
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned char *dst;
|
|
|
|
unsigned char buflen;
|
2005-04-17 06:20:36 +08:00
|
|
|
int nr_write;
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned char tmp_rdptr;
|
|
|
|
unsigned char wr_mirror;
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
|
|
|
sti();
|
|
|
|
|
|
|
|
/* 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. */
|
2006-03-25 19:07:04 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
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) ||
|
2006-03-25 19:07:04 +08:00
|
|
|
((*(unsigned long *) dpr->ToPcBuf) != RDY_MAGIC))
|
2005-04-17 06:20:36 +08:00
|
|
|
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");
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_lock_irqsave(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
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 */
|
|
|
|
|
2006-10-17 15:10:36 +08:00
|
|
|
spin_unlock_irqrestore(&card->hysdn_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
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 */
|
|
|
|
sti();
|
|
|
|
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);
|
|
|
|
vfree(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 */
|
2006-07-02 10:29:36 +08:00
|
|
|
if (request_irq(card->irq, ergo_interrupt, IRQF_SHARED, "HYSDN", card)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
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, (void *) (void *) ergo_irq_bh, card);
|
2006-10-17 15:10:36 +08:00
|
|
|
card->hysdn_lock = SPIN_LOCK_UNLOCKED;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
} /* ergo_inithardware */
|