drivers/isdn/hisax/avm_a1.c

   1 /* $Id: avm_a1.c,v 2.13 2000/11/24 17:05:37 kai Exp $
   2  *
   3  * avm_a1.c     low level stuff for AVM A1 (Fritz) isdn cards
   4  *
   5  * Author       Karsten Keil (keil@isdn4linux.de)
   6  *
   7  * This file is (c) under GNU PUBLIC LICENSE
   8  *
   9  */
  10 #define __NO_VERSION__
  11 #include <linux/init.h>
  12 #include "hisax.h"
  13 #include "isac.h"
  14 #include "hscx.h"
  15 #include "isdnl1.h"
  16
  17 extern const char *CardType[];
  18 static const char *avm_revision = "$Revision: 2.13 $";
  19
  20 #define  AVM_A1_STAT_ISAC       0x01
  21 #define  AVM_A1_STAT_HSCX       0x02
  22 #define  AVM_A1_STAT_TIMER      0x04
  23
  24 #define byteout(addr,val) outb(val,addr)
  25 #define bytein(addr) inb(addr)
  26
  27 static inline u_char
  28 readreg(unsigned int adr, u_char off)
  29 {
  30         return (bytein(adr + off));
  31 }
  32
  33 static inline void
  34 writereg(unsigned int adr, u_char off, u_char data)
  35 {
  36         byteout(adr + off, data);
  37 }
  38
  39
  40 static inline void
  41 read_fifo(unsigned int adr, u_char * data, int size)
  42 {
  43         insb(adr, data, size);
  44 }
  45
  46 static void
  47 write_fifo(unsigned int adr, u_char * data, int size)
  48 {
  49         outsb(adr, data, size);
  50 }
  51
  52 /* Interface functions */
  53
  54 static u_char
  55 ReadISAC(struct IsdnCardState *cs, u_char offset)
  56 {
  57         return (readreg(cs->hw.avm.isac, offset));
  58 }
  59
  60 static void
  61 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
  62 {
  63         writereg(cs->hw.avm.isac, offset, value);
  64 }
  65
  66 static void
  67 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  68 {
  69         read_fifo(cs->hw.avm.isacfifo, data, size);
  70 }
  71
  72 static void
  73 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  74 {
  75         write_fifo(cs->hw.avm.isacfifo, data, size);
  76 }
  77
  78 static u_char
  79 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
  80 {
  81         return (readreg(cs->hw.avm.hscx[hscx], offset));
  82 }
  83
  84 static void
  85 WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
  86 {
  87         writereg(cs->hw.avm.hscx[hscx], offset, value);
  88 }
  89
  90 /*
  91  * fast interrupt HSCX stuff goes here
  92  */
  93
  94 #define READHSCX(cs, nr, reg) readreg(cs->hw.avm.hscx[nr], reg)
  95 #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.avm.hscx[nr], reg, data)
  96 #define READHSCXFIFO(cs, nr, ptr, cnt) read_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
  97 #define WRITEHSCXFIFO(cs, nr, ptr, cnt) write_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
  98
  99 #include "hscx_irq.c"
 100
 101 static void
 102 avm_a1_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 103 {
 104         struct IsdnCardState *cs = dev_id;
 105         u_char val, sval;
 106
 107         if (!cs) {
 108                 printk(KERN_WARNING "AVM A1: Spurious interrupt!\n");
 109                 return;
 110         }
 111         while (((sval = bytein(cs->hw.avm.cfg_reg)) & 0xf) != 0x7) {
 112                 if (!(sval & AVM_A1_STAT_TIMER)) {
 113                         byteout(cs->hw.avm.cfg_reg, 0x1E);
 114                         sval = bytein(cs->hw.avm.cfg_reg);
 115                 } else if (cs->debug & L1_DEB_INTSTAT)
 116                         debugl1(cs, "avm IntStatus %x", sval);
 117                 if (!(sval & AVM_A1_STAT_HSCX)) {
 118                         val = readreg(cs->hw.avm.hscx[1], HSCX_ISTA);
 119                         if (val)
 120                                 hscx_int_main(cs, val);
 121                 }
 122                 if (!(sval & AVM_A1_STAT_ISAC)) {
 123                         val = readreg(cs->hw.avm.isac, ISAC_ISTA);
 124                         if (val)
 125                                 isac_interrupt(cs, val);
 126                 }
 127         }
 128         writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0xFF);
 129         writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0xFF);
 130         writereg(cs->hw.avm.isac, ISAC_MASK, 0xFF);
 131         writereg(cs->hw.avm.isac, ISAC_MASK, 0x0);
 132         writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0x0);
 133         writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0x0);
 134 }
 135
 136 inline static void
 137 release_ioregs(struct IsdnCardState *cs, int mask)
 138 {
 139         release_region(cs->hw.avm.cfg_reg, 8);
 140         if (mask & 1)
 141                 release_region(cs->hw.avm.isac + 32, 32);
 142         if (mask & 2)
 143                 release_region(cs->hw.avm.isacfifo, 1);
 144         if (mask & 4)
 145                 release_region(cs->hw.avm.hscx[0] + 32, 32);
 146         if (mask & 8)
 147                 release_region(cs->hw.avm.hscxfifo[0], 1);
 148         if (mask & 0x10)
 149                 release_region(cs->hw.avm.hscx[1] + 32, 32);
 150         if (mask & 0x20)
 151                 release_region(cs->hw.avm.hscxfifo[1], 1);
 152 }
 153
 154 static int
 155 AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 156 {
 157         switch (mt) {
 158                 case CARD_RESET:
 159                         return(0);
 160                 case CARD_RELEASE:
 161                         release_ioregs(cs, 0x3f);
 162                         return(0);
 163                 case CARD_INIT:
 164                         inithscxisac(cs, 1);
 165                         byteout(cs->hw.avm.cfg_reg, 0x16);
 166                         byteout(cs->hw.avm.cfg_reg, 0x1E);
 167                         inithscxisac(cs, 2);
 168                         return(0);
 169                 case CARD_TEST:
 170                         return(0);
 171         }
 172         return(0);
 173 }
 174
 175 int __init
 176 setup_avm_a1(struct IsdnCard *card)
 177 {
 178         u_char val;
 179         struct IsdnCardState *cs = card->cs;
 180         long flags;
 181         char tmp[64];
 182
 183         strcpy(tmp, avm_revision);
 184         printk(KERN_INFO "HiSax: AVM driver Rev. %s\n", HiSax_getrev(tmp));
 185         if (cs->typ != ISDN_CTYPE_A1)
 186                 return (0);
 187
 188         cs->hw.avm.cfg_reg = card->para[1] + 0x1800;
 189         cs->hw.avm.isac = card->para[1] + 0x1400 - 0x20;
 190         cs->hw.avm.hscx[0] = card->para[1] + 0x400 - 0x20;
 191         cs->hw.avm.hscx[1] = card->para[1] + 0xc00 - 0x20;
 192         cs->hw.avm.isacfifo = card->para[1] + 0x1000;
 193         cs->hw.avm.hscxfifo[0] = card->para[1];
 194         cs->hw.avm.hscxfifo[1] = card->para[1] + 0x800;
 195         cs->irq = card->para[0];
 196         if (check_region((cs->hw.avm.cfg_reg), 8)) {
 197                 printk(KERN_WARNING
 198                        "HiSax: %s config port %x-%x already in use\n",
 199                        CardType[card->typ],
 200                        cs->hw.avm.cfg_reg,
 201                        cs->hw.avm.cfg_reg + 8);
 202                 return (0);
 203         } else {
 204                 request_region(cs->hw.avm.cfg_reg, 8, "avm cfg");
 205         }
 206         if (check_region((cs->hw.avm.isac + 32), 32)) {
 207                 printk(KERN_WARNING
 208                        "HiSax: %s isac ports %x-%x already in use\n",
 209                        CardType[cs->typ],
 210                        cs->hw.avm.isac + 32,
 211                        cs->hw.avm.isac + 64);
 212                 release_ioregs(cs, 0);
 213                 return (0);
 214         } else {
 215                 request_region(cs->hw.avm.isac + 32, 32, "HiSax isac");
 216         }
 217         if (check_region((cs->hw.avm.isacfifo), 1)) {
 218                 printk(KERN_WARNING
 219                        "HiSax: %s isac fifo port %x already in use\n",
 220                        CardType[cs->typ],
 221                        cs->hw.avm.isacfifo);
 222                 release_ioregs(cs, 1);
 223                 return (0);
 224         } else {
 225                 request_region(cs->hw.avm.isacfifo, 1, "HiSax isac fifo");
 226         }
 227         if (check_region((cs->hw.avm.hscx[0]) + 32, 32)) {
 228                 printk(KERN_WARNING
 229                        "HiSax: %s hscx A ports %x-%x already in use\n",
 230                        CardType[cs->typ],
 231                        cs->hw.avm.hscx[0] + 32,
 232                        cs->hw.avm.hscx[0] + 64);
 233                 release_ioregs(cs, 3);
 234                 return (0);
 235         } else {
 236                 request_region(cs->hw.avm.hscx[0] + 32, 32, "HiSax hscx A");
 237         }
 238         if (check_region(cs->hw.avm.hscxfifo[0], 1)) {
 239                 printk(KERN_WARNING
 240                        "HiSax: %s hscx A fifo port %x already in use\n",
 241                        CardType[cs->typ],
 242                        cs->hw.avm.hscxfifo[0]);
 243                 release_ioregs(cs, 7);
 244                 return (0);
 245         } else {
 246                 request_region(cs->hw.avm.hscxfifo[0], 1, "HiSax hscx A fifo");
 247         }
 248         if (check_region(cs->hw.avm.hscx[1] + 32, 32)) {
 249                 printk(KERN_WARNING
 250                        "HiSax: %s hscx B ports %x-%x already in use\n",
 251                        CardType[cs->typ],
 252                        cs->hw.avm.hscx[1] + 32,
 253                        cs->hw.avm.hscx[1] + 64);
 254                 release_ioregs(cs, 0xf);
 255                 return (0);
 256         } else {
 257                 request_region(cs->hw.avm.hscx[1] + 32, 32, "HiSax hscx B");
 258         }
 259         if (check_region(cs->hw.avm.hscxfifo[1], 1)) {
 260                 printk(KERN_WARNING
 261                        "HiSax: %s hscx B fifo port %x already in use\n",
 262                        CardType[cs->typ],
 263                        cs->hw.avm.hscxfifo[1]);
 264                 release_ioregs(cs, 0x1f);
 265                 return (0);
 266         } else {
 267                 request_region(cs->hw.avm.hscxfifo[1], 1, "HiSax hscx B fifo");
 268         }
 269         save_flags(flags);
 270         byteout(cs->hw.avm.cfg_reg, 0x0);
 271         sti();
 272         HZDELAY(HZ / 5 + 1);
 273         byteout(cs->hw.avm.cfg_reg, 0x1);
 274         HZDELAY(HZ / 5 + 1);
 275         byteout(cs->hw.avm.cfg_reg, 0x0);
 276         HZDELAY(HZ / 5 + 1);
 277         val = cs->irq;
 278         if (val == 9)
 279                 val = 2;
 280         byteout(cs->hw.avm.cfg_reg + 1, val);
 281         HZDELAY(HZ / 5 + 1);
 282         byteout(cs->hw.avm.cfg_reg, 0x0);
 283         HZDELAY(HZ / 5 + 1);
 284         restore_flags(flags);
 285
 286         val = bytein(cs->hw.avm.cfg_reg);
 287         printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
 288                cs->hw.avm.cfg_reg, val);
 289         val = bytein(cs->hw.avm.cfg_reg + 3);
 290         printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
 291                cs->hw.avm.cfg_reg + 3, val);
 292         val = bytein(cs->hw.avm.cfg_reg + 2);
 293         printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
 294                cs->hw.avm.cfg_reg + 2, val);
 295         val = bytein(cs->hw.avm.cfg_reg);
 296         printk(KERN_INFO "AVM A1: Byte at %x is %x\n",
 297                cs->hw.avm.cfg_reg, val);
 298
 299         printk(KERN_INFO
 300                "HiSax: %s config irq:%d cfg:0x%X\n",
 301                CardType[cs->typ], cs->irq,
 302                cs->hw.avm.cfg_reg);
 303         printk(KERN_INFO
 304                "HiSax: isac:0x%X/0x%X\n",
 305                cs->hw.avm.isac + 32, cs->hw.avm.isacfifo);
 306         printk(KERN_INFO
 307                "HiSax: hscx A:0x%X/0x%X  hscx B:0x%X/0x%X\n",
 308                cs->hw.avm.hscx[0] + 32, cs->hw.avm.hscxfifo[0],
 309                cs->hw.avm.hscx[1] + 32, cs->hw.avm.hscxfifo[1]);
 310
 311         cs->readisac = &ReadISAC;
 312         cs->writeisac = &WriteISAC;
 313         cs->readisacfifo = &ReadISACfifo;
 314         cs->writeisacfifo = &WriteISACfifo;
 315         cs->BC_Read_Reg = &ReadHSCX;
 316         cs->BC_Write_Reg = &WriteHSCX;
 317         cs->BC_Send_Data = &hscx_fill_fifo;
 318         cs->cardmsg = &AVM_card_msg;
 319         cs->irq_func = &avm_a1_interrupt;
 320         ISACVersion(cs, "AVM A1:");
 321         if (HscxVersion(cs, "AVM A1:")) {
 322                 printk(KERN_WARNING
 323                        "AVM A1: wrong HSCX versions check IO address\n");
 324                 release_ioregs(cs, 0x3f);
 325                 return (0);
 326         }
 327         return (1);
 328 }