drivers/isdn/hisax/sportster.c

   1 /* $Id: sportster.c,v 1.14.6.2 2001/09/23 22:24:51 kai Exp $
   2  *
   3  * low level stuff for USR Sportster internal TA
   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  * Thanks to Christian "naddy" Weisgerber (3Com, US Robotics) for documentation
  12  *
  13  *
  14  */
  15 #include <linux/init.h>
  16 #include "hisax.h"
  17 #include "isac.h"
  18 #include "hscx.h"
  19 #include "isdnl1.h"
  20
  21 extern const char *CardType[];
  22 const char *sportster_revision = "$Revision: 1.14.6.2 $";
  23
  24 #define byteout(addr,val) outb(val,addr)
  25 #define bytein(addr) inb(addr)
  26
  27 #define  SPORTSTER_ISAC         0xC000
  28 #define  SPORTSTER_HSCXA        0x0000
  29 #define  SPORTSTER_HSCXB        0x4000
  30 #define  SPORTSTER_RES_IRQ      0x8000
  31 #define  SPORTSTER_RESET        0x80
  32 #define  SPORTSTER_INTE         0x40
  33
  34 static inline int
  35 calc_off(unsigned int base, unsigned int off)
  36 {
  37         return(base + ((off & 0xfc)<<8) + ((off & 3)<<1));
  38 }
  39
  40 static inline void
  41 read_fifo(unsigned int adr, u8 * data, int size)
  42 {
  43         insb(adr, data, size);
  44 }
  45
  46 static void
  47 write_fifo(unsigned int adr, u8 * data, int size)
  48 {
  49         outsb(adr, data, size);
  50 }
  51
  52 static u8
  53 isac_read(struct IsdnCardState *cs, u8 offset)
  54 {
  55         return bytein(calc_off(cs->hw.spt.isac, offset));
  56 }
  57
  58 static void
  59 isac_write(struct IsdnCardState *cs, u8 offset, u8 value)
  60 {
  61         byteout(calc_off(cs->hw.spt.isac, offset), value);
  62 }
  63
  64 static void
  65 isac_read_fifo(struct IsdnCardState *cs, u8 * data, int size)
  66 {
  67         read_fifo(cs->hw.spt.isac, data, size);
  68 }
  69
  70 static void
  71 isac_write_fifo(struct IsdnCardState *cs, u8 * data, int size)
  72 {
  73         write_fifo(cs->hw.spt.isac, data, size);
  74 }
  75
  76 static struct dc_hw_ops isac_ops = {
  77         .read_reg   = isac_read,
  78         .write_reg  = isac_write,
  79         .read_fifo  = isac_read_fifo,
  80         .write_fifo = isac_write_fifo,
  81 };
  82
  83 static u8
  84 hscx_read(struct IsdnCardState *cs, int hscx, u8 offset)
  85 {
  86         return bytein(calc_off(cs->hw.spt.hscx[hscx], offset));
  87 }
  88
  89 static void
  90 hscx_write(struct IsdnCardState *cs, int hscx, u8 offset, u8 value)
  91 {
  92         byteout(calc_off(cs->hw.spt.hscx[hscx], offset), value);
  93 }
  94
  95 static void
  96 hscx_read_fifo(struct IsdnCardState *cs, int hscx, u8 *data, int size)
  97 {
  98         read_fifo(cs->hw.spt.hscx[hscx], data, size);
  99 }
 100
 101 static void
 102 hscx_write_fifo(struct IsdnCardState *cs, int hscx, u8 *data, int size)
 103 {
 104         write_fifo(cs->hw.spt.hscx[hscx], data, size);
 105 }
 106
 107 static struct bc_hw_ops hscx_ops = {
 108         .read_reg   = hscx_read,
 109         .write_reg  = hscx_write,
 110         .read_fifo  = hscx_read_fifo,
 111         .write_fifo = hscx_write_fifo,
 112 };
 113
 114 static irqreturn_t
 115 sportster_interrupt(int intno, void *dev_id, struct pt_regs *regs)
 116 {
 117         struct IsdnCardState *cs = dev_id;
 118
 119         hscxisac_irq(intno, dev_id, regs);
 120         bytein(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ +1);
 121         return IRQ_HANDLED;
 122 }
 123
 124 static void
 125 sportster_release(struct IsdnCardState *cs)
 126 {
 127         int i, adr;
 128
 129         byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, 0);
 130         for (i=0; i<64; i++) {
 131                 adr = cs->hw.spt.cfg_reg + i *1024;
 132                 release_region(adr, 8);
 133         }
 134 }
 135
 136 static int
 137 sportster_reset(struct IsdnCardState *cs)
 138 {
 139         cs->hw.spt.res_irq |= SPORTSTER_RESET; /* Reset On */
 140         byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, cs->hw.spt.res_irq);
 141         set_current_state(TASK_UNINTERRUPTIBLE);
 142         schedule_timeout((10*HZ)/1000);
 143         cs->hw.spt.res_irq &= ~SPORTSTER_RESET; /* Reset Off */
 144         byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, cs->hw.spt.res_irq);
 145         set_current_state(TASK_UNINTERRUPTIBLE);
 146         schedule_timeout((10*HZ)/1000);
 147         return 0;
 148 }
 149
 150 static int
 151 Sportster_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 152 {
 153         return(0);
 154 }
 155
 156 static void
 157 sportster_init(struct IsdnCardState *cs)
 158 {
 159         inithscxisac(cs);
 160         cs->hw.spt.res_irq |= SPORTSTER_INTE; /* IRQ On */
 161         byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, cs->hw.spt.res_irq);
 162 }
 163
 164 static struct card_ops sportster_ops = {
 165         .init     = sportster_init,
 166         .reset    = sportster_reset,
 167         .release  = sportster_release,
 168         .irq_func = sportster_interrupt,
 169 };
 170
 171 static int __init
 172 get_io_range(struct IsdnCardState *cs)
 173 {
 174         int i, adr;
 175
 176         for (i=0;i<64;i++) {
 177                 adr = cs->hw.spt.cfg_reg + i *1024;
 178                 if (!request_region(adr, 8, "sportster")) {
 179                         printk(KERN_WARNING
 180                                 "HiSax: %s config port %x-%x already in use\n",
 181                                 CardType[cs->typ], adr, adr + 8);
 182                         goto err;
 183                 }
 184         }
 185         return 1;
 186  err:
 187         for (i=i-1; i >= 0; i--) {
 188                 adr = cs->hw.spt.cfg_reg + i *1024;
 189                 release_region(adr, 8);
 190         }
 191         return 0;
 192 }
 193
 194 static int __init
 195 sportster_probe(struct IsdnCardState *cs, struct IsdnCard *card)
 196 {
 197         cs->irq = card->para[0];
 198         cs->hw.spt.cfg_reg = card->para[1];
 199         if (!get_io_range(cs))
 200                 return -EBUSY;
 201         cs->hw.spt.isac = cs->hw.spt.cfg_reg + SPORTSTER_ISAC;
 202         cs->hw.spt.hscx[0] = cs->hw.spt.cfg_reg + SPORTSTER_HSCXA;
 203         cs->hw.spt.hscx[1] = cs->hw.spt.cfg_reg + SPORTSTER_HSCXB;
 204
 205         switch(cs->irq) {
 206         case 5: cs->hw.spt.res_irq = 1; break;
 207         case 7: cs->hw.spt.res_irq = 2; break;
 208         case 10:cs->hw.spt.res_irq = 3; break;
 209         case 11:cs->hw.spt.res_irq = 4; break;
 210         case 12:cs->hw.spt.res_irq = 5; break;
 211         case 14:cs->hw.spt.res_irq = 6; break;
 212         case 15:cs->hw.spt.res_irq = 7; break;
 213         default:
 214                 printk(KERN_WARNING "Sportster: wrong IRQ\n");
 215                 goto err;
 216         }
 217         sportster_reset(cs);
 218         printk(KERN_INFO "HiSax: %s config irq:%d cfg:0x%X\n",
 219                CardType[cs->typ], cs->irq, cs->hw.spt.cfg_reg);
 220
 221         cs->cardmsg = &Sportster_card_msg;
 222         cs->card_ops = &sportster_ops;
 223         if (hscxisac_setup(cs, &isac_ops, &hscx_ops))
 224                 goto err;
 225         return 0;
 226  err:
 227         sportster_release(cs);
 228         return -EBUSY;
 229 }
 230
 231 int __init
 232 setup_sportster(struct IsdnCard *card)
 233 {
 234         char tmp[64];
 235
 236         strcpy(tmp, sportster_revision);
 237         printk(KERN_INFO "HiSax: USR Sportster driver Rev. %s\n",
 238                HiSax_getrev(tmp));
 239
 240         if (sportster_probe(card->cs, card) < 0)
 241                 return 0;
 242         return 1;
 243 }