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 timer_list *t)
 183 {
 184         struct IsdnCardState *cs = from_timer(cs, t, hw.hfc.timer);
 185         int stat = 0;
 186         u_long flags;
 187
 188         spin_lock_irqsave(&cs->lock, flags);
 189         if (cs->bcs[0].mode) {
 190                 stat |= 1;
 191                 main_irq_hfc(&cs->bcs[0]);
 192         }
 193         if (cs->bcs[1].mode) {
 194                 stat |= 2;
 195                 main_irq_hfc(&cs->bcs[1]);
 196         }
 197         spin_unlock_irqrestore(&cs->lock, flags);
 198         stat = HZ / 100;
 199         if (!stat)
 200                 stat = 1;
 201         cs->hw.hfc.timer.expires = jiffies + stat;
 202         add_timer(&cs->hw.hfc.timer);
 203 }
 204
 205 static void
 206 release_io_TeleInt(struct IsdnCardState *cs)
 207 {
 208         del_timer(&cs->hw.hfc.timer);
 209         releasehfc(cs);
 210         if (cs->hw.hfc.addr)
 211                 release_region(cs->hw.hfc.addr, 2);
 212 }
 213
 214 static void
 215 reset_TeleInt(struct IsdnCardState *cs)
 216 {
 217         printk(KERN_INFO "TeleInt: resetting card\n");
 218         cs->hw.hfc.cirm |= HFC_RESET;
 219         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);  /* Reset On */
 220         mdelay(10);
 221         cs->hw.hfc.cirm &= ~HFC_RESET;
 222         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);  /* Reset Off */
 223         mdelay(10);
 224 }
 225
 226 static int
 227 TeleInt_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 228 {
 229         u_long flags;
 230         int delay;
 231
 232         switch (mt) {
 233         case CARD_RESET:
 234                 spin_lock_irqsave(&cs->lock, flags);
 235                 reset_TeleInt(cs);
 236                 spin_unlock_irqrestore(&cs->lock, flags);
 237                 return (0);
 238         case CARD_RELEASE:
 239                 release_io_TeleInt(cs);
 240                 return (0);
 241         case CARD_INIT:
 242                 spin_lock_irqsave(&cs->lock, flags);
 243                 reset_TeleInt(cs);
 244                 inithfc(cs);
 245                 clear_pending_isac_ints(cs);
 246                 initisac(cs);
 247                 /* Reenable all IRQ */
 248                 cs->writeisac(cs, ISAC_MASK, 0);
 249                 cs->writeisac(cs, ISAC_CMDR, 0x41);
 250                 spin_unlock_irqrestore(&cs->lock, flags);
 251                 delay = HZ / 100;
 252                 if (!delay)
 253                         delay = 1;
 254                 cs->hw.hfc.timer.expires = jiffies + delay;
 255                 add_timer(&cs->hw.hfc.timer);
 256                 return (0);
 257         case CARD_TEST:
 258                 return (0);
 259         }
 260         return (0);
 261 }
 262
 263 int 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         timer_setup(&cs->hw.hfc.timer, TeleInt_Timer, 0);
 283         if (!request_region(cs->hw.hfc.addr, 2, "TeleInt isdn")) {
 284                 printk(KERN_WARNING
 285                        "HiSax: TeleInt config port %x-%x already in use\n",
 286                        cs->hw.hfc.addr,
 287                        cs->hw.hfc.addr + 2);
 288                 return (0);
 289         }
 290         /* HW IO = IO */
 291         byteout(cs->hw.hfc.addr, cs->hw.hfc.addr & 0xff);
 292         byteout(cs->hw.hfc.addr | 1, ((cs->hw.hfc.addr & 0x300) >> 8) | 0x54);
 293         switch (cs->irq) {
 294         case 3:
 295                 cs->hw.hfc.cirm |= HFC_INTA;
 296                 break;
 297         case 4:
 298                 cs->hw.hfc.cirm |= HFC_INTB;
 299                 break;
 300         case 5:
 301                 cs->hw.hfc.cirm |= HFC_INTC;
 302                 break;
 303         case 7:
 304                 cs->hw.hfc.cirm |= HFC_INTD;
 305                 break;
 306         case 10:
 307                 cs->hw.hfc.cirm |= HFC_INTE;
 308                 break;
 309         case 11:
 310                 cs->hw.hfc.cirm |= HFC_INTF;
 311                 break;
 312         default:
 313                 printk(KERN_WARNING "TeleInt: wrong IRQ\n");
 314                 release_io_TeleInt(cs);
 315                 return (0);
 316         }
 317         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);
 318         byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.ctmt);
 319
 320         printk(KERN_INFO "TeleInt: defined at 0x%x IRQ %d\n",
 321                cs->hw.hfc.addr, cs->irq);
 322
 323         setup_isac(cs);
 324         cs->readisac = &ReadISAC;
 325         cs->writeisac = &WriteISAC;
 326         cs->readisacfifo = &ReadISACfifo;
 327         cs->writeisacfifo = &WriteISACfifo;
 328         cs->BC_Read_Reg = &ReadHFC;
 329         cs->BC_Write_Reg = &WriteHFC;
 330         cs->cardmsg = &TeleInt_card_msg;
 331         cs->irq_func = &TeleInt_interrupt;
 332         ISACVersion(cs, "TeleInt:");
 333         return (1);
 334 }