git.oblomov.eu Git - linux-2.6/blob - drivers/isdn/hysdn/boardergo.c

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