drivers/isdn/hisax/niccy.c

   1 /* $Id: niccy.c,v 1.15.6.1 2000/11/28 12:02:46 kai Exp $
   2  *
   3  * niccy.c  low level stuff for Dr. Neuhaus NICCY PnP and NICCY PCI and
   4  *          compatible (SAGEM cybermodem)
   5  *
   6  * Author   Karsten Keil
   7  *
   8  * Thanks to Dr. Neuhaus and SAGEM for informations
   9  *
  10  * This file is (c) under GNU PUBLIC LICENSE
  11  *
  12  */
  13
  14
  15 #define __NO_VERSION__
  16 #include <linux/config.h>
  17 #include <linux/init.h>
  18 #include "hisax.h"
  19 #include "isac.h"
  20 #include "hscx.h"
  21 #include "isdnl1.h"
  22 #include <linux/pci.h>
  23
  24 extern const char *CardType[];
  25 const char *niccy_revision = "$Revision: 1.15.6.1 $";
  26
  27 #define byteout(addr,val) outb(val,addr)
  28 #define bytein(addr) inb(addr)
  29
  30 #define ISAC_PCI_DATA   0
  31 #define HSCX_PCI_DATA   1
  32 #define ISAC_PCI_ADDR   2
  33 #define HSCX_PCI_ADDR   3
  34 #define ISAC_PNP        0
  35 #define HSCX_PNP        1
  36
  37 /* SUB Types */
  38 #define NICCY_PNP       1
  39 #define NICCY_PCI       2
  40
  41 /* PCI stuff */
  42 #define PCI_IRQ_CTRL_REG        0x38
  43 #define PCI_IRQ_ENABLE          0x1f00
  44 #define PCI_IRQ_DISABLE         0xff0000
  45 #define PCI_IRQ_ASSERT          0x800000
  46
  47 static inline u_char
  48 readreg(unsigned int ale, unsigned int adr, u_char off)
  49 {
  50         register u_char ret;
  51         long flags;
  52
  53         save_flags(flags);
  54         cli();
  55         byteout(ale, off);
  56         ret = bytein(adr);
  57         restore_flags(flags);
  58         return (ret);
  59 }
  60
  61 static inline void
  62 readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  63 {
  64         /* fifo read without cli because it's allready done  */
  65
  66         byteout(ale, off);
  67         insb(adr, data, size);
  68 }
  69
  70
  71 static inline void
  72 writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
  73 {
  74         long flags;
  75
  76         save_flags(flags);
  77         cli();
  78         byteout(ale, off);
  79         byteout(adr, data);
  80         restore_flags(flags);
  81 }
  82
  83 static inline void
  84 writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
  85 {
  86         /* fifo write without cli because it's allready done  */
  87         byteout(ale, off);
  88         outsb(adr, data, size);
  89 }
  90
  91 /* Interface functions */
  92
  93 static u_char
  94 ReadISAC(struct IsdnCardState *cs, u_char offset)
  95 {
  96         return (readreg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, offset));
  97 }
  98
  99 static void
 100 WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
 101 {
 102         writereg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, offset, value);
 103 }
 104
 105 static void
 106 ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 107 {
 108         readfifo(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 0, data, size);
 109 }
 110
 111 static void
 112 WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 113 {
 114         writefifo(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 0, data, size);
 115 }
 116
 117 static u_char
 118 ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 119 {
 120         return (readreg(cs->hw.niccy.hscx_ale,
 121                         cs->hw.niccy.hscx, offset + (hscx ? 0x40 : 0)));
 122 }
 123
 124 static void
 125 WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
 126 {
 127         writereg(cs->hw.niccy.hscx_ale,
 128                  cs->hw.niccy.hscx, offset + (hscx ? 0x40 : 0), value);
 129 }
 130
 131 #define READHSCX(cs, nr, reg) readreg(cs->hw.niccy.hscx_ale, \
 132                 cs->hw.niccy.hscx, reg + (nr ? 0x40 : 0))
 133 #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.niccy.hscx_ale, \
 134                 cs->hw.niccy.hscx, reg + (nr ? 0x40 : 0), data)
 135
 136 #define READHSCXFIFO(cs, nr, ptr, cnt) readfifo(cs->hw.niccy.hscx_ale, \
 137                 cs->hw.niccy.hscx, (nr ? 0x40 : 0), ptr, cnt)
 138
 139 #define WRITEHSCXFIFO(cs, nr, ptr, cnt) writefifo(cs->hw.niccy.hscx_ale, \
 140                 cs->hw.niccy.hscx, (nr ? 0x40 : 0), ptr, cnt)
 141
 142 #include "hscx_irq.c"
 143
 144 static void
 145 niccy_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 146 {
 147         struct IsdnCardState *cs = dev_id;
 148         u_char val;
 149
 150         if (!cs) {
 151                 printk(KERN_WARNING "Niccy: Spurious interrupt!\n");
 152                 return;
 153         }
 154         if (cs->subtyp == NICCY_PCI) {
 155                 int ival;
 156                 ival = inl(cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
 157                 if (!(ival & PCI_IRQ_ASSERT)) /* IRQ not for us (shared) */
 158                         return;
 159                 outl(ival, cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
 160         }
 161         val = readreg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_ISTA + 0x40);
 162       Start_HSCX:
 163         if (val)
 164                 hscx_int_main(cs, val);
 165         val = readreg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, ISAC_ISTA);
 166       Start_ISAC:
 167         if (val)
 168                 isac_interrupt(cs, val);
 169         val = readreg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_ISTA + 0x40);
 170         if (val) {
 171                 if (cs->debug & L1_DEB_HSCX)
 172                         debugl1(cs, "HSCX IntStat after IntRoutine");
 173                 goto Start_HSCX;
 174         }
 175         val = readreg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, ISAC_ISTA);
 176         if (val) {
 177                 if (cs->debug & L1_DEB_ISAC)
 178                         debugl1(cs, "ISAC IntStat after IntRoutine");
 179                 goto Start_ISAC;
 180         }
 181         writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK, 0xFF);
 182         writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK + 0x40, 0xFF);
 183         writereg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, ISAC_MASK, 0xFF);
 184         writereg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, ISAC_MASK, 0);
 185         writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK, 0);
 186         writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK + 0x40, 0);
 187 }
 188
 189 void
 190 release_io_niccy(struct IsdnCardState *cs)
 191 {
 192         if (cs->subtyp == NICCY_PCI) {
 193                 int val;
 194
 195                 val = inl(cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
 196                 val &= PCI_IRQ_DISABLE;
 197                 outl(val, cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
 198                 release_region(cs->hw.niccy.cfg_reg, 0x80);
 199                 release_region(cs->hw.niccy.isac, 4);
 200         } else {
 201                 release_region(cs->hw.niccy.isac, 2);
 202                 release_region(cs->hw.niccy.isac_ale, 2);
 203         }
 204 }
 205
 206 static void
 207 niccy_reset(struct IsdnCardState *cs)
 208 {
 209         if (cs->subtyp == NICCY_PCI) {
 210                 int val;
 211
 212                 val = inl(cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
 213                 val |= PCI_IRQ_ENABLE;
 214                 outl(val, cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
 215         }
 216         inithscxisac(cs, 3);
 217 }
 218
 219 static int
 220 niccy_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 221 {
 222         switch (mt) {
 223                 case CARD_RESET:
 224                         niccy_reset(cs);
 225                         return(0);
 226                 case CARD_RELEASE:
 227                         release_io_niccy(cs);
 228                         return(0);
 229                 case CARD_INIT:
 230                         niccy_reset(cs);
 231                         return(0);
 232                 case CARD_TEST:
 233                         return(0);
 234         }
 235         return(0);
 236 }
 237
 238 static struct pci_dev *niccy_dev __initdata;
 239
 240 int __init
 241 setup_niccy(struct IsdnCard *card)
 242 {
 243         struct IsdnCardState *cs = card->cs;
 244         char tmp[64];
 245
 246         strcpy(tmp, niccy_revision);
 247         printk(KERN_INFO "HiSax: Niccy driver Rev. %s\n", HiSax_getrev(tmp));
 248         if (cs->typ != ISDN_CTYPE_NICCY)
 249                 return (0);
 250
 251         if (card->para[1]) {
 252                 cs->hw.niccy.isac = card->para[1] + ISAC_PNP;
 253                 cs->hw.niccy.hscx = card->para[1] + HSCX_PNP;
 254                 cs->hw.niccy.isac_ale = card->para[2] + ISAC_PNP;
 255                 cs->hw.niccy.hscx_ale = card->para[2] + HSCX_PNP;
 256                 cs->hw.niccy.cfg_reg = 0;
 257                 cs->subtyp = NICCY_PNP;
 258                 cs->irq = card->para[0];
 259                 if (check_region((cs->hw.niccy.isac), 2)) {
 260                         printk(KERN_WARNING
 261                                 "HiSax: %s data port %x-%x already in use\n",
 262                                 CardType[card->typ],
 263                                 cs->hw.niccy.isac,
 264                                 cs->hw.niccy.isac + 1);
 265                         return (0);
 266                 } else
 267                         request_region(cs->hw.niccy.isac, 2, "niccy data");
 268                 if (check_region((cs->hw.niccy.isac_ale), 2)) {
 269                         printk(KERN_WARNING
 270                                 "HiSax: %s address port %x-%x already in use\n",
 271                                 CardType[card->typ],
 272                                 cs->hw.niccy.isac_ale,
 273                                 cs->hw.niccy.isac_ale + 1);
 274                         release_region(cs->hw.niccy.isac, 2);
 275                         return (0);
 276                 } else
 277                         request_region(cs->hw.niccy.isac_ale, 2, "niccy addr");
 278         } else {
 279 #if CONFIG_PCI
 280                 u_int pci_ioaddr;
 281                 if (!pci_present()) {
 282                         printk(KERN_ERR "Niccy: no PCI bus present\n");
 283                         return(0);
 284                 }
 285                 cs->subtyp = 0;
 286                 if ((niccy_dev = pci_find_device(PCI_VENDOR_ID_SATSAGEM,
 287                         PCI_DEVICE_ID_SATSAGEM_NICCY, niccy_dev))) {
 288                         if (pci_enable_device(niccy_dev))
 289                                 return(0);
 290                         /* get IRQ */
 291                         if (!niccy_dev->irq) {
 292                                 printk(KERN_WARNING "Niccy: No IRQ for PCI card found\n");
 293                                 return(0);
 294                         }
 295                         cs->irq = niccy_dev->irq;
 296                         cs->hw.niccy.cfg_reg = pci_resource_start(niccy_dev, 0);
 297                         if (!cs->hw.niccy.cfg_reg) {
 298                                 printk(KERN_WARNING "Niccy: No IO-Adr for PCI cfg found\n");
 299                                 return(0);
 300                         }
 301                         pci_ioaddr = pci_resource_start(niccy_dev, 1);
 302                         if (!pci_ioaddr) {
 303                                 printk(KERN_WARNING "Niccy: No IO-Adr for PCI card found\n");
 304                                 return(0);
 305                         }
 306                         cs->subtyp = NICCY_PCI;
 307                 } else {
 308                         printk(KERN_WARNING "Niccy: No PCI card found\n");
 309                         return(0);
 310                 }
 311                 cs->irq_flags |= SA_SHIRQ;
 312                 cs->hw.niccy.isac = pci_ioaddr + ISAC_PCI_DATA;
 313                 cs->hw.niccy.isac_ale = pci_ioaddr + ISAC_PCI_ADDR;
 314                 cs->hw.niccy.hscx = pci_ioaddr + HSCX_PCI_DATA;
 315                 cs->hw.niccy.hscx_ale = pci_ioaddr + HSCX_PCI_ADDR;
 316                 if (check_region((cs->hw.niccy.isac), 4)) {
 317                         printk(KERN_WARNING
 318                                 "HiSax: %s data port %x-%x already in use\n",
 319                                 CardType[card->typ],
 320                                 cs->hw.niccy.isac,
 321                                 cs->hw.niccy.isac + 4);
 322                         return (0);
 323                 } else
 324                         request_region(cs->hw.niccy.isac, 4, "niccy");
 325                 if (check_region(cs->hw.niccy.cfg_reg, 0x80)) {
 326                         printk(KERN_WARNING
 327                                "HiSax: %s pci port %x-%x already in use\n",
 328                                 CardType[card->typ],
 329                                 cs->hw.niccy.cfg_reg,
 330                                 cs->hw.niccy.cfg_reg + 0x80);
 331                         release_region(cs->hw.niccy.isac, 4);
 332                         return (0);
 333                 } else {
 334                         request_region(cs->hw.niccy.cfg_reg, 0x80, "niccy pci");
 335                 }
 336 #else
 337                 printk(KERN_WARNING "Niccy: io0 0 and NO_PCI_BIOS\n");
 338                 printk(KERN_WARNING "Niccy: unable to config NICCY PCI\n");
 339                 return (0);
 340 #endif /* CONFIG_PCI */
 341         }
 342         printk(KERN_INFO
 343                 "HiSax: %s %s config irq:%d data:0x%X ale:0x%X\n",
 344                 CardType[cs->typ], (cs->subtyp==1) ? "PnP":"PCI",
 345                 cs->irq, cs->hw.niccy.isac, cs->hw.niccy.isac_ale);
 346         cs->readisac = &ReadISAC;
 347         cs->writeisac = &WriteISAC;
 348         cs->readisacfifo = &ReadISACfifo;
 349         cs->writeisacfifo = &WriteISACfifo;
 350         cs->BC_Read_Reg = &ReadHSCX;
 351         cs->BC_Write_Reg = &WriteHSCX;
 352         cs->BC_Send_Data = &hscx_fill_fifo;
 353         cs->cardmsg = &niccy_card_msg;
 354         cs->irq_func = &niccy_interrupt;
 355         ISACVersion(cs, "Niccy:");
 356         if (HscxVersion(cs, "Niccy:")) {
 357                 printk(KERN_WARNING
 358                     "Niccy: wrong HSCX versions check IO address\n");
 359                 release_io_niccy(cs);
 360                 return (0);
 361         }
 362         return (1);
 363 }