drivers/isdn/hisax/mic.c

   1 /* $Id: mic.c,v 1.9 2000/06/26 08:59:14 keil Exp $
   2  *
   3  * mic.c  low level stuff for mic cards
   4  *
   5  * Copyright (C) 1997
   6  *
   7  * Author  Stephan von Krawczynski <skraw@ithnet.com>
   8  *
   9  * This file is (c) under GNU PUBLIC LICENSE
  10  *
  11  */
  12
  13 #define __NO_VERSION__
  14 #include "hisax.h"
  15 #include "isac.h"
  16 #include "hscx.h"
  17 #include "isdnl1.h"
  18
  19 extern const char *CardType[];
  20
  21 const char *mic_revision = "$Revision: 1.9 $";
  22
  23 #define byteout(addr,val) outb(val,addr)
  24 #define bytein(addr) inb(addr)
  25
  26 #define MIC_ISAC        2
  27 #define MIC_HSCX        1
  28 #define MIC_ADR         7
  29
  30 /* CARD_ADR (Write) */
  31 #define MIC_RESET      0x3      /* same as DOS driver */
  32
  33 static inline u_char
  34 readreg(unsigned int ale, unsigned int adr, u_char off)
  35 {
  36         register u_char ret;
  37         long flags;
  38
  39         save_flags(flags);
  40         cli();
  41         byteout(ale, off);
  42         ret = bytein(adr);
  43         restore_flags(flags);
  44
  45         return (ret);
  46 }
  47
  48 static inline void
  49 readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  50 {
  51         /* fifo read without cli because it's allready done  */
  52
  53         byteout(ale, off);
  54         insb(adr, data, size);
  55 }
  56
  57
  58 static inline void
  59 writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
  60 {
  61         long flags;
  62
  63         save_flags(flags);
  64         cli();
  65         byteout(ale, off);
  66         byteout(adr, data);
  67         restore_flags(flags);
  68 }
  69
  70 static inline void
  71 writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  72 {
  73         /* fifo write without cli because it's allready done  */
  74         byteout(ale, off);
  75         outsb(adr, data, size);
  76 }
  77
  78 /* Interface functions */
  79
  80 static u_char
  81 ReadISAC(struct IsdnCardState *cs, u_char offset)
  82 {
  83         return (readreg(cs->hw.mic.adr, cs->hw.mic.isac, offset));
  84 }
  85
  86 static void
  87 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
  88 {
  89         writereg(cs->hw.mic.adr, cs->hw.mic.isac, offset, value);
  90 }
  91
  92 static void
  93 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  94 {
  95         readfifo(cs->hw.mic.adr, cs->hw.mic.isac, 0, data, size);
  96 }
  97
  98 static void
  99 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 100 {
 101         writefifo(cs->hw.mic.adr, cs->hw.mic.isac, 0, data, size);
 102 }
 103
 104 static u_char
 105 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 106 {
 107         return (readreg(cs->hw.mic.adr,
 108                         cs->hw.mic.hscx, offset + (hscx ? 0x40 : 0)));
 109 }
 110
 111 static void
 112 WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
 113 {
 114         writereg(cs->hw.mic.adr,
 115                  cs->hw.mic.hscx, offset + (hscx ? 0x40 : 0), value);
 116 }
 117
 118 /*
 119  * fast interrupt HSCX stuff goes here
 120  */
 121
 122 #define READHSCX(cs, nr, reg) readreg(cs->hw.mic.adr, \
 123                 cs->hw.mic.hscx, reg + (nr ? 0x40 : 0))
 124 #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.mic.adr, \
 125                 cs->hw.mic.hscx, reg + (nr ? 0x40 : 0), data)
 126
 127 #define READHSCXFIFO(cs, nr, ptr, cnt) readfifo(cs->hw.mic.adr, \
 128                 cs->hw.mic.hscx, (nr ? 0x40 : 0), ptr, cnt)
 129
 130 #define WRITEHSCXFIFO(cs, nr, ptr, cnt) writefifo(cs->hw.mic.adr, \
 131                 cs->hw.mic.hscx, (nr ? 0x40 : 0), ptr, cnt)
 132
 133 #include "hscx_irq.c"
 134
 135 static void
 136 mic_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 137 {
 138         struct IsdnCardState *cs = dev_id;
 139         u_char val;
 140
 141         if (!cs) {
 142                 printk(KERN_WARNING "mic: Spurious interrupt!\n");
 143                 return;
 144         }
 145         val = readreg(cs->hw.mic.adr, cs->hw.mic.hscx, HSCX_ISTA + 0x40);
 146       Start_HSCX:
 147         if (val)
 148                 hscx_int_main(cs, val);
 149         val = readreg(cs->hw.mic.adr, cs->hw.mic.isac, ISAC_ISTA);
 150       Start_ISAC:
 151         if (val)
 152                 isac_interrupt(cs, val);
 153         val = readreg(cs->hw.mic.adr, cs->hw.mic.hscx, HSCX_ISTA + 0x40);
 154         if (val) {
 155                 if (cs->debug & L1_DEB_HSCX)
 156                         debugl1(cs, "HSCX IntStat after IntRoutine");
 157                 goto Start_HSCX;
 158         }
 159         val = readreg(cs->hw.mic.adr, cs->hw.mic.isac, ISAC_ISTA);
 160         if (val) {
 161                 if (cs->debug & L1_DEB_ISAC)
 162                         debugl1(cs, "ISAC IntStat after IntRoutine");
 163                 goto Start_ISAC;
 164         }
 165         writereg(cs->hw.mic.adr, cs->hw.mic.hscx, HSCX_MASK, 0xFF);
 166         writereg(cs->hw.mic.adr, cs->hw.mic.hscx, HSCX_MASK + 0x40, 0xFF);
 167         writereg(cs->hw.mic.adr, cs->hw.mic.isac, ISAC_MASK, 0xFF);
 168         writereg(cs->hw.mic.adr, cs->hw.mic.isac, ISAC_MASK, 0x0);
 169         writereg(cs->hw.mic.adr, cs->hw.mic.hscx, HSCX_MASK, 0x0);
 170         writereg(cs->hw.mic.adr, cs->hw.mic.hscx, HSCX_MASK + 0x40, 0x0);
 171 }
 172
 173 void
 174 release_io_mic(struct IsdnCardState *cs)
 175 {
 176         int bytecnt = 8;
 177
 178         if (cs->hw.mic.cfg_reg)
 179                 release_region(cs->hw.mic.cfg_reg, bytecnt);
 180 }
 181
 182 static int
 183 mic_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 184 {
 185         switch (mt) {
 186                 case CARD_RESET:
 187                         return(0);
 188                 case CARD_RELEASE:
 189                         release_io_mic(cs);
 190                         return(0);
 191                 case CARD_INIT:
 192                         inithscx(cs); /* /RTSA := ISAC RST */
 193                         inithscxisac(cs, 3);
 194                         return(0);
 195                 case CARD_TEST:
 196                         return(0);
 197         }
 198         return(0);
 199 }
 200
 201 __initfunc(int
 202 setup_mic(struct IsdnCard *card))
 203 {
 204         int bytecnt;
 205         struct IsdnCardState *cs = card->cs;
 206         char tmp[64];
 207
 208         strcpy(tmp, mic_revision);
 209         printk(KERN_INFO "HiSax: mic driver Rev. %s\n", HiSax_getrev(tmp));
 210         if (cs->typ != ISDN_CTYPE_MIC)
 211                 return (0);
 212
 213         bytecnt = 8;
 214         cs->hw.mic.cfg_reg = card->para[1];
 215         cs->irq = card->para[0];
 216         cs->hw.mic.adr = cs->hw.mic.cfg_reg + MIC_ADR;
 217         cs->hw.mic.isac = cs->hw.mic.cfg_reg + MIC_ISAC;
 218         cs->hw.mic.hscx = cs->hw.mic.cfg_reg + MIC_HSCX;
 219
 220         if (check_region((cs->hw.mic.cfg_reg), bytecnt)) {
 221                 printk(KERN_WARNING
 222                        "HiSax: %s config port %x-%x already in use\n",
 223                        CardType[card->typ],
 224                        cs->hw.mic.cfg_reg,
 225                        cs->hw.mic.cfg_reg + bytecnt);
 226                 return (0);
 227         } else {
 228                 request_region(cs->hw.mic.cfg_reg, bytecnt, "mic isdn");
 229         }
 230
 231         printk(KERN_INFO
 232                "mic: defined at 0x%x IRQ %d\n",
 233                cs->hw.mic.cfg_reg,
 234                cs->irq);
 235         cs->readisac = &ReadISAC;
 236         cs->writeisac = &WriteISAC;
 237         cs->readisacfifo = &ReadISACfifo;
 238         cs->writeisacfifo = &WriteISACfifo;
 239         cs->BC_Read_Reg = &ReadHSCX;
 240         cs->BC_Write_Reg = &WriteHSCX;
 241         cs->BC_Send_Data = &hscx_fill_fifo;
 242         cs->cardmsg = &mic_card_msg;
 243         cs->irq_func = &mic_interrupt;
 244         ISACVersion(cs, "mic:");
 245         if (HscxVersion(cs, "mic:")) {
 246                 printk(KERN_WARNING
 247                     "mic: wrong HSCX versions check IO address\n");
 248                 release_io_mic(cs);
 249                 return (0);
 250         }
 251         return (1);
 252 }