drivers/isdn/hisax/teleint.c

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