cregit-Linux how code gets into the kernel

Release 4.14 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; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)11876.62%120.00%
Amol Lad1811.69%120.00%
Andrew Morton1711.04%240.00%
Ingo Molnar10.65%120.00%
Total154100.00%5100.00%

/* 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); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)19584.42%125.00%
Amol Lad187.79%125.00%
Al Viro166.93%125.00%
Andrew Morton20.87%125.00%
Total231100.00%4100.00%

/* 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); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)10386.55%250.00%
Amol Lad1210.08%125.00%
Andrew Morton43.36%125.00%
Total119100.00%4100.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) { 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); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)10282.93%125.00%
Amol Lad1814.63%125.00%
Andrew Morton21.63%125.00%
Ingo Molnar10.81%125.00%
Total123100.00%4100.00%

/* 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); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)155100.00%1100.00%
Total155100.00%1100.00%

/* 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 */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)20996.31%125.00%
Andrew Morton62.76%125.00%
Linus Torvalds10.46%125.00%
Maximilian Attems10.46%125.00%
Total217100.00%4100.00%

/* 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); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)24496.06%150.00%
Andrew Morton103.94%150.00%
Total254100.00%2100.00%

/* 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); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)31091.18%228.57%
Linus Torvalds133.82%228.57%
Amol Lad123.53%114.29%
Andrew Morton41.18%114.29%
Maximilian Attems10.29%114.29%
Total340100.00%7100.00%

/* 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 */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)6298.41%150.00%
Amol Lad11.59%150.00%
Total63100.00%2100.00%

/* 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); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)17676.52%228.57%
William Stinson4017.39%114.29%
Ingo Molnar52.17%114.29%
Thomas Gleixner52.17%228.57%
Amol Lad41.74%114.29%
Total230100.00%7100.00%

/* ergo_inithardware */

Overall Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)176888.53%315.00%
Amol Lad834.16%210.00%
Andrew Morton452.25%210.00%
William Stinson402.00%15.00%
Linus Torvalds221.10%525.00%
Al Viro160.80%15.00%
Ingo Molnar70.35%15.00%
Thomas Gleixner50.25%210.00%
Maximilian Attems50.25%15.00%
Mark Asselstine50.25%15.00%
Joe Perches10.05%15.00%
Total1997100.00%20100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.