drivers/isdn/hisax/teleint.c

   1 /* $Id: teleint.c,v 1.13 2000/06/26 08:59:14 keil Exp $
   2  *
   3  * teleint.c     low level stuff for TeleInt isdn cards
   4  *
   5  * Author     Karsten Keil (keil@isdn4linux.de)
   6  *
   7  * This file is (c) under GNU PUBLIC LICENSE
   8  *
   9  */
  10
  11 #define __NO_VERSION__
  12 #include "hisax.h"
  13 #include "isac.h"
  14 #include "hfc_2bs0.h"
  15 #include "isdnl1.h"
  16
  17 extern const char *CardType[];
  18
  19 const char *TeleInt_revision = "$Revision: 1.13 $";
  20
  21 #define byteout(addr,val) outb(val,addr)
  22 #define bytein(addr) inb(addr)
  23
  24 static inline u_char
  25 readreg(unsigned int ale, unsigned int adr, u_char off)
  26 {
  27         register u_char ret;
  28         int max_delay = 2000;
  29         long flags;
  30
  31         save_flags(flags);
  32         cli();
  33         byteout(ale, off);
  34         ret = HFC_BUSY & bytein(ale);
  35         while (ret && --max_delay)
  36                 ret = HFC_BUSY & bytein(ale);
  37         if (!max_delay) {
  38                 printk(KERN_WARNING "TeleInt Busy not inactive\n");
  39                 restore_flags(flags);
  40                 return (0);
  41         }
  42         ret = bytein(adr);
  43         restore_flags(flags);
  44         return (ret);
  45 }
  46
  47 static inline void
  48 readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  49 {
  50         register u_char ret;
  51         register int max_delay = 20000;
  52         register int i;
  53
  54         byteout(ale, off);
  55         for (i = 0; i<size; i++) {
  56                 ret = HFC_BUSY & bytein(ale);
  57                 while (ret && --max_delay)
  58                         ret = HFC_BUSY & bytein(ale);
  59                 if (!max_delay) {
  60                         printk(KERN_WARNING "TeleInt Busy not inactive\n");
  61                         return;
  62                 }
  63                 data[i] = bytein(adr);
  64         }
  65 }
  66
  67
  68 static inline void
  69 writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
  70 {
  71         register u_char ret;
  72         int max_delay = 2000;
  73         long flags;
  74
  75         save_flags(flags);
  76         cli();
  77         byteout(ale, off);
  78         ret = HFC_BUSY & bytein(ale);
  79         while (ret && --max_delay)
  80                 ret = HFC_BUSY & bytein(ale);
  81         if (!max_delay) {
  82                 printk(KERN_WARNING "TeleInt Busy not inactive\n");
  83                 restore_flags(flags);
  84                 return;
  85         }
  86         byteout(adr, data);
  87         restore_flags(flags);
  88 }
  89
  90 static inline void
  91 writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  92 {
  93         register u_char ret;
  94         register int max_delay = 20000;
  95         register int i;
  96
  97         /* fifo write without cli because it's allready done  */
  98         byteout(ale, off);
  99         for (i = 0; i<size; i++) {
 100                 ret = HFC_BUSY & bytein(ale);
 101                 while (ret && --max_delay)
 102                         ret = HFC_BUSY & bytein(ale);
 103                 if (!max_delay) {
 104                         printk(KERN_WARNING "TeleInt Busy not inactive\n");
 105                         return;
 106                 }
 107                 byteout(adr, data[i]);
 108         }
 109 }
 110
 111 /* Interface functions */
 112
 113 static u_char
 114 ReadISAC(struct IsdnCardState *cs, u_char offset)
 115 {
 116         cs->hw.hfc.cip = offset;
 117         return (readreg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, offset));
 118 }
 119
 120 static void
 121 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
 122 {
 123         cs->hw.hfc.cip = offset;
 124         writereg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, offset, value);
 125 }
 126
 127 static void
 128 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 129 {
 130         cs->hw.hfc.cip = 0;
 131         readfifo(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, 0, data, size);
 132 }
 133
 134 static void
 135 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 136 {
 137         cs->hw.hfc.cip = 0;
 138         writefifo(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, 0, data, size);
 139 }
 140
 141 static u_char
 142 ReadHFC(struct IsdnCardState *cs, int data, u_char reg)
 143 {
 144         register u_char ret;
 145
 146         if (data) {
 147                 cs->hw.hfc.cip = reg;
 148                 byteout(cs->hw.hfc.addr | 1, reg);
 149                 ret = bytein(cs->hw.hfc.addr);
 150                 if (cs->debug & L1_DEB_HSCX_FIFO && (data != 2))
 151                         debugl1(cs, "hfc RD %02x %02x", reg, ret);
 152         } else
 153                 ret = bytein(cs->hw.hfc.addr | 1);
 154         return (ret);
 155 }
 156
 157 static void
 158 WriteHFC(struct IsdnCardState *cs, int data, u_char reg, u_char value)
 159 {
 160         byteout(cs->hw.hfc.addr | 1, reg);
 161         cs->hw.hfc.cip = reg;
 162         if (data)
 163                 byteout(cs->hw.hfc.addr, value);
 164         if (cs->debug & L1_DEB_HSCX_FIFO && (data != 2))
 165                 debugl1(cs, "hfc W%c %02x %02x", data ? 'D' : 'C', reg, value);
 166 }
 167
 168 static void
 169 TeleInt_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 170 {
 171         struct IsdnCardState *cs = dev_id;
 172         u_char val;
 173
 174         if (!cs) {
 175                 printk(KERN_WARNING "TeleInt: Spurious interrupt!\n");
 176                 return;
 177         }
 178         val = readreg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, ISAC_ISTA);
 179       Start_ISAC:
 180         if (val)
 181                 isac_interrupt(cs, val);
 182         val = readreg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, ISAC_ISTA);
 183         if (val) {
 184                 if (cs->debug & L1_DEB_ISAC)
 185                         debugl1(cs, "ISAC IntStat after IntRoutine");
 186                 goto Start_ISAC;
 187         }
 188         writereg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, ISAC_MASK, 0xFF);
 189         writereg(cs->hw.hfc.addr | 1, cs->hw.hfc.addr, ISAC_MASK, 0x0);
 190 }
 191
 192 static void
 193 TeleInt_Timer(struct IsdnCardState *cs)
 194 {
 195         int stat = 0;
 196
 197         if (cs->bcs[0].mode) {
 198                 stat |= 1;
 199                 main_irq_hfc(&cs->bcs[0]);
 200         }
 201         if (cs->bcs[1].mode) {
 202                 stat |= 2;
 203                 main_irq_hfc(&cs->bcs[1]);
 204         }
 205         cs->hw.hfc.timer.expires = jiffies + 1;
 206         add_timer(&cs->hw.hfc.timer);
 207 }
 208
 209 void
 210 release_io_TeleInt(struct IsdnCardState *cs)
 211 {
 212         del_timer(&cs->hw.hfc.timer);
 213         releasehfc(cs);
 214         if (cs->hw.hfc.addr)
 215                 release_region(cs->hw.hfc.addr, 2);
 216 }
 217
 218 static void
 219 reset_TeleInt(struct IsdnCardState *cs)
 220 {
 221         long flags;
 222
 223         printk(KERN_INFO "TeleInt: resetting card\n");
 224         cs->hw.hfc.cirm |= HFC_RESET;
 225         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);  /* Reset On */
 226         save_flags(flags);
 227         sti();
 228         set_current_state(TASK_UNINTERRUPTIBLE);
 229         schedule_timeout((30*HZ)/1000);
 230         cs->hw.hfc.cirm &= ~HFC_RESET;
 231         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);  /* Reset Off */
 232         set_current_state(TASK_UNINTERRUPTIBLE);
 233         schedule_timeout((10*HZ)/1000);
 234         restore_flags(flags);
 235 }
 236
 237 static int
 238 TeleInt_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 239 {
 240         switch (mt) {
 241                 case CARD_RESET:
 242                         reset_TeleInt(cs);
 243                         return(0);
 244                 case CARD_RELEASE:
 245                         release_io_TeleInt(cs);
 246                         return(0);
 247                 case CARD_INIT:
 248                         inithfc(cs);
 249                         clear_pending_isac_ints(cs);
 250                         initisac(cs);
 251                         /* Reenable all IRQ */
 252                         cs->writeisac(cs, ISAC_MASK, 0);
 253                         cs->writeisac(cs, ISAC_CMDR, 0x41);
 254                         cs->hw.hfc.timer.expires = jiffies + 1;
 255                         add_timer(&cs->hw.hfc.timer);
 256                         return(0);
 257                 case CARD_TEST:
 258                         return(0);
 259         }
 260         return(0);
 261 }
 262
 263 __initfunc(int
 264 setup_TeleInt(struct IsdnCard *card))
 265 {
 266         struct IsdnCardState *cs = card->cs;
 267         char tmp[64];
 268
 269         strcpy(tmp, TeleInt_revision);
 270         printk(KERN_INFO "HiSax: TeleInt driver Rev. %s\n", HiSax_getrev(tmp));
 271         if (cs->typ != ISDN_CTYPE_TELEINT)
 272                 return (0);
 273
 274         cs->hw.hfc.addr = card->para[1] & 0x3fe;
 275         cs->irq = card->para[0];
 276         cs->hw.hfc.cirm = HFC_CIRM;
 277         cs->hw.hfc.isac_spcr = 0x00;
 278         cs->hw.hfc.cip = 0;
 279         cs->hw.hfc.ctmt = HFC_CTMT | HFC_CLTIMER;
 280         cs->bcs[0].hw.hfc.send = NULL;
 281         cs->bcs[1].hw.hfc.send = NULL;
 282         cs->hw.hfc.fifosize = 7 * 1024 + 512;
 283         cs->hw.hfc.timer.function = (void *) TeleInt_Timer;
 284         cs->hw.hfc.timer.data = (long) cs;
 285         init_timer(&cs->hw.hfc.timer);
 286         if (check_region((cs->hw.hfc.addr), 2)) {
 287                 printk(KERN_WARNING
 288                        "HiSax: %s config port %x-%x already in use\n",
 289                        CardType[card->typ],
 290                        cs->hw.hfc.addr,
 291                        cs->hw.hfc.addr + 2);
 292                 return (0);
 293         } else {
 294                 request_region(cs->hw.hfc.addr, 2, "TeleInt isdn");
 295         }
 296         /* HW IO = IO */
 297         byteout(cs->hw.hfc.addr, cs->hw.hfc.addr & 0xff);
 298         byteout(cs->hw.hfc.addr | 1, ((cs->hw.hfc.addr & 0x300) >> 8) | 0x54);
 299         switch (cs->irq) {
 300                 case 3:
 301                         cs->hw.hfc.cirm |= HFC_INTA;
 302                         break;
 303                 case 4:
 304                         cs->hw.hfc.cirm |= HFC_INTB;
 305                         break;
 306                 case 5:
 307                         cs->hw.hfc.cirm |= HFC_INTC;
 308                         break;
 309                 case 7:
 310                         cs->hw.hfc.cirm |= HFC_INTD;
 311                         break;
 312                 case 10:
 313                         cs->hw.hfc.cirm |= HFC_INTE;
 314                         break;
 315                 case 11:
 316                         cs->hw.hfc.cirm |= HFC_INTF;
 317                         break;
 318                 default:
 319                         printk(KERN_WARNING "TeleInt: wrong IRQ\n");
 320                         release_io_TeleInt(cs);
 321                         return (0);
 322         }
 323         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);
 324         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.ctmt);
 325
 326         printk(KERN_INFO
 327                "TeleInt: defined at 0x%x IRQ %d\n",
 328                cs->hw.hfc.addr,
 329                cs->irq);
 330
 331         reset_TeleInt(cs);
 332         cs->readisac = &ReadISAC;
 333         cs->writeisac = &WriteISAC;
 334         cs->readisacfifo = &ReadISACfifo;
 335         cs->writeisacfifo = &WriteISACfifo;
 336         cs->BC_Read_Reg = &ReadHFC;
 337         cs->BC_Write_Reg = &WriteHFC;
 338         cs->cardmsg = &TeleInt_card_msg;
 339         cs->irq_func = &TeleInt_interrupt;
 340         ISACVersion(cs, "TeleInt:");
 341         return (1);
 342 }