boardergo.c

Go to the documentation of this file.

/* $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 ([email protected]) for Hypercope GmbH
 * Copyright 1999 by Werner Cornelius ([email protected])
 *
 * 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 */