git.oblomov.eu Git - linux-2.6/blob - drivers/atm/iphase.c

   1 /******************************************************************************
   2          iphase.c: Device driver for Interphase ATM PCI adapter cards
   3                     Author: Peter Wang  <pwang@iphase.com>
   4                    Some fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
   5                    Interphase Corporation  <www.iphase.com>
   6                                Version: 1.0
   7 *******************************************************************************
   8
   9       This software may be used and distributed according to the terms
  10       of the GNU General Public License (GPL), incorporated herein by reference.
  11       Drivers based on this skeleton fall under the GPL and must retain
  12       the authorship (implicit copyright) notice.
  13
  14       This program is distributed in the hope that it will be useful, but
  15       WITHOUT ANY WARRANTY; without even the implied warranty of
  16       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17       General Public License for more details.
  18
  19       Modified from an incomplete driver for Interphase 5575 1KVC 1M card which
  20       was originally written by Monalisa Agrawal at UNH. Now this driver
  21       supports a variety of varients of Interphase ATM PCI (i)Chip adapter
  22       card family (See www.iphase.com/products/ClassSheet.cfm?ClassID=ATM)
  23       in terms of PHY type, the size of control memory and the size of
  24       packet memory. The followings are the change log and history:
  25
  26           Bugfix the Mona's UBR driver.
  27           Modify the basic memory allocation and dma logic.
  28           Port the driver to the latest kernel from 2.0.46.
  29           Complete the ABR logic of the driver, and added the ABR work-
  30               around for the hardware anormalies.
  31           Add the CBR support.
  32           Add the flow control logic to the driver to allow rate-limit VC.
  33           Add 4K VC support to the board with 512K control memory.
  34           Add the support of all the variants of the Interphase ATM PCI
  35           (i)Chip adapter cards including x575 (155M OC3 and UTP155), x525
  36           (25M UTP25) and x531 (DS3 and E3).
  37           Add SMP support.
  38
  39       Support and updates available at: ftp://ftp.iphase.com/pub/atm
  40
  41 *******************************************************************************/
  42
  43 #include <linux/module.h>
  44 #include <linux/kernel.h>
  45 #include <linux/mm.h>
  46 #include <linux/pci.h>
  47 #include <linux/errno.h>
  48 #include <linux/atm.h>
  49 #include <linux/atmdev.h>
  50 #include <linux/sonet.h>
  51 #include <linux/skbuff.h>
  52 #include <linux/time.h>
  53 #include <linux/delay.h>
  54 #include <linux/uio.h>
  55 #include <linux/init.h>
  56 #include <linux/wait.h>
  57 #include <asm/system.h>
  58 #include <asm/io.h>
  59 #include <asm/atomic.h>
  60 #include <asm/uaccess.h>
  61 #include <asm/string.h>
  62 #include <asm/byteorder.h>
  63 #include <linux/vmalloc.h>
  64 #include "iphase.h"
  65 #include "suni.h"
  66 #define swap(x) (((x & 0xff) << 8) | ((x & 0xff00) >> 8))
  67 struct suni_priv {
  68         struct k_sonet_stats sonet_stats; /* link diagnostics */
  69         unsigned char loop_mode;        /* loopback mode */
  70         struct atm_dev *dev;            /* device back-pointer */
  71         struct suni_priv *next;         /* next SUNI */
  72 };
  73 #define PRIV(dev) ((struct suni_priv *) dev->phy_data)
  74
  75 static unsigned char ia_phy_get(struct atm_dev *dev, unsigned long addr);
  76 static void desc_dbg(IADEV *iadev);
  77
  78 static IADEV *ia_dev[8];
  79 static struct atm_dev *_ia_dev[8];
  80 static int iadev_count;
  81 static void ia_led_timer(unsigned long arg);
  82 static DEFINE_TIMER(ia_timer, ia_led_timer, 0, 0);
  83 static int IA_TX_BUF = DFL_TX_BUFFERS, IA_TX_BUF_SZ = DFL_TX_BUF_SZ;
  84 static int IA_RX_BUF = DFL_RX_BUFFERS, IA_RX_BUF_SZ = DFL_RX_BUF_SZ;
  85 static uint IADebugFlag = /* IF_IADBG_ERR | IF_IADBG_CBR| IF_IADBG_INIT_ADAPTER
  86             |IF_IADBG_ABR | IF_IADBG_EVENT*/ 0;
  87
  88 module_param(IA_TX_BUF, int, 0);
  89 module_param(IA_TX_BUF_SZ, int, 0);
  90 module_param(IA_RX_BUF, int, 0);
  91 module_param(IA_RX_BUF_SZ, int, 0);
  92 module_param(IADebugFlag, uint, 0644);
  93
  94 MODULE_LICENSE("GPL");
  95
  96 #if BITS_PER_LONG != 32
  97 #  error FIXME: this driver only works on 32-bit platforms
  98 #endif
  99
 100 /**************************** IA_LIB **********************************/
 101
 102 static void ia_init_rtn_q (IARTN_Q *que)
 103 {
 104    que->next = NULL;
 105    que->tail = NULL;
 106 }
 107
 108 static void ia_enque_head_rtn_q (IARTN_Q *que, IARTN_Q * data)
 109 {
 110    data->next = NULL;
 111    if (que->next == NULL)
 112       que->next = que->tail = data;
 113    else {
 114       data->next = que->next;
 115       que->next = data;
 116    }
 117    return;
 118 }
 119
 120 static int ia_enque_rtn_q (IARTN_Q *que, struct desc_tbl_t data) {
 121    IARTN_Q *entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
 122    if (!entry) return -1;
 123    entry->data = data;
 124    entry->next = NULL;
 125    if (que->next == NULL)
 126       que->next = que->tail = entry;
 127    else {
 128       que->tail->next = entry;
 129       que->tail = que->tail->next;
 130    }
 131    return 1;
 132 }
 133
 134 static IARTN_Q * ia_deque_rtn_q (IARTN_Q *que) {
 135    IARTN_Q *tmpdata;
 136    if (que->next == NULL)
 137       return NULL;
 138    tmpdata = que->next;
 139    if ( que->next == que->tail)
 140       que->next = que->tail = NULL;
 141    else
 142       que->next = que->next->next;
 143    return tmpdata;
 144 }
 145
 146 static void ia_hack_tcq(IADEV *dev) {
 147
 148   u_short               desc1;
 149   u_short               tcq_wr;
 150   struct ia_vcc         *iavcc_r = NULL;
 151
 152   tcq_wr = readl(dev->seg_reg+TCQ_WR_PTR) & 0xffff;
 153   while (dev->host_tcq_wr != tcq_wr) {
 154      desc1 = *(u_short *)(dev->seg_ram + dev->host_tcq_wr);
 155      if (!desc1) ;
 156      else if (!dev->desc_tbl[desc1 -1].timestamp) {
 157         IF_ABR(printk(" Desc %d is reset at %ld\n", desc1 -1, jiffies);)
 158         *(u_short *) (dev->seg_ram + dev->host_tcq_wr) = 0;
 159      }
 160      else if (dev->desc_tbl[desc1 -1].timestamp) {
 161         if (!(iavcc_r = dev->desc_tbl[desc1 -1].iavcc)) {
 162            printk("IA: Fatal err in get_desc\n");
 163            continue;
 164         }
 165         iavcc_r->vc_desc_cnt--;
 166         dev->desc_tbl[desc1 -1].timestamp = 0;
 167         IF_EVENT(printk("ia_hack: return_q skb = 0x%x desc = %d\n",
 168                                    (u32)dev->desc_tbl[desc1 -1].txskb, desc1);)
 169         if (iavcc_r->pcr < dev->rate_limit) {
 170            IA_SKB_STATE (dev->desc_tbl[desc1-1].txskb) |= IA_TX_DONE;
 171            if (ia_enque_rtn_q(&dev->tx_return_q, dev->desc_tbl[desc1 -1]) < 0)
 172               printk("ia_hack_tcq: No memory available\n");
 173         }
 174         dev->desc_tbl[desc1 -1].iavcc = NULL;
 175         dev->desc_tbl[desc1 -1].txskb = NULL;
 176      }
 177      dev->host_tcq_wr += 2;
 178      if (dev->host_tcq_wr > dev->ffL.tcq_ed)
 179         dev->host_tcq_wr = dev->ffL.tcq_st;
 180   }
 181 } /* ia_hack_tcq */
 182
 183 static u16 get_desc (IADEV *dev, struct ia_vcc *iavcc) {
 184   u_short               desc_num, i;
 185   struct sk_buff        *skb;
 186   struct ia_vcc         *iavcc_r = NULL;
 187   unsigned long delta;
 188   static unsigned long timer = 0;
 189   int ltimeout;
 190
 191   ia_hack_tcq (dev);
 192   if(((jiffies - timer)>50)||((dev->ffL.tcq_rd==dev->host_tcq_wr))){
 193      timer = jiffies;
 194      i=0;
 195      while (i < dev->num_tx_desc) {
 196         if (!dev->desc_tbl[i].timestamp) {
 197            i++;
 198            continue;
 199         }
 200         ltimeout = dev->desc_tbl[i].iavcc->ltimeout;
 201         delta = jiffies - dev->desc_tbl[i].timestamp;
 202         if (delta >= ltimeout) {
 203            IF_ABR(printk("RECOVER run!! desc_tbl %d = %d  delta = %ld, time = %ld\n", i,dev->desc_tbl[i].timestamp, delta, jiffies);)
 204            if (dev->ffL.tcq_rd == dev->ffL.tcq_st)
 205               dev->ffL.tcq_rd =  dev->ffL.tcq_ed;
 206            else
 207               dev->ffL.tcq_rd -= 2;
 208            *(u_short *)(dev->seg_ram + dev->ffL.tcq_rd) = i+1;
 209            if (!(skb = dev->desc_tbl[i].txskb) ||
 210                           !(iavcc_r = dev->desc_tbl[i].iavcc))
 211               printk("Fatal err, desc table vcc or skb is NULL\n");
 212            else
 213               iavcc_r->vc_desc_cnt--;
 214            dev->desc_tbl[i].timestamp = 0;
 215            dev->desc_tbl[i].iavcc = NULL;
 216            dev->desc_tbl[i].txskb = NULL;
 217         }
 218         i++;
 219      } /* while */
 220   }
 221   if (dev->ffL.tcq_rd == dev->host_tcq_wr)
 222      return 0xFFFF;
 223
 224   /* Get the next available descriptor number from TCQ */
 225   desc_num = *(u_short *)(dev->seg_ram + dev->ffL.tcq_rd);
 226
 227   while (!desc_num || (dev->desc_tbl[desc_num -1]).timestamp) {
 228      dev->ffL.tcq_rd += 2;
 229      if (dev->ffL.tcq_rd > dev->ffL.tcq_ed)
 230      dev->ffL.tcq_rd = dev->ffL.tcq_st;
 231      if (dev->ffL.tcq_rd == dev->host_tcq_wr)
 232         return 0xFFFF;
 233      desc_num = *(u_short *)(dev->seg_ram + dev->ffL.tcq_rd);
 234   }
 235
 236   /* get system time */
 237   dev->desc_tbl[desc_num -1].timestamp = jiffies;
 238   return desc_num;
 239 }
 240
 241 static void clear_lockup (struct atm_vcc *vcc, IADEV *dev) {
 242   u_char                foundLockUp;
 243   vcstatus_t            *vcstatus;
 244   u_short               *shd_tbl;
 245   u_short               tempCellSlot, tempFract;
 246   struct main_vc *abr_vc = (struct main_vc *)dev->MAIN_VC_TABLE_ADDR;
 247   struct ext_vc *eabr_vc = (struct ext_vc *)dev->EXT_VC_TABLE_ADDR;
 248   u_int  i;
 249
 250   if (vcc->qos.txtp.traffic_class == ATM_ABR) {
 251      vcstatus = (vcstatus_t *) &(dev->testTable[vcc->vci]->vc_status);
 252      vcstatus->cnt++;
 253      foundLockUp = 0;
 254      if( vcstatus->cnt == 0x05 ) {
 255         abr_vc += vcc->vci;
 256         eabr_vc += vcc->vci;
 257         if( eabr_vc->last_desc ) {
 258            if( (abr_vc->status & 0x07) == ABR_STATE /* 0x2 */ ) {
 259               /* Wait for 10 Micro sec */
 260               udelay(10);
 261               if ((eabr_vc->last_desc)&&((abr_vc->status & 0x07)==ABR_STATE))
 262                  foundLockUp = 1;
 263            }
 264            else {
 265               tempCellSlot = abr_vc->last_cell_slot;
 266               tempFract    = abr_vc->fraction;
 267               if((tempCellSlot == dev->testTable[vcc->vci]->lastTime)
 268                          && (tempFract == dev->testTable[vcc->vci]->fract))
 269                  foundLockUp = 1;
 270               dev->testTable[vcc->vci]->lastTime = tempCellSlot;
 271               dev->testTable[vcc->vci]->fract = tempFract;
 272            }
 273         } /* last descriptor */
 274         vcstatus->cnt = 0;
 275      } /* vcstatus->cnt */
 276
 277      if (foundLockUp) {
 278         IF_ABR(printk("LOCK UP found\n");)
 279         writew(0xFFFD, dev->seg_reg+MODE_REG_0);
 280         /* Wait for 10 Micro sec */
 281         udelay(10);
 282         abr_vc->status &= 0xFFF8;
 283         abr_vc->status |= 0x0001;  /* state is idle */
 284         shd_tbl = (u_short *)dev->ABR_SCHED_TABLE_ADDR;
 285         for( i = 0; ((i < dev->num_vc) && (shd_tbl[i])); i++ );
 286         if (i < dev->num_vc)
 287            shd_tbl[i] = vcc->vci;
 288         else
 289            IF_ERR(printk("ABR Seg. may not continue on VC %x\n",vcc->vci);)
 290         writew(T_ONLINE, dev->seg_reg+MODE_REG_0);
 291         writew(~(TRANSMIT_DONE|TCQ_NOT_EMPTY), dev->seg_reg+SEG_MASK_REG);
 292         writew(TRANSMIT_DONE, dev->seg_reg+SEG_INTR_STATUS_REG);
 293         vcstatus->cnt = 0;
 294      } /* foundLockUp */
 295
 296   } /* if an ABR VC */
 297
 298
 299 }
 300
 301 /*
 302 ** Conversion of 24-bit cellrate (cells/sec) to 16-bit floating point format.
 303 **
 304 **  +----+----+------------------+-------------------------------+
 305 **  |  R | NZ |  5-bit exponent  |        9-bit mantissa         |
 306 **  +----+----+------------------+-------------------------------+
 307 **
 308 **    R = reserved (written as 0)
 309 **    NZ = 0 if 0 cells/sec; 1 otherwise
 310 **
 311 **    if NZ = 1, rate = 1.mmmmmmmmm x 2^(eeeee) cells/sec
 312 */
 313 static u16
 314 cellrate_to_float(u32 cr)
 315 {
 316
 317 #define NZ              0x4000
 318 #define M_BITS          9               /* Number of bits in mantissa */
 319 #define E_BITS          5               /* Number of bits in exponent */
 320 #define M_MASK          0x1ff
 321 #define E_MASK          0x1f
 322   u16   flot;
 323   u32   tmp = cr & 0x00ffffff;
 324   int   i   = 0;
 325   if (cr == 0)
 326      return 0;
 327   while (tmp != 1) {
 328      tmp >>= 1;
 329      i++;
 330   }
 331   if (i == M_BITS)
 332      flot = NZ | (i << M_BITS) | (cr & M_MASK);
 333   else if (i < M_BITS)
 334      flot = NZ | (i << M_BITS) | ((cr << (M_BITS - i)) & M_MASK);
 335   else
 336      flot = NZ | (i << M_BITS) | ((cr >> (i - M_BITS)) & M_MASK);
 337   return flot;
 338 }
 339
 340 #if 0
 341 /*
 342 ** Conversion of 16-bit floating point format to 24-bit cellrate (cells/sec).
 343 */
 344 static u32
 345 float_to_cellrate(u16 rate)
 346 {
 347   u32   exp, mantissa, cps;
 348   if ((rate & NZ) == 0)
 349      return 0;
 350   exp = (rate >> M_BITS) & E_MASK;
 351   mantissa = rate & M_MASK;
 352   if (exp == 0)
 353      return 1;
 354   cps = (1 << M_BITS) | mantissa;
 355   if (exp == M_BITS)
 356      cps = cps;
 357   else if (exp > M_BITS)
 358      cps <<= (exp - M_BITS);
 359   else
 360      cps >>= (M_BITS - exp);
 361   return cps;
 362 }
 363 #endif
 364
 365 static void init_abr_vc (IADEV *dev, srv_cls_param_t *srv_p) {
 366   srv_p->class_type = ATM_ABR;
 367   srv_p->pcr        = dev->LineRate;
 368   srv_p->mcr        = 0;
 369   srv_p->icr        = 0x055cb7;
 370   srv_p->tbe        = 0xffffff;
 371   srv_p->frtt       = 0x3a;
 372   srv_p->rif        = 0xf;
 373   srv_p->rdf        = 0xb;
 374   srv_p->nrm        = 0x4;
 375   srv_p->trm        = 0x7;
 376   srv_p->cdf        = 0x3;
 377   srv_p->adtf       = 50;
 378 }
 379
 380 static int
 381 ia_open_abr_vc(IADEV *dev, srv_cls_param_t *srv_p,
 382                                                 struct atm_vcc *vcc, u8 flag)
 383 {
 384   f_vc_abr_entry  *f_abr_vc;
 385   r_vc_abr_entry  *r_abr_vc;
 386   u32           icr;
 387   u8            trm, nrm, crm;
 388   u16           adtf, air, *ptr16;
 389   f_abr_vc =(f_vc_abr_entry *)dev->MAIN_VC_TABLE_ADDR;
 390   f_abr_vc += vcc->vci;
 391   switch (flag) {
 392      case 1: /* FFRED initialization */
 393 #if 0  /* sanity check */
 394        if (srv_p->pcr == 0)
 395           return INVALID_PCR;
 396        if (srv_p->pcr > dev->LineRate)
 397           srv_p->pcr = dev->LineRate;
 398        if ((srv_p->mcr + dev->sum_mcr) > dev->LineRate)
 399           return MCR_UNAVAILABLE;
 400        if (srv_p->mcr > srv_p->pcr)
 401           return INVALID_MCR;
 402        if (!(srv_p->icr))
 403           srv_p->icr = srv_p->pcr;
 404        if ((srv_p->icr < srv_p->mcr) || (srv_p->icr > srv_p->pcr))
 405           return INVALID_ICR;
 406        if ((srv_p->tbe < MIN_TBE) || (srv_p->tbe > MAX_TBE))
 407           return INVALID_TBE;
 408        if ((srv_p->frtt < MIN_FRTT) || (srv_p->frtt > MAX_FRTT))
 409           return INVALID_FRTT;
 410        if (srv_p->nrm > MAX_NRM)
 411           return INVALID_NRM;
 412        if (srv_p->trm > MAX_TRM)
 413           return INVALID_TRM;
 414        if (srv_p->adtf > MAX_ADTF)
 415           return INVALID_ADTF;
 416        else if (srv_p->adtf == 0)
 417           srv_p->adtf = 1;
 418        if (srv_p->cdf > MAX_CDF)
 419           return INVALID_CDF;
 420        if (srv_p->rif > MAX_RIF)
 421           return INVALID_RIF;
 422        if (srv_p->rdf > MAX_RDF)
 423           return INVALID_RDF;
 424 #endif
 425        memset ((caddr_t)f_abr_vc, 0, sizeof(*f_abr_vc));
 426        f_abr_vc->f_vc_type = ABR;
 427        nrm = 2 << srv_p->nrm;     /* (2 ** (srv_p->nrm +1)) */
 428                                   /* i.e 2**n = 2 << (n-1) */
 429        f_abr_vc->f_nrm = nrm << 8 | nrm;
 430        trm = 100000/(2 << (16 - srv_p->trm));
 431        if ( trm == 0) trm = 1;
 432        f_abr_vc->f_nrmexp =(((srv_p->nrm +1) & 0x0f) << 12)|(MRM << 8) | trm;
 433        crm = srv_p->tbe / nrm;
 434        if (crm == 0) crm = 1;
 435        f_abr_vc->f_crm = crm & 0xff;
 436        f_abr_vc->f_pcr = cellrate_to_float(srv_p->pcr);
 437        icr = min( srv_p->icr, (srv_p->tbe > srv_p->frtt) ?
 438                                 ((srv_p->tbe/srv_p->frtt)*1000000) :
 439                                 (1000000/(srv_p->frtt/srv_p->tbe)));
 440        f_abr_vc->f_icr = cellrate_to_float(icr);
 441        adtf = (10000 * srv_p->adtf)/8192;
 442        if (adtf == 0) adtf = 1;
 443        f_abr_vc->f_cdf = ((7 - srv_p->cdf) << 12 | adtf) & 0xfff;
 444        f_abr_vc->f_mcr = cellrate_to_float(srv_p->mcr);
 445        f_abr_vc->f_acr = f_abr_vc->f_icr;
 446        f_abr_vc->f_status = 0x0042;
 447        break;
 448     case 0: /* RFRED initialization */
 449        ptr16 = (u_short *)(dev->reass_ram + REASS_TABLE*dev->memSize);
 450        *(ptr16 + vcc->vci) = NO_AAL5_PKT | REASS_ABR;
 451        r_abr_vc = (r_vc_abr_entry*)(dev->reass_ram+ABR_VC_TABLE*dev->memSize);
 452        r_abr_vc += vcc->vci;
 453        r_abr_vc->r_status_rdf = (15 - srv_p->rdf) & 0x000f;
 454        air = srv_p->pcr << (15 - srv_p->rif);
 455        if (air == 0) air = 1;
 456        r_abr_vc->r_air = cellrate_to_float(air);
 457        dev->testTable[vcc->vci]->vc_status = VC_ACTIVE | VC_ABR;
 458        dev->sum_mcr        += srv_p->mcr;
 459        dev->n_abr++;
 460        break;
 461     default:
 462        break;
 463   }
 464   return        0;
 465 }
 466 static int ia_cbr_setup (IADEV *dev, struct atm_vcc *vcc) {
 467    u32 rateLow=0, rateHigh, rate;
 468    int entries;
 469    struct ia_vcc *ia_vcc;
 470
 471    int   idealSlot =0, testSlot, toBeAssigned, inc;
 472    u32   spacing;
 473    u16  *SchedTbl, *TstSchedTbl;
 474    u16  cbrVC, vcIndex;
 475    u32   fracSlot    = 0;
 476    u32   sp_mod      = 0;
 477    u32   sp_mod2     = 0;
 478
 479    /* IpAdjustTrafficParams */
 480    if (vcc->qos.txtp.max_pcr <= 0) {
 481       IF_ERR(printk("PCR for CBR not defined\n");)
 482       return -1;
 483    }
 484    rate = vcc->qos.txtp.max_pcr;
 485    entries = rate / dev->Granularity;
 486    IF_CBR(printk("CBR: CBR entries=0x%x for rate=0x%x & Gran=0x%x\n",
 487                                 entries, rate, dev->Granularity);)
 488    if (entries < 1)
 489       IF_CBR(printk("CBR: Bandwidth smaller than granularity of CBR table\n");)
 490    rateLow  =  entries * dev->Granularity;
 491    rateHigh = (entries + 1) * dev->Granularity;
 492    if (3*(rate - rateLow) > (rateHigh - rate))
 493       entries++;
 494    if (entries > dev->CbrRemEntries) {
 495       IF_CBR(printk("CBR: Not enough bandwidth to support this PCR.\n");)
 496       IF_CBR(printk("Entries = 0x%x, CbrRemEntries = 0x%x.\n",
 497                                        entries, dev->CbrRemEntries);)
 498       return -EBUSY;
 499    }
 500
 501    ia_vcc = INPH_IA_VCC(vcc);
 502    ia_vcc->NumCbrEntry = entries;
 503    dev->sum_mcr += entries * dev->Granularity;
 504    /* IaFFrednInsertCbrSched */
 505    // Starting at an arbitrary location, place the entries into the table
 506    // as smoothly as possible
 507    cbrVC   = 0;
 508    spacing = dev->CbrTotEntries / entries;
 509    sp_mod  = dev->CbrTotEntries % entries; // get modulo
 510    toBeAssigned = entries;
 511    fracSlot = 0;
 512    vcIndex  = vcc->vci;
 513    IF_CBR(printk("Vci=0x%x,Spacing=0x%x,Sp_mod=0x%x\n",vcIndex,spacing,sp_mod);)
 514    while (toBeAssigned)
 515    {
 516       // If this is the first time, start the table loading for this connection
 517       // as close to entryPoint as possible.
 518       if (toBeAssigned == entries)
 519       {
 520          idealSlot = dev->CbrEntryPt;
 521          dev->CbrEntryPt += 2;    // Adding 2 helps to prevent clumping
 522          if (dev->CbrEntryPt >= dev->CbrTotEntries)
 523             dev->CbrEntryPt -= dev->CbrTotEntries;// Wrap if necessary
 524       } else {
 525          idealSlot += (u32)(spacing + fracSlot); // Point to the next location
 526          // in the table that would be  smoothest
 527          fracSlot = ((sp_mod + sp_mod2) / entries);  // get new integer part
 528          sp_mod2  = ((sp_mod + sp_mod2) % entries);  // calc new fractional part
 529       }
 530       if (idealSlot >= (int)dev->CbrTotEntries)
 531          idealSlot -= dev->CbrTotEntries;
 532       // Continuously check around this ideal value until a null
 533       // location is encountered.
 534       SchedTbl = (u16*)(dev->seg_ram+CBR_SCHED_TABLE*dev->memSize);
 535       inc = 0;
 536       testSlot = idealSlot;
 537       TstSchedTbl = (u16*)(SchedTbl+testSlot);  //set index and read in value
 538       IF_CBR(printk("CBR Testslot 0x%x AT Location 0x%x, NumToAssign=%d\n",
 539                                 testSlot, (u32)TstSchedTbl,toBeAssigned);)
 540       memcpy((caddr_t)&cbrVC,(caddr_t)TstSchedTbl,sizeof(cbrVC));
 541       while (cbrVC)  // If another VC at this location, we have to keep looking
 542       {
 543           inc++;
 544           testSlot = idealSlot - inc;
 545           if (testSlot < 0) { // Wrap if necessary
 546              testSlot += dev->CbrTotEntries;
 547              IF_CBR(printk("Testslot Wrap. STable Start=0x%x,Testslot=%d\n",
 548                                                        (u32)SchedTbl,testSlot);)
 549           }
 550           TstSchedTbl = (u16 *)(SchedTbl + testSlot);  // set table index
 551           memcpy((caddr_t)&cbrVC,(caddr_t)TstSchedTbl,sizeof(cbrVC));
 552           if (!cbrVC)
 553              break;
 554           testSlot = idealSlot + inc;
 555           if (testSlot >= (int)dev->CbrTotEntries) { // Wrap if necessary
 556              testSlot -= dev->CbrTotEntries;
 557              IF_CBR(printk("TotCbrEntries=%d",dev->CbrTotEntries);)
 558              IF_CBR(printk(" Testslot=0x%x ToBeAssgned=%d\n",
 559                                             testSlot, toBeAssigned);)
 560           }
 561           // set table index and read in value
 562           TstSchedTbl = (u16*)(SchedTbl + testSlot);
 563           IF_CBR(printk("Reading CBR Tbl from 0x%x, CbrVal=0x%x Iteration %d\n",
 564                           (u32)TstSchedTbl,cbrVC,inc);)
 565           memcpy((caddr_t)&cbrVC,(caddr_t)TstSchedTbl,sizeof(cbrVC));
 566        } /* while */
 567        // Move this VCI number into this location of the CBR Sched table.
 568        memcpy((caddr_t)TstSchedTbl, (caddr_t)&vcIndex,sizeof(TstSchedTbl));
 569        dev->CbrRemEntries--;
 570        toBeAssigned--;
 571    } /* while */
 572
 573    /* IaFFrednCbrEnable */
 574    dev->NumEnabledCBR++;
 575    if (dev->NumEnabledCBR == 1) {
 576        writew((CBR_EN | UBR_EN | ABR_EN | (0x23 << 2)), dev->seg_reg+STPARMS);
 577        IF_CBR(printk("CBR is enabled\n");)
 578    }
 579    return 0;
 580 }
 581 static void ia_cbrVc_close (struct atm_vcc *vcc) {
 582    IADEV *iadev;
 583    u16 *SchedTbl, NullVci = 0;
 584    u32 i, NumFound;
 585
 586    iadev = INPH_IA_DEV(vcc->dev);
 587    iadev->NumEnabledCBR--;
 588    SchedTbl = (u16*)(iadev->seg_ram+CBR_SCHED_TABLE*iadev->memSize);
 589    if (iadev->NumEnabledCBR == 0) {
 590       writew((UBR_EN | ABR_EN | (0x23 << 2)), iadev->seg_reg+STPARMS);
 591       IF_CBR (printk("CBR support disabled\n");)
 592    }
 593    NumFound = 0;
 594    for (i=0; i < iadev->CbrTotEntries; i++)
 595    {
 596       if (*SchedTbl == vcc->vci) {
 597          iadev->CbrRemEntries++;
 598          *SchedTbl = NullVci;
 599          IF_CBR(NumFound++;)
 600       }
 601       SchedTbl++;
 602    }
 603    IF_CBR(printk("Exit ia_cbrVc_close, NumRemoved=%d\n",NumFound);)
 604 }
 605
 606 static int ia_avail_descs(IADEV *iadev) {
 607    int tmp = 0;
 608    ia_hack_tcq(iadev);
 609    if (iadev->host_tcq_wr >= iadev->ffL.tcq_rd)
 610       tmp = (iadev->host_tcq_wr - iadev->ffL.tcq_rd) / 2;
 611    else
 612       tmp = (iadev->ffL.tcq_ed - iadev->ffL.tcq_rd + 2 + iadev->host_tcq_wr -
 613                    iadev->ffL.tcq_st) / 2;
 614    return tmp;
 615 }
 616
 617 static int ia_pkt_tx (struct atm_vcc *vcc, struct sk_buff *skb);
 618
 619 static int ia_que_tx (IADEV *iadev) {
 620    struct sk_buff *skb;
 621    int num_desc;
 622    struct atm_vcc *vcc;
 623    struct ia_vcc *iavcc;
 624    num_desc = ia_avail_descs(iadev);
 625
 626    while (num_desc && (skb = skb_dequeue(&iadev->tx_backlog))) {
 627       if (!(vcc = ATM_SKB(skb)->vcc)) {
 628          dev_kfree_skb_any(skb);
 629          printk("ia_que_tx: Null vcc\n");
 630          break;
 631       }
 632       if (!test_bit(ATM_VF_READY,&vcc->flags)) {
 633          dev_kfree_skb_any(skb);
 634          printk("Free the SKB on closed vci %d \n", vcc->vci);
 635          break;
 636       }
 637       iavcc = INPH_IA_VCC(vcc);
 638       if (ia_pkt_tx (vcc, skb)) {
 639          skb_queue_head(&iadev->tx_backlog, skb);
 640       }
 641       num_desc--;
 642    }
 643    return 0;
 644 }
 645
 646 static void ia_tx_poll (IADEV *iadev) {
 647    struct atm_vcc *vcc = NULL;
 648    struct sk_buff *skb = NULL, *skb1 = NULL;
 649    struct ia_vcc *iavcc;
 650    IARTN_Q *  rtne;
 651
 652    ia_hack_tcq(iadev);
 653    while ( (rtne = ia_deque_rtn_q(&iadev->tx_return_q))) {
 654        skb = rtne->data.txskb;
 655        if (!skb) {
 656            printk("ia_tx_poll: skb is null\n");
 657            goto out;
 658        }
 659        vcc = ATM_SKB(skb)->vcc;
 660        if (!vcc) {
 661            printk("ia_tx_poll: vcc is null\n");
 662            dev_kfree_skb_any(skb);
 663            goto out;
 664        }
 665
 666        iavcc = INPH_IA_VCC(vcc);
 667        if (!iavcc) {
 668            printk("ia_tx_poll: iavcc is null\n");
 669            dev_kfree_skb_any(skb);
 670            goto out;
 671        }
 672
 673        skb1 = skb_dequeue(&iavcc->txing_skb);
 674        while (skb1 && (skb1 != skb)) {
 675           if (!(IA_SKB_STATE(skb1) & IA_TX_DONE)) {
 676              printk("IA_tx_intr: Vci %d lost pkt!!!\n", vcc->vci);
 677           }
 678           IF_ERR(printk("Release the SKB not match\n");)
 679           if ((vcc->pop) && (skb1->len != 0))
 680           {
 681              vcc->pop(vcc, skb1);
 682              IF_EVENT(printk("Tansmit Done - skb 0x%lx return\n",
 683                                                           (long)skb1);)
 684           }
 685           else
 686              dev_kfree_skb_any(skb1);
 687           skb1 = skb_dequeue(&iavcc->txing_skb);
 688        }
 689        if (!skb1) {
 690           IF_EVENT(printk("IA: Vci %d - skb not found requed\n",vcc->vci);)
 691           ia_enque_head_rtn_q (&iadev->tx_return_q, rtne);
 692           break;
 693        }
 694        if ((vcc->pop) && (skb->len != 0))
 695        {
 696           vcc->pop(vcc, skb);
 697           IF_EVENT(printk("Tx Done - skb 0x%lx return\n",(long)skb);)
 698        }
 699        else
 700           dev_kfree_skb_any(skb);
 701        kfree(rtne);
 702     }
 703     ia_que_tx(iadev);
 704 out:
 705     return;
 706 }
 707 #if 0
 708 static void ia_eeprom_put (IADEV *iadev, u32 addr, u_short val)
 709 {
 710         u32     t;
 711         int     i;
 712         /*
 713          * Issue a command to enable writes to the NOVRAM
 714          */
 715         NVRAM_CMD (EXTEND + EWEN);
 716         NVRAM_CLR_CE;
 717         /*
 718          * issue the write command
 719          */
 720         NVRAM_CMD(IAWRITE + addr);
 721         /*
 722          * Send the data, starting with D15, then D14, and so on for 16 bits
 723          */
 724         for (i=15; i>=0; i--) {
 725                 NVRAM_CLKOUT (val & 0x8000);
 726                 val <<= 1;
 727         }
 728         NVRAM_CLR_CE;
 729         CFG_OR(NVCE);
 730         t = readl(iadev->reg+IPHASE5575_EEPROM_ACCESS);
 731         while (!(t & NVDO))
 732                 t = readl(iadev->reg+IPHASE5575_EEPROM_ACCESS);
 733
 734         NVRAM_CLR_CE;
 735         /*
 736          * disable writes again
 737          */
 738         NVRAM_CMD(EXTEND + EWDS)
 739         NVRAM_CLR_CE;
 740         CFG_AND(~NVDI);
 741 }
 742 #endif
 743
 744 static u16 ia_eeprom_get (IADEV *iadev, u32 addr)
 745 {
 746         u_short val;
 747         u32     t;
 748         int     i;
 749         /*
 750          * Read the first bit that was clocked with the falling edge of the
 751          * the last command data clock
 752          */
 753         NVRAM_CMD(IAREAD + addr);
 754         /*
 755          * Now read the rest of the bits, the next bit read is D14, then D13,
 756          * and so on.
 757          */
 758         val = 0;
 759         for (i=15; i>=0; i--) {
 760                 NVRAM_CLKIN(t);
 761                 val |= (t << i);
 762         }
 763         NVRAM_CLR_CE;
 764         CFG_AND(~NVDI);
 765         return val;
 766 }
 767
 768 static void ia_hw_type(IADEV *iadev) {
 769    u_short memType = ia_eeprom_get(iadev, 25);
 770    iadev->memType = memType;
 771    if ((memType & MEM_SIZE_MASK) == MEM_SIZE_1M) {
 772       iadev->num_tx_desc = IA_TX_BUF;
 773       iadev->tx_buf_sz = IA_TX_BUF_SZ;
 774       iadev->num_rx_desc = IA_RX_BUF;
 775       iadev->rx_buf_sz = IA_RX_BUF_SZ;
 776    } else if ((memType & MEM_SIZE_MASK) == MEM_SIZE_512K) {
 777       if (IA_TX_BUF == DFL_TX_BUFFERS)
 778         iadev->num_tx_desc = IA_TX_BUF / 2;
 779       else
 780         iadev->num_tx_desc = IA_TX_BUF;
 781       iadev->tx_buf_sz = IA_TX_BUF_SZ;
 782       if (IA_RX_BUF == DFL_RX_BUFFERS)
 783         iadev->num_rx_desc = IA_RX_BUF / 2;
 784       else
 785         iadev->num_rx_desc = IA_RX_BUF;
 786       iadev->rx_buf_sz = IA_RX_BUF_SZ;
 787    }
 788    else {
 789       if (IA_TX_BUF == DFL_TX_BUFFERS)
 790         iadev->num_tx_desc = IA_TX_BUF / 8;
 791       else
 792         iadev->num_tx_desc = IA_TX_BUF;
 793       iadev->tx_buf_sz = IA_TX_BUF_SZ;
 794       if (IA_RX_BUF == DFL_RX_BUFFERS)
 795         iadev->num_rx_desc = IA_RX_BUF / 8;
 796       else
 797         iadev->num_rx_desc = IA_RX_BUF;
 798       iadev->rx_buf_sz = IA_RX_BUF_SZ;
 799    }
 800    iadev->rx_pkt_ram = TX_PACKET_RAM + (iadev->num_tx_desc * iadev->tx_buf_sz);
 801    IF_INIT(printk("BUF: tx=%d,sz=%d rx=%d sz= %d rx_pkt_ram=%d\n",
 802          iadev->num_tx_desc, iadev->tx_buf_sz, iadev->num_rx_desc,
 803          iadev->rx_buf_sz, iadev->rx_pkt_ram);)
 804
 805 #if 0
 806    if ((memType & FE_MASK) == FE_SINGLE_MODE) {
 807       iadev->phy_type = PHY_OC3C_S;
 808    else if ((memType & FE_MASK) == FE_UTP_OPTION)
 809       iadev->phy_type = PHY_UTP155;
 810    else
 811      iadev->phy_type = PHY_OC3C_M;
 812 #endif
 813
 814    iadev->phy_type = memType & FE_MASK;
 815    IF_INIT(printk("memType = 0x%x iadev->phy_type = 0x%x\n",
 816                                          memType,iadev->phy_type);)
 817    if (iadev->phy_type == FE_25MBIT_PHY)
 818       iadev->LineRate = (u32)(((25600000/8)*26)/(27*53));
 819    else if (iadev->phy_type == FE_DS3_PHY)
 820       iadev->LineRate = (u32)(((44736000/8)*26)/(27*53));
 821    else if (iadev->phy_type == FE_E3_PHY)
 822       iadev->LineRate = (u32)(((34368000/8)*26)/(27*53));
 823    else
 824        iadev->LineRate = (u32)(ATM_OC3_PCR);
 825    IF_INIT(printk("iadev->LineRate = %d \n", iadev->LineRate);)
 826
 827 }
 828
 829 static void IaFrontEndIntr(IADEV *iadev) {
 830   volatile IA_SUNI *suni;
 831   volatile ia_mb25_t *mb25;
 832   volatile suni_pm7345_t *suni_pm7345;
 833   u32 intr_status;
 834   u_int frmr_intr;
 835
 836   if(iadev->phy_type & FE_25MBIT_PHY) {
 837      mb25 = (ia_mb25_t*)iadev->phy;
 838      iadev->carrier_detect =  Boolean(mb25->mb25_intr_status & MB25_IS_GSB);
 839   } else if (iadev->phy_type & FE_DS3_PHY) {
 840      suni_pm7345 = (suni_pm7345_t *)iadev->phy;
 841      /* clear FRMR interrupts */
 842      frmr_intr   = suni_pm7345->suni_ds3_frm_intr_stat;
 843      iadev->carrier_detect =
 844            Boolean(!(suni_pm7345->suni_ds3_frm_stat & SUNI_DS3_LOSV));
 845   } else if (iadev->phy_type & FE_E3_PHY ) {
 846      suni_pm7345 = (suni_pm7345_t *)iadev->phy;
 847      frmr_intr   = suni_pm7345->suni_e3_frm_maint_intr_ind;
 848      iadev->carrier_detect =
 849            Boolean(!(suni_pm7345->suni_e3_frm_fram_intr_ind_stat&SUNI_E3_LOS));
 850   }
 851   else {
 852      suni = (IA_SUNI *)iadev->phy;
 853      intr_status = suni->suni_rsop_status & 0xff;
 854      iadev->carrier_detect = Boolean(!(suni->suni_rsop_status & SUNI_LOSV));
 855   }
 856   if (iadev->carrier_detect)
 857     printk("IA: SUNI carrier detected\n");
 858   else
 859     printk("IA: SUNI carrier lost signal\n");
 860   return;
 861 }
 862
 863 static void ia_mb25_init (IADEV *iadev)
 864 {
 865    volatile ia_mb25_t  *mb25 = (ia_mb25_t*)iadev->phy;
 866 #if 0
 867    mb25->mb25_master_ctrl = MB25_MC_DRIC | MB25_MC_DREC | MB25_MC_ENABLED;
 868 #endif
 869    mb25->mb25_master_ctrl = MB25_MC_DRIC | MB25_MC_DREC;
 870    mb25->mb25_diag_control = 0;
 871    /*
 872     * Initialize carrier detect state
 873     */
 874    iadev->carrier_detect =  Boolean(mb25->mb25_intr_status & MB25_IS_GSB);
 875    return;
 876 }
 877
 878 static void ia_suni_pm7345_init (IADEV *iadev)
 879 {
 880    volatile suni_pm7345_t *suni_pm7345 = (suni_pm7345_t *)iadev->phy;
 881    if (iadev->phy_type & FE_DS3_PHY)
 882    {
 883       iadev->carrier_detect =
 884           Boolean(!(suni_pm7345->suni_ds3_frm_stat & SUNI_DS3_LOSV));
 885       suni_pm7345->suni_ds3_frm_intr_enbl = 0x17;
 886       suni_pm7345->suni_ds3_frm_cfg = 1;
 887       suni_pm7345->suni_ds3_tran_cfg = 1;
 888       suni_pm7345->suni_config = 0;
 889       suni_pm7345->suni_splr_cfg = 0;
 890       suni_pm7345->suni_splt_cfg = 0;
 891    }
 892    else
 893    {
 894       iadev->carrier_detect =
 895           Boolean(!(suni_pm7345->suni_e3_frm_fram_intr_ind_stat & SUNI_E3_LOS));
 896       suni_pm7345->suni_e3_frm_fram_options = 0x4;
 897       suni_pm7345->suni_e3_frm_maint_options = 0x20;
 898       suni_pm7345->suni_e3_frm_fram_intr_enbl = 0x1d;
 899       suni_pm7345->suni_e3_frm_maint_intr_enbl = 0x30;
 900       suni_pm7345->suni_e3_tran_stat_diag_options = 0x0;
 901       suni_pm7345->suni_e3_tran_fram_options = 0x1;
 902       suni_pm7345->suni_config = SUNI_PM7345_E3ENBL;
 903       suni_pm7345->suni_splr_cfg = 0x41;
 904       suni_pm7345->suni_splt_cfg = 0x41;
 905    }
 906    /*
 907     * Enable RSOP loss of signal interrupt.
 908     */
 909    suni_pm7345->suni_intr_enbl = 0x28;
 910
 911    /*
 912     * Clear error counters
 913     */
 914    suni_pm7345->suni_id_reset = 0;
 915
 916    /*
 917     * Clear "PMCTST" in master test register.
 918     */
 919    suni_pm7345->suni_master_test = 0;
 920
 921    suni_pm7345->suni_rxcp_ctrl = 0x2c;
 922    suni_pm7345->suni_rxcp_fctrl = 0x81;
 923
 924    suni_pm7345->suni_rxcp_idle_pat_h1 =
 925         suni_pm7345->suni_rxcp_idle_pat_h2 =
 926         suni_pm7345->suni_rxcp_idle_pat_h3 = 0;
 927    suni_pm7345->suni_rxcp_idle_pat_h4 = 1;
 928
 929    suni_pm7345->suni_rxcp_idle_mask_h1 = 0xff;
 930    suni_pm7345->suni_rxcp_idle_mask_h2 = 0xff;
 931    suni_pm7345->suni_rxcp_idle_mask_h3 = 0xff;
 932    suni_pm7345->suni_rxcp_idle_mask_h4 = 0xfe;
 933
 934    suni_pm7345->suni_rxcp_cell_pat_h1 =
 935         suni_pm7345->suni_rxcp_cell_pat_h2 =
 936         suni_pm7345->suni_rxcp_cell_pat_h3 = 0;
 937    suni_pm7345->suni_rxcp_cell_pat_h4 = 1;
 938
 939    suni_pm7345->suni_rxcp_cell_mask_h1 =
 940         suni_pm7345->suni_rxcp_cell_mask_h2 =
 941         suni_pm7345->suni_rxcp_cell_mask_h3 =
 942         suni_pm7345->suni_rxcp_cell_mask_h4 = 0xff;
 943
 944    suni_pm7345->suni_txcp_ctrl = 0xa4;
 945    suni_pm7345->suni_txcp_intr_en_sts = 0x10;
 946    suni_pm7345->suni_txcp_idle_pat_h5 = 0x55;
 947
 948    suni_pm7345->suni_config &= ~(SUNI_PM7345_LLB |
 949                                  SUNI_PM7345_CLB |
 950                                  SUNI_PM7345_DLB |
 951                                   SUNI_PM7345_PLB);
 952 #ifdef __SNMP__
 953    suni_pm7345->suni_rxcp_intr_en_sts |= SUNI_OOCDE;
 954 #endif /* __SNMP__ */
 955    return;
 956 }
 957
 958
 959 /***************************** IA_LIB END *****************************/
 960
 961 #ifdef CONFIG_ATM_IA_DEBUG
 962 static int tcnter = 0;
 963 static void xdump( u_char*  cp, int  length, char*  prefix )
 964 {
 965     int col, count;
 966     u_char prntBuf[120];
 967     u_char*  pBuf = prntBuf;
 968     count = 0;
 969     while(count < length){
 970         pBuf += sprintf( pBuf, "%s", prefix );
 971         for(col = 0;count + col < length && col < 16; col++){
 972             if (col != 0 && (col % 4) == 0)
 973                 pBuf += sprintf( pBuf, " " );
 974             pBuf += sprintf( pBuf, "%02X ", cp[count + col] );
 975         }
 976         while(col++ < 16){      /* pad end of buffer with blanks */
 977             if ((col % 4) == 0)
 978                 sprintf( pBuf, " " );
 979             pBuf += sprintf( pBuf, "   " );
 980         }
 981         pBuf += sprintf( pBuf, "  " );
 982         for(col = 0;count + col < length && col < 16; col++){
 983             if (isprint((int)cp[count + col]))
 984                 pBuf += sprintf( pBuf, "%c", cp[count + col] );
 985             else
 986                 pBuf += sprintf( pBuf, "." );
 987                 }
 988         sprintf( pBuf, "\n" );
 989         // SPrint(prntBuf);
 990         printk(prntBuf);
 991         count += col;
 992         pBuf = prntBuf;
 993     }
 994
 995 }  /* close xdump(... */
 996 #endif /* CONFIG_ATM_IA_DEBUG */
 997
 998
 999 static struct atm_dev *ia_boards = NULL;
1000
1001 #define ACTUAL_RAM_BASE \
1002         RAM_BASE*((iadev->mem)/(128 * 1024))
1003 #define ACTUAL_SEG_RAM_BASE \
1004         IPHASE5575_FRAG_CONTROL_RAM_BASE*((iadev->mem)/(128 * 1024))
1005 #define ACTUAL_REASS_RAM_BASE \
1006         IPHASE5575_REASS_CONTROL_RAM_BASE*((iadev->mem)/(128 * 1024))
1007
1008
1009 /*-- some utilities and memory allocation stuff will come here -------------*/
1010
1011 static void desc_dbg(IADEV *iadev) {
1012
1013   u_short tcq_wr_ptr, tcq_st_ptr, tcq_ed_ptr;
1014   u32 i;
1015   void __iomem *tmp;
1016   // regval = readl((u32)ia_cmds->maddr);
1017   tcq_wr_ptr =  readw(iadev->seg_reg+TCQ_WR_PTR);
1018   printk("B_tcq_wr = 0x%x desc = %d last desc = %d\n",
1019                      tcq_wr_ptr, readw(iadev->seg_ram+tcq_wr_ptr),
1020                      readw(iadev->seg_ram+tcq_wr_ptr-2));
1021   printk(" host_tcq_wr = 0x%x  host_tcq_rd = 0x%x \n",  iadev->host_tcq_wr,
1022                    iadev->ffL.tcq_rd);
1023   tcq_st_ptr =  readw(iadev->seg_reg+TCQ_ST_ADR);
1024   tcq_ed_ptr =  readw(iadev->seg_reg+TCQ_ED_ADR);
1025   printk("tcq_st_ptr = 0x%x    tcq_ed_ptr = 0x%x \n", tcq_st_ptr, tcq_ed_ptr);
1026   i = 0;
1027   while (tcq_st_ptr != tcq_ed_ptr) {
1028       tmp = iadev->seg_ram+tcq_st_ptr;
1029       printk("TCQ slot %d desc = %d  Addr = %p\n", i++, readw(tmp), tmp);
1030       tcq_st_ptr += 2;
1031   }
1032   for(i=0; i <iadev->num_tx_desc; i++)
1033       printk("Desc_tbl[%d] = %d \n", i, iadev->desc_tbl[i].timestamp);
1034 }
1035
1036
1037 /*----------------------------- Recieving side stuff --------------------------*/
1038
1039 static void rx_excp_rcvd(struct atm_dev *dev)
1040 {
1041 #if 0 /* closing the receiving size will cause too many excp int */
1042   IADEV *iadev;
1043   u_short state;
1044   u_short excpq_rd_ptr;
1045   //u_short *ptr;
1046   int vci, error = 1;
1047   iadev = INPH_IA_DEV(dev);
1048   state = readl(iadev->reass_reg + STATE_REG) & 0xffff;
1049   while((state & EXCPQ_EMPTY) != EXCPQ_EMPTY)
1050   { printk("state = %x \n", state);
1051         excpq_rd_ptr = readw(iadev->reass_reg + EXCP_Q_RD_PTR) & 0xffff;
1052  printk("state = %x excpq_rd_ptr = %x \n", state, excpq_rd_ptr);
1053         if (excpq_rd_ptr == *(u16*)(iadev->reass_reg + EXCP_Q_WR_PTR))
1054             IF_ERR(printk("excpq_rd_ptr is wrong!!!\n");)
1055         // TODO: update exception stat
1056         vci = readw(iadev->reass_ram+excpq_rd_ptr);
1057         error = readw(iadev->reass_ram+excpq_rd_ptr+2) & 0x0007;
1058         // pwang_test
1059         excpq_rd_ptr += 4;
1060         if (excpq_rd_ptr > (readw(iadev->reass_reg + EXCP_Q_ED_ADR)& 0xffff))
1061             excpq_rd_ptr = readw(iadev->reass_reg + EXCP_Q_ST_ADR)& 0xffff;
1062         writew( excpq_rd_ptr, iadev->reass_reg + EXCP_Q_RD_PTR);
1063         state = readl(iadev->reass_reg + STATE_REG) & 0xffff;
1064   }
1065 #endif
1066 }
1067
1068 static void free_desc(struct atm_dev *dev, int desc)
1069 {
1070         IADEV *iadev;
1071         iadev = INPH_IA_DEV(dev);
1072         writew(desc, iadev->reass_ram+iadev->rfL.fdq_wr);
1073         iadev->rfL.fdq_wr +=2;
1074         if (iadev->rfL.fdq_wr > iadev->rfL.fdq_ed)
1075                 iadev->rfL.fdq_wr =  iadev->rfL.fdq_st;
1076         writew(iadev->rfL.fdq_wr, iadev->reass_reg+FREEQ_WR_PTR);
1077 }
1078
1079
1080 static int rx_pkt(struct atm_dev *dev)
1081 {
1082         IADEV *iadev;
1083         struct atm_vcc *vcc;
1084         unsigned short status;
1085         struct rx_buf_desc __iomem *buf_desc_ptr;
1086         int desc;
1087         struct dle* wr_ptr;
1088         int len;
1089         struct sk_buff *skb;
1090         u_int buf_addr, dma_addr;
1091
1092         iadev = INPH_IA_DEV(dev);
1093         if (iadev->rfL.pcq_rd == (readw(iadev->reass_reg+PCQ_WR_PTR)&0xffff))
1094         {
1095             printk(KERN_ERR DEV_LABEL "(itf %d) Receive queue empty\n", dev->number);
1096             return -EINVAL;
1097         }
1098         /* mask 1st 3 bits to get the actual descno. */
1099         desc = readw(iadev->reass_ram+iadev->rfL.pcq_rd) & 0x1fff;
1100         IF_RX(printk("reass_ram = %p iadev->rfL.pcq_rd = 0x%x desc = %d\n",
1101                                     iadev->reass_ram, iadev->rfL.pcq_rd, desc);
1102               printk(" pcq_wr_ptr = 0x%x\n",
1103                                readw(iadev->reass_reg+PCQ_WR_PTR)&0xffff);)
1104         /* update the read pointer  - maybe we shud do this in the end*/
1105         if ( iadev->rfL.pcq_rd== iadev->rfL.pcq_ed)
1106                 iadev->rfL.pcq_rd = iadev->rfL.pcq_st;
1107         else
1108                 iadev->rfL.pcq_rd += 2;
1109         writew(iadev->rfL.pcq_rd, iadev->reass_reg+PCQ_RD_PTR);
1110
1111         /* get the buffer desc entry.
1112                 update stuff. - doesn't seem to be any update necessary
1113         */
1114         buf_desc_ptr = iadev->RX_DESC_BASE_ADDR;
1115         /* make the ptr point to the corresponding buffer desc entry */
1116         buf_desc_ptr += desc;
1117         if (!desc || (desc > iadev->num_rx_desc) ||
1118                       ((buf_desc_ptr->vc_index & 0xffff) > iadev->num_vc)) {
1119             free_desc(dev, desc);
1120             IF_ERR(printk("IA: bad descriptor desc = %d \n", desc);)
1121             return -1;
1122         }
1123         vcc = iadev->rx_open[buf_desc_ptr->vc_index & 0xffff];
1124         if (!vcc)
1125         {
1126                 free_desc(dev, desc);
1127                 printk("IA: null vcc, drop PDU\n");
1128                 return -1;
1129         }
1130
1131
1132         /* might want to check the status bits for errors */
1133         status = (u_short) (buf_desc_ptr->desc_mode);
1134         if (status & (RX_CER | RX_PTE | RX_OFL))
1135         {
1136                 atomic_inc(&vcc->stats->rx_err);
1137                 IF_ERR(printk("IA: bad packet, dropping it");)
1138                 if (status & RX_CER) {
1139                     IF_ERR(printk(" cause: packet CRC error\n");)
1140                 }
1141                 else if (status & RX_PTE) {
1142                     IF_ERR(printk(" cause: packet time out\n");)
1143                 }
1144                 else {
1145                     IF_ERR(printk(" cause: buffer over flow\n");)
1146                 }
1147                 goto out_free_desc;
1148         }
1149
1150         /*
1151                 build DLE.
1152         */
1153
1154         buf_addr = (buf_desc_ptr->buf_start_hi << 16) | buf_desc_ptr->buf_start_lo;
1155         dma_addr = (buf_desc_ptr->dma_start_hi << 16) | buf_desc_ptr->dma_start_lo;
1156         len = dma_addr - buf_addr;
1157         if (len > iadev->rx_buf_sz) {
1158            printk("Over %d bytes sdu received, dropped!!!\n", iadev->rx_buf_sz);
1159            atomic_inc(&vcc->stats->rx_err);
1160            goto out_free_desc;
1161         }
1162
1163         if (!(skb = atm_alloc_charge(vcc, len, GFP_ATOMIC))) {
1164            if (vcc->vci < 32)
1165               printk("Drop control packets\n");
1166               goto out_free_desc;
1167         }
1168         skb_put(skb,len);
1169         // pwang_test
1170         ATM_SKB(skb)->vcc = vcc;
1171         ATM_DESC(skb) = desc;
1172         skb_queue_tail(&iadev->rx_dma_q, skb);
1173
1174         /* Build the DLE structure */
1175         wr_ptr = iadev->rx_dle_q.write;
1176         wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data,
1177                 len, PCI_DMA_FROMDEVICE);
1178         wr_ptr->local_pkt_addr = buf_addr;
1179         wr_ptr->bytes = len;    /* We don't know this do we ?? */
1180         wr_ptr->mode = DMA_INT_ENABLE;
1181
1182         /* shud take care of wrap around here too. */
1183         if(++wr_ptr == iadev->rx_dle_q.end)
1184              wr_ptr = iadev->rx_dle_q.start;
1185         iadev->rx_dle_q.write = wr_ptr;
1186         udelay(1);
1187         /* Increment transaction counter */
1188         writel(1, iadev->dma+IPHASE5575_RX_COUNTER);
1189 out:    return 0;
1190 out_free_desc:
1191         free_desc(dev, desc);
1192         goto out;
1193 }
1194
1195 static void rx_intr(struct atm_dev *dev)
1196 {
1197   IADEV *iadev;
1198   u_short status;
1199   u_short state, i;
1200
1201   iadev = INPH_IA_DEV(dev);
1202   status = readl(iadev->reass_reg+REASS_INTR_STATUS_REG) & 0xffff;
1203   IF_EVENT(printk("rx_intr: status = 0x%x\n", status);)
1204   if (status & RX_PKT_RCVD)
1205   {
1206         /* do something */
1207         /* Basically recvd an interrupt for receving a packet.
1208         A descriptor would have been written to the packet complete
1209         queue. Get all the descriptors and set up dma to move the
1210         packets till the packet complete queue is empty..
1211         */
1212         state = readl(iadev->reass_reg + STATE_REG) & 0xffff;
1213         IF_EVENT(printk("Rx intr status: RX_PKT_RCVD %08x\n", status);)
1214         while(!(state & PCQ_EMPTY))
1215         {
1216              rx_pkt(dev);
1217              state = readl(iadev->reass_reg + STATE_REG) & 0xffff;
1218         }
1219         iadev->rxing = 1;
1220   }
1221   if (status & RX_FREEQ_EMPT)
1222   {
1223      if (iadev->rxing) {
1224         iadev->rx_tmp_cnt = iadev->rx_pkt_cnt;
1225         iadev->rx_tmp_jif = jiffies;
1226         iadev->rxing = 0;
1227      }
1228      else if (((jiffies - iadev->rx_tmp_jif) > 50) &&
1229                ((iadev->rx_pkt_cnt - iadev->rx_tmp_cnt) == 0)) {
1230         for (i = 1; i <= iadev->num_rx_desc; i++)
1231                free_desc(dev, i);
1232 printk("Test logic RUN!!!!\n");
1233         writew( ~(RX_FREEQ_EMPT|RX_EXCP_RCVD),iadev->reass_reg+REASS_MASK_REG);
1234         iadev->rxing = 1;
1235      }
1236      IF_EVENT(printk("Rx intr status: RX_FREEQ_EMPT %08x\n", status);)
1237   }
1238
1239   if (status & RX_EXCP_RCVD)
1240   {
1241         /* probably need to handle the exception queue also. */
1242         IF_EVENT(printk("Rx intr status: RX_EXCP_RCVD %08x\n", status);)
1243         rx_excp_rcvd(dev);
1244   }
1245
1246
1247   if (status & RX_RAW_RCVD)
1248   {
1249         /* need to handle the raw incoming cells. This deepnds on
1250         whether we have programmed to receive the raw cells or not.
1251         Else ignore. */
1252         IF_EVENT(printk("Rx intr status:  RX_RAW_RCVD %08x\n", status);)
1253   }
1254 }
1255
1256
1257 static void rx_dle_intr(struct atm_dev *dev)
1258 {
1259   IADEV *iadev;
1260   struct atm_vcc *vcc;
1261   struct sk_buff *skb;
1262   int desc;
1263   u_short state;
1264   struct dle *dle, *cur_dle;
1265   u_int dle_lp;
1266   int len;
1267   iadev = INPH_IA_DEV(dev);
1268
1269   /* free all the dles done, that is just update our own dle read pointer
1270         - do we really need to do this. Think not. */
1271   /* DMA is done, just get all the recevie buffers from the rx dma queue
1272         and push them up to the higher layer protocol. Also free the desc
1273         associated with the buffer. */
1274   dle = iadev->rx_dle_q.read;
1275   dle_lp = readl(iadev->dma+IPHASE5575_RX_LIST_ADDR) & (sizeof(struct dle)*DLE_ENTRIES - 1);
1276   cur_dle = (struct dle*)(iadev->rx_dle_q.start + (dle_lp >> 4));
1277   while(dle != cur_dle)
1278   {
1279       /* free the DMAed skb */
1280       skb = skb_dequeue(&iadev->rx_dma_q);
1281       if (!skb)
1282          goto INCR_DLE;
1283       desc = ATM_DESC(skb);
1284       free_desc(dev, desc);
1285
1286       if (!(len = skb->len))
1287       {
1288           printk("rx_dle_intr: skb len 0\n");
1289           dev_kfree_skb_any(skb);
1290       }
1291       else
1292       {
1293           struct cpcs_trailer *trailer;
1294           u_short length;
1295           struct ia_vcc *ia_vcc;
1296
1297           pci_unmap_single(iadev->pci, iadev->rx_dle_q.write->sys_pkt_addr,
1298                 len, PCI_DMA_FROMDEVICE);
1299           /* no VCC related housekeeping done as yet. lets see */
1300           vcc = ATM_SKB(skb)->vcc;
1301           if (!vcc) {
1302               printk("IA: null vcc\n");
1303               dev_kfree_skb_any(skb);
1304               goto INCR_DLE;
1305           }
1306           ia_vcc = INPH_IA_VCC(vcc);
1307           if (ia_vcc == NULL)
1308           {
1309              atomic_inc(&vcc->stats->rx_err);
1310              dev_kfree_skb_any(skb);
1311              atm_return(vcc, atm_guess_pdu2truesize(len));
1312              goto INCR_DLE;
1313            }
1314           // get real pkt length  pwang_test
1315           trailer = (struct cpcs_trailer*)((u_char *)skb->data +
1316                                  skb->len - sizeof(*trailer));
1317           length =  swap(trailer->length);
1318           if ((length > iadev->rx_buf_sz) || (length >
1319                               (skb->len - sizeof(struct cpcs_trailer))))
1320           {
1321              atomic_inc(&vcc->stats->rx_err);
1322              IF_ERR(printk("rx_dle_intr: Bad  AAL5 trailer %d (skb len %d)",
1323                                                             length, skb->len);)
1324              dev_kfree_skb_any(skb);
1325              atm_return(vcc, atm_guess_pdu2truesize(len));
1326              goto INCR_DLE;
1327           }
1328           skb_trim(skb, length);
1329
1330           /* Display the packet */
1331           IF_RXPKT(printk("\nDmad Recvd data: len = %d \n", skb->len);
1332           xdump(skb->data, skb->len, "RX: ");
1333           printk("\n");)
1334
1335           IF_RX(printk("rx_dle_intr: skb push");)
1336           vcc->push(vcc,skb);
1337           atomic_inc(&vcc->stats->rx);
1338           iadev->rx_pkt_cnt++;
1339       }
1340 INCR_DLE:
1341       if (++dle == iadev->rx_dle_q.end)
1342           dle = iadev->rx_dle_q.start;
1343   }
1344   iadev->rx_dle_q.read = dle;
1345
1346   /* if the interrupts are masked because there were no free desc available,
1347                 unmask them now. */
1348   if (!iadev->rxing) {
1349      state = readl(iadev->reass_reg + STATE_REG) & 0xffff;
1350      if (!(state & FREEQ_EMPTY)) {
1351         state = readl(iadev->reass_reg + REASS_MASK_REG) & 0xffff;
1352         writel(state & ~(RX_FREEQ_EMPT |/* RX_EXCP_RCVD |*/ RX_PKT_RCVD),
1353                                       iadev->reass_reg+REASS_MASK_REG);
1354         iadev->rxing++;
1355      }
1356   }
1357 }
1358
1359
1360 static int open_rx(struct atm_vcc *vcc)
1361 {
1362         IADEV *iadev;
1363         u_short __iomem *vc_table;
1364         u_short __iomem *reass_ptr;
1365         IF_EVENT(printk("iadev: open_rx %d.%d\n", vcc->vpi, vcc->vci);)
1366
1367         if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0;
1368         iadev = INPH_IA_DEV(vcc->dev);
1369         if (vcc->qos.rxtp.traffic_class == ATM_ABR) {
1370            if (iadev->phy_type & FE_25MBIT_PHY) {
1371                printk("IA:  ABR not support\n");
1372                return -EINVAL;
1373            }
1374         }
1375         /* Make only this VCI in the vc table valid and let all
1376                 others be invalid entries */
1377         vc_table = iadev->reass_ram+RX_VC_TABLE*iadev->memSize;
1378         vc_table += vcc->vci;
1379         /* mask the last 6 bits and OR it with 3 for 1K VCs */
1380
1381         *vc_table = vcc->vci << 6;
1382         /* Also keep a list of open rx vcs so that we can attach them with
1383                 incoming PDUs later. */
1384         if ((vcc->qos.rxtp.traffic_class == ATM_ABR) ||
1385                                 (vcc->qos.txtp.traffic_class == ATM_ABR))
1386         {
1387                 srv_cls_param_t srv_p;
1388                 init_abr_vc(iadev, &srv_p);
1389                 ia_open_abr_vc(iadev, &srv_p, vcc, 0);
1390         }
1391         else {  /* for UBR  later may need to add CBR logic */
1392                 reass_ptr = iadev->reass_ram+REASS_TABLE*iadev->memSize;
1393                 reass_ptr += vcc->vci;
1394                 *reass_ptr = NO_AAL5_PKT;
1395         }
1396
1397         if (iadev->rx_open[vcc->vci])
1398                 printk(KERN_CRIT DEV_LABEL "(itf %d): VCI %d already open\n",
1399                         vcc->dev->number, vcc->vci);
1400         iadev->rx_open[vcc->vci] = vcc;
1401         return 0;
1402 }
1403
1404 static int rx_init(struct atm_dev *dev)
1405 {
1406         IADEV *iadev;
1407         struct rx_buf_desc __iomem *buf_desc_ptr;
1408         unsigned long rx_pkt_start = 0;
1409         void *dle_addr;
1410         struct abr_vc_table  *abr_vc_table;
1411         u16 *vc_table;
1412         u16 *reass_table;
1413         u16 *ptr16;
1414         int i,j, vcsize_sel;
1415         u_short freeq_st_adr;
1416         u_short *freeq_start;
1417
1418         iadev = INPH_IA_DEV(dev);
1419   //    spin_lock_init(&iadev->rx_lock);
1420
1421         /* Allocate 4k bytes - more aligned than needed (4k boundary) */
1422         dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE,
1423                                         &iadev->rx_dle_dma);
1424         if (!dle_addr)  {
1425                 printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n");
1426                 goto err_out;
1427         }
1428         iadev->rx_dle_q.start = (struct dle*)dle_addr;
1429         iadev->rx_dle_q.read = iadev->rx_dle_q.start;
1430         iadev->rx_dle_q.write = iadev->rx_dle_q.start;
1431         iadev->rx_dle_q.end = (struct dle*)((u32)dle_addr+sizeof(struct dle)*DLE_ENTRIES);
1432         /* the end of the dle q points to the entry after the last
1433         DLE that can be used. */
1434
1435         /* write the upper 20 bits of the start address to rx list address register */
1436         writel(iadev->rx_dle_dma & 0xfffff000,
1437                iadev->dma + IPHASE5575_RX_LIST_ADDR);
1438         IF_INIT(printk("Tx Dle list addr: 0x%08x value: 0x%0x\n",
1439                       (u32)(iadev->dma+IPHASE5575_TX_LIST_ADDR),
1440                       *(u32*)(iadev->dma+IPHASE5575_TX_LIST_ADDR));
1441         printk("Rx Dle list addr: 0x%08x value: 0x%0x\n",
1442                       (u32)(iadev->dma+IPHASE5575_RX_LIST_ADDR),
1443                       *(u32*)(iadev->dma+IPHASE5575_RX_LIST_ADDR));)
1444
1445         writew(0xffff, iadev->reass_reg+REASS_MASK_REG);
1446         writew(0, iadev->reass_reg+MODE_REG);
1447         writew(RESET_REASS, iadev->reass_reg+REASS_COMMAND_REG);
1448
1449         /* Receive side control memory map
1450            -------------------------------
1451
1452                 Buffer descr    0x0000 (736 - 23K)
1453                 VP Table        0x5c00 (256 - 512)
1454                 Except q        0x5e00 (128 - 512)
1455                 Free buffer q   0x6000 (1K - 2K)
1456                 Packet comp q   0x6800 (1K - 2K)
1457                 Reass Table     0x7000 (1K - 2K)
1458                 VC Table        0x7800 (1K - 2K)
1459                 ABR VC Table    0x8000 (1K - 32K)
1460         */
1461
1462         /* Base address for Buffer Descriptor Table */
1463         writew(RX_DESC_BASE >> 16, iadev->reass_reg+REASS_DESC_BASE);
1464         /* Set the buffer size register */
1465         writew(iadev->rx_buf_sz, iadev->reass_reg+BUF_SIZE);
1466
1467         /* Initialize each entry in the Buffer Descriptor Table */
1468         iadev->RX_DESC_BASE_ADDR = iadev->reass_ram+RX_DESC_BASE*iadev->memSize;
1469         buf_desc_ptr = iadev->RX_DESC_BASE_ADDR;
1470         memset_io(buf_desc_ptr, 0, sizeof(*buf_desc_ptr));
1471         buf_desc_ptr++;
1472         rx_pkt_start = iadev->rx_pkt_ram;
1473         for(i=1; i<=iadev->num_rx_desc; i++)
1474         {
1475                 memset_io(buf_desc_ptr, 0, sizeof(*buf_desc_ptr));
1476                 buf_desc_ptr->buf_start_hi = rx_pkt_start >> 16;
1477                 buf_desc_ptr->buf_start_lo = rx_pkt_start & 0x0000ffff;
1478                 buf_desc_ptr++;
1479                 rx_pkt_start += iadev->rx_buf_sz;
1480         }
1481         IF_INIT(printk("Rx Buffer desc ptr: 0x%0x\n", (u32)(buf_desc_ptr));)
1482         i = FREE_BUF_DESC_Q*iadev->memSize;
1483         writew(i >> 16,  iadev->reass_reg+REASS_QUEUE_BASE);
1484         writew(i, iadev->reass_reg+FREEQ_ST_ADR);
1485         writew(i+iadev->num_rx_desc*sizeof(u_short),
1486                                          iadev->reass_reg+FREEQ_ED_ADR);
1487         writew(i, iadev->reass_reg+FREEQ_RD_PTR);
1488         writew(i+iadev->num_rx_desc*sizeof(u_short),
1489                                         iadev->reass_reg+FREEQ_WR_PTR);
1490         /* Fill the FREEQ with all the free descriptors. */
1491         freeq_st_adr = readw(iadev->reass_reg+FREEQ_ST_ADR);
1492         freeq_start = (u_short *)(iadev->reass_ram+freeq_st_adr);
1493         for(i=1; i<=iadev->num_rx_desc; i++)
1494         {
1495                 *freeq_start = (u_short)i;
1496                 freeq_start++;
1497         }
1498         IF_INIT(printk("freeq_start: 0x%0x\n", (u32)freeq_start);)
1499         /* Packet Complete Queue */
1500         i = (PKT_COMP_Q * iadev->memSize) & 0xffff;
1501         writew(i, iadev->reass_reg+PCQ_ST_ADR);
1502         writew(i+iadev->num_vc*sizeof(u_short), iadev->reass_reg+PCQ_ED_ADR);
1503         writew(i, iadev->reass_reg+PCQ_RD_PTR);
1504         writew(i, iadev->reass_reg+PCQ_WR_PTR);
1505
1506         /* Exception Queue */
1507         i = (EXCEPTION_Q * iadev->memSize) & 0xffff;
1508         writew(i, iadev->reass_reg+EXCP_Q_ST_ADR);
1509         writew(i + NUM_RX_EXCP * sizeof(RX_ERROR_Q),
1510                                              iadev->reass_reg+EXCP_Q_ED_ADR);
1511         writew(i, iadev->reass_reg+EXCP_Q_RD_PTR);
1512         writew(i, iadev->reass_reg+EXCP_Q_WR_PTR);
1513
1514         /* Load local copy of FREEQ and PCQ ptrs */
1515         iadev->rfL.fdq_st = readw(iadev->reass_reg+FREEQ_ST_ADR) & 0xffff;
1516         iadev->rfL.fdq_ed = readw(iadev->reass_reg+FREEQ_ED_ADR) & 0xffff ;
1517         iadev->rfL.fdq_rd = readw(iadev->reass_reg+FREEQ_RD_PTR) & 0xffff;
1518         iadev->rfL.fdq_wr = readw(iadev->reass_reg+FREEQ_WR_PTR) & 0xffff;
1519         iadev->rfL.pcq_st = readw(iadev->reass_reg+PCQ_ST_ADR) & 0xffff;
1520         iadev->rfL.pcq_ed = readw(iadev->reass_reg+PCQ_ED_ADR) & 0xffff;
1521         iadev->rfL.pcq_rd = readw(iadev->reass_reg+PCQ_RD_PTR) & 0xffff;
1522         iadev->rfL.pcq_wr = readw(iadev->reass_reg+PCQ_WR_PTR) & 0xffff;
1523
1524         IF_INIT(printk("INIT:pcq_st:0x%x pcq_ed:0x%x pcq_rd:0x%x pcq_wr:0x%x",
1525               iadev->rfL.pcq_st, iadev->rfL.pcq_ed, iadev->rfL.pcq_rd,
1526               iadev->rfL.pcq_wr);)
1527         /* just for check - no VP TBL */
1528         /* VP Table */
1529         /* writew(0x0b80, iadev->reass_reg+VP_LKUP_BASE); */
1530         /* initialize VP Table for invalid VPIs
1531                 - I guess we can write all 1s or 0x000f in the entire memory
1532                   space or something similar.
1533         */
1534
1535         /* This seems to work and looks right to me too !!! */
1536         i =  REASS_TABLE * iadev->memSize;
1537         writew((i >> 3), iadev->reass_reg+REASS_TABLE_BASE);
1538         /* initialize Reassembly table to I don't know what ???? */
1539         reass_table = (u16 *)(iadev->reass_ram+i);
1540         j = REASS_TABLE_SZ * iadev->memSize;
1541         for(i=0; i < j; i++)
1542                 *reass_table++ = NO_AAL5_PKT;
1543        i = 8*1024;
1544        vcsize_sel =  0;
1545        while (i != iadev->num_vc) {
1546           i /= 2;
1547           vcsize_sel++;
1548        }
1549        i = RX_VC_TABLE * iadev->memSize;
1550        writew(((i>>3) & 0xfff8) | vcsize_sel, iadev->reass_reg+VC_LKUP_BASE);
1551        vc_table = (u16 *)(iadev->reass_ram+RX_VC_TABLE*iadev->memSize);
1552         j = RX_VC_TABLE_SZ * iadev->memSize;
1553         for(i = 0; i < j; i++)
1554         {
1555                 /* shift the reassembly pointer by 3 + lower 3 bits of
1556                 vc_lkup_base register (=3 for 1K VCs) and the last byte
1557                 is those low 3 bits.
1558                 Shall program this later.
1559                 */
1560                 *vc_table = (i << 6) | 15;      /* for invalid VCI */
1561                 vc_table++;
1562         }
1563         /* ABR VC table */
1564         i =  ABR_VC_TABLE * iadev->memSize;
1565         writew(i >> 3, iadev->reass_reg+ABR_LKUP_BASE);
1566
1567         i = ABR_VC_TABLE * iadev->memSize;
1568         abr_vc_table = (struct abr_vc_table *)(iadev->reass_ram+i);
1569         j = REASS_TABLE_SZ * iadev->memSize;
1570         memset ((char*)abr_vc_table, 0, j * sizeof(*abr_vc_table));
1571         for(i = 0; i < j; i++) {
1572                 abr_vc_table->rdf = 0x0003;
1573                 abr_vc_table->air = 0x5eb1;
1574                 abr_vc_table++;
1575         }
1576
1577         /* Initialize other registers */
1578
1579         /* VP Filter Register set for VC Reassembly only */
1580         writew(0xff00, iadev->reass_reg+VP_FILTER);
1581         writew(0, iadev->reass_reg+XTRA_RM_OFFSET);
1582         writew(0x1,  iadev->reass_reg+PROTOCOL_ID);
1583
1584         /* Packet Timeout Count  related Registers :
1585            Set packet timeout to occur in about 3 seconds
1586            Set Packet Aging Interval count register to overflow in about 4 us
1587         */
1588         writew(0xF6F8, iadev->reass_reg+PKT_TM_CNT );
1589         ptr16 = (u16*)j;
1590         i = ((u32)ptr16 >> 6) & 0xff;
1591         ptr16  += j - 1;
1592         i |=(((u32)ptr16 << 2) & 0xff00);
1593         writew(i, iadev->reass_reg+TMOUT_RANGE);
1594         /* initiate the desc_tble */
1595         for(i=0; i<iadev->num_tx_desc;i++)
1596             iadev->desc_tbl[i].timestamp = 0;
1597
1598         /* to clear the interrupt status register - read it */
1599         readw(iadev->reass_reg+REASS_INTR_STATUS_REG);
1600
1601         /* Mask Register - clear it */
1602         writew(~(RX_FREEQ_EMPT|RX_PKT_RCVD), iadev->reass_reg+REASS_MASK_REG);
1603
1604         skb_queue_head_init(&iadev->rx_dma_q);
1605         iadev->rx_free_desc_qhead = NULL;
1606
1607         iadev->rx_open = kzalloc(4 * iadev->num_vc, GFP_KERNEL);
1608         if (!iadev->rx_open) {
1609                 printk(KERN_ERR DEV_LABEL "itf %d couldn't get free page\n",
1610                 dev->number);
1611                 goto err_free_dle;
1612         }
1613
1614         iadev->rxing = 1;
1615         iadev->rx_pkt_cnt = 0;
1616         /* Mode Register */
1617         writew(R_ONLINE, iadev->reass_reg+MODE_REG);
1618         return 0;
1619
1620 err_free_dle:
1621         pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start,
1622                             iadev->rx_dle_dma);
1623 err_out:
1624         return -ENOMEM;
1625 }
1626
1627
1628 /*
1629         The memory map suggested in appendix A and the coding for it.
1630         Keeping it around just in case we change our mind later.
1631
1632                 Buffer descr    0x0000 (128 - 4K)
1633                 UBR sched       0x1000 (1K - 4K)
1634                 UBR Wait q      0x2000 (1K - 4K)
1635                 Commn queues    0x3000 Packet Ready, Trasmit comp(0x3100)
1636                                         (128 - 256) each
1637                 extended VC     0x4000 (1K - 8K)
1638                 ABR sched       0x6000  and ABR wait queue (1K - 2K) each
1639                 CBR sched       0x7000 (as needed)
1640                 VC table        0x8000 (1K - 32K)
1641 */
1642
1643 static void tx_intr(struct atm_dev *dev)
1644 {
1645         IADEV *iadev;
1646         unsigned short status;
1647         unsigned long flags;
1648
1649         iadev = INPH_IA_DEV(dev);
1650
1651         status = readl(iadev->seg_reg+SEG_INTR_STATUS_REG);
1652         if (status & TRANSMIT_DONE){
1653
1654            IF_EVENT(printk("Tansmit Done Intr logic run\n");)
1655            spin_lock_irqsave(&iadev->tx_lock, flags);
1656            ia_tx_poll(iadev);
1657            spin_unlock_irqrestore(&iadev->tx_lock, flags);
1658            writew(TRANSMIT_DONE, iadev->seg_reg+SEG_INTR_STATUS_REG);
1659            if (iadev->close_pending)
1660                wake_up(&iadev->close_wait);
1661         }
1662         if (status & TCQ_NOT_EMPTY)
1663         {
1664             IF_EVENT(printk("TCQ_NOT_EMPTY int received\n");)
1665         }
1666 }
1667
1668 static void tx_dle_intr(struct atm_dev *dev)
1669 {
1670         IADEV *iadev;
1671         struct dle *dle, *cur_dle;
1672         struct sk_buff *skb;
1673         struct atm_vcc *vcc;
1674         struct ia_vcc  *iavcc;
1675         u_int dle_lp;
1676         unsigned long flags;
1677
1678         iadev = INPH_IA_DEV(dev);
1679         spin_lock_irqsave(&iadev->tx_lock, flags);
1680         dle = iadev->tx_dle_q.read;
1681         dle_lp = readl(iadev->dma+IPHASE5575_TX_LIST_ADDR) &
1682                                         (sizeof(struct dle)*DLE_ENTRIES - 1);
1683         cur_dle = (struct dle*)(iadev->tx_dle_q.start + (dle_lp >> 4));
1684         while (dle != cur_dle)
1685         {
1686             /* free the DMAed skb */
1687             skb = skb_dequeue(&iadev->tx_dma_q);
1688             if (!skb) break;
1689
1690             /* Revenge of the 2 dle (skb + trailer) used in ia_pkt_tx() */
1691             if (!((dle - iadev->tx_dle_q.start)%(2*sizeof(struct dle)))) {
1692                 pci_unmap_single(iadev->pci, dle->sys_pkt_addr, skb->len,
1693                                  PCI_DMA_TODEVICE);
1694             }
1695             vcc = ATM_SKB(skb)->vcc;
1696             if (!vcc) {
1697                   printk("tx_dle_intr: vcc is null\n");
1698                   spin_unlock_irqrestore(&iadev->tx_lock, flags);
1699                   dev_kfree_skb_any(skb);
1700
1701                   return;
1702             }
1703             iavcc = INPH_IA_VCC(vcc);
1704             if (!iavcc) {
1705                   printk("tx_dle_intr: iavcc is null\n");
1706                   spin_unlock_irqrestore(&iadev->tx_lock, flags);
1707                   dev_kfree_skb_any(skb);
1708                   return;
1709             }
1710             if (vcc->qos.txtp.pcr >= iadev->rate_limit) {
1711                if ((vcc->pop) && (skb->len != 0))
1712                {
1713                  vcc->pop(vcc, skb);
1714                }
1715                else {
1716                  dev_kfree_skb_any(skb);
1717                }
1718             }
1719             else { /* Hold the rate-limited skb for flow control */
1720                IA_SKB_STATE(skb) |= IA_DLED;
1721                skb_queue_tail(&iavcc->txing_skb, skb);
1722             }
1723             IF_EVENT(printk("tx_dle_intr: enque skb = 0x%x \n", (u32)skb);)
1724             if (++dle == iadev->tx_dle_q.end)
1725                  dle = iadev->tx_dle_q.start;
1726         }
1727         iadev->tx_dle_q.read = dle;
1728         spin_unlock_irqrestore(&iadev->tx_lock, flags);
1729 }
1730
1731 static int open_tx(struct atm_vcc *vcc)
1732 {
1733         struct ia_vcc *ia_vcc;
1734         IADEV *iadev;
1735         struct main_vc *vc;
1736         struct ext_vc *evc;
1737         int ret;
1738         IF_EVENT(printk("iadev: open_tx entered vcc->vci = %d\n", vcc->vci);)
1739         if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0;
1740         iadev = INPH_IA_DEV(vcc->dev);
1741
1742         if (iadev->phy_type & FE_25MBIT_PHY) {
1743            if (vcc->qos.txtp.traffic_class == ATM_ABR) {
1744                printk("IA:  ABR not support\n");
1745                return -EINVAL;
1746            }
1747           if (vcc->qos.txtp.traffic_class == ATM_CBR) {
1748                printk("IA:  CBR not support\n");
1749                return -EINVAL;
1750           }
1751         }
1752         ia_vcc =  INPH_IA_VCC(vcc);
1753         memset((caddr_t)ia_vcc, 0, sizeof(*ia_vcc));
1754         if (vcc->qos.txtp.max_sdu >
1755                          (iadev->tx_buf_sz - sizeof(struct cpcs_trailer))){
1756            printk("IA:  SDU size over (%d) the configured SDU size %d\n",
1757                   vcc->qos.txtp.max_sdu,iadev->tx_buf_sz);
1758            vcc->dev_data = NULL;
1759            kfree(ia_vcc);
1760            return -EINVAL;
1761         }
1762         ia_vcc->vc_desc_cnt = 0;
1763         ia_vcc->txing = 1;
1764
1765         /* find pcr */
1766         if (vcc->qos.txtp.max_pcr == ATM_MAX_PCR)
1767            vcc->qos.txtp.pcr = iadev->LineRate;
1768         else if ((vcc->qos.txtp.max_pcr == 0)&&( vcc->qos.txtp.pcr <= 0))
1769            vcc->qos.txtp.pcr = iadev->LineRate;
1770         else if ((vcc->qos.txtp.max_pcr > vcc->qos.txtp.pcr) && (vcc->qos.txtp.max_pcr> 0))
1771            vcc->qos.txtp.pcr = vcc->qos.txtp.max_pcr;
1772         if (vcc->qos.txtp.pcr > iadev->LineRate)
1773              vcc->qos.txtp.pcr = iadev->LineRate;
1774         ia_vcc->pcr = vcc->qos.txtp.pcr;
1775
1776         if (ia_vcc->pcr > (iadev->LineRate / 6) ) ia_vcc->ltimeout = HZ / 10;
1777         else if (ia_vcc->pcr > (iadev->LineRate / 130)) ia_vcc->ltimeout = HZ;
1778         else if (ia_vcc->pcr <= 170) ia_vcc->ltimeout = 16 * HZ;
1779         else ia_vcc->ltimeout = 2700 * HZ  / ia_vcc->pcr;
1780         if (ia_vcc->pcr < iadev->rate_limit)
1781            skb_queue_head_init (&ia_vcc->txing_skb);
1782         if (ia_vcc->pcr < iadev->rate_limit) {
1783            struct sock *sk = sk_atm(vcc);
1784
1785            if (vcc->qos.txtp.max_sdu != 0) {
1786                if (ia_vcc->pcr > 60000)
1787                   sk->sk_sndbuf = vcc->qos.txtp.max_sdu * 5;
1788                else if (ia_vcc->pcr > 2000)
1789                   sk->sk_sndbuf = vcc->qos.txtp.max_sdu * 4;
1790                else
1791                  sk->sk_sndbuf = vcc->qos.txtp.max_sdu * 3;
1792            }
1793            else
1794              sk->sk_sndbuf = 24576;
1795         }
1796
1797         vc = (struct main_vc *)iadev->MAIN_VC_TABLE_ADDR;
1798         evc = (struct ext_vc *)iadev->EXT_VC_TABLE_ADDR;
1799         vc += vcc->vci;
1800         evc += vcc->vci;
1801         memset((caddr_t)vc, 0, sizeof(*vc));
1802         memset((caddr_t)evc, 0, sizeof(*evc));
1803
1804         /* store the most significant 4 bits of vci as the last 4 bits
1805                 of first part of atm header.
1806            store the last 12 bits of vci as first 12 bits of the second
1807                 part of the atm header.
1808         */
1809         evc->atm_hdr1 = (vcc->vci >> 12) & 0x000f;
1810         evc->atm_hdr2 = (vcc->vci & 0x0fff) << 4;
1811
1812         /* check the following for different traffic classes */
1813         if (vcc->qos.txtp.traffic_class == ATM_UBR)
1814         {
1815                 vc->type = UBR;
1816                 vc->status = CRC_APPEND;
1817                 vc->acr = cellrate_to_float(iadev->LineRate);
1818                 if (vcc->qos.txtp.pcr > 0)
1819                    vc->acr = cellrate_to_float(vcc->qos.txtp.pcr);
1820                 IF_UBR(printk("UBR: txtp.pcr = 0x%x f_rate = 0x%x\n",
1821                                              vcc->qos.txtp.max_pcr,vc->acr);)
1822         }
1823         else if (vcc->qos.txtp.traffic_class == ATM_ABR)
1824         {       srv_cls_param_t srv_p;
1825                 IF_ABR(printk("Tx ABR VCC\n");)
1826                 init_abr_vc(iadev, &srv_p);
1827                 if (vcc->qos.txtp.pcr > 0)
1828                    srv_p.pcr = vcc->qos.txtp.pcr;
1829                 if (vcc->qos.txtp.min_pcr > 0) {
1830                    int tmpsum = iadev->sum_mcr+iadev->sum_cbr+vcc->qos.txtp.min_pcr;
1831                    if (tmpsum > iadev->LineRate)
1832                        return -EBUSY;
1833                    srv_p.mcr = vcc->qos.txtp.min_pcr;
1834                    iadev->sum_mcr += vcc->qos.txtp.min_pcr;
1835                 }
1836                 else srv_p.mcr = 0;
1837                 if (vcc->qos.txtp.icr)
1838                    srv_p.icr = vcc->qos.txtp.icr;
1839                 if (vcc->qos.txtp.tbe)
1840                    srv_p.tbe = vcc->qos.txtp.tbe;
1841                 if (vcc->qos.txtp.frtt)
1842                    srv_p.frtt = vcc->qos.txtp.frtt;
1843                 if (vcc->qos.txtp.rif)
1844                    srv_p.rif = vcc->qos.txtp.rif;
1845                 if (vcc->qos.txtp.rdf)
1846                    srv_p.rdf = vcc->qos.txtp.rdf;
1847                 if (vcc->qos.txtp.nrm_pres)
1848                    srv_p.nrm = vcc->qos.txtp.nrm;
1849                 if (vcc->qos.txtp.trm_pres)
1850                    srv_p.trm = vcc->qos.txtp.trm;
1851                 if (vcc->qos.txtp.adtf_pres)
1852                    srv_p.adtf = vcc->qos.txtp.adtf;
1853                 if (vcc->qos.txtp.cdf_pres)
1854                    srv_p.cdf = vcc->qos.txtp.cdf;
1855                 if (srv_p.icr > srv_p.pcr)
1856                    srv_p.icr = srv_p.pcr;
1857                 IF_ABR(printk("ABR:vcc->qos.txtp.max_pcr = %d  mcr = %d\n",
1858                                                       srv_p.pcr, srv_p.mcr);)
1859                 ia_open_abr_vc(iadev, &srv_p, vcc, 1);
1860         } else if (vcc->qos.txtp.traffic_class == ATM_CBR) {
1861                 if (iadev->phy_type & FE_25MBIT_PHY) {
1862                     printk("IA:  CBR not support\n");
1863                     return -EINVAL;
1864                 }
1865                 if (vcc->qos.txtp.max_pcr > iadev->LineRate) {
1866                    IF_CBR(printk("PCR is not availble\n");)
1867                    return -1;
1868                 }
1869                 vc->type = CBR;
1870                 vc->status = CRC_APPEND;
1871                 if ((ret = ia_cbr_setup (iadev, vcc)) < 0) {
1872                     return ret;
1873                 }
1874        }
1875         else
1876            printk("iadev:  Non UBR, ABR and CBR traffic not supportedn");
1877
1878         iadev->testTable[vcc->vci]->vc_status |= VC_ACTIVE;
1879         IF_EVENT(printk("ia open_tx returning \n");)
1880         return 0;
1881 }
1882
1883
1884 static int tx_init(struct atm_dev *dev)
1885 {
1886         IADEV *iadev;
1887         struct tx_buf_desc *buf_desc_ptr;
1888         unsigned int tx_pkt_start;
1889         void *dle_addr;
1890         int i;
1891         u_short tcq_st_adr;
1892         u_short *tcq_start;
1893         u_short prq_st_adr;
1894         u_short *prq_start;
1895         struct main_vc *vc;
1896         struct ext_vc *evc;
1897         u_short tmp16;
1898         u32 vcsize_sel;
1899
1900         iadev = INPH_IA_DEV(dev);
1901         spin_lock_init(&iadev->tx_lock);
1902
1903         IF_INIT(printk("Tx MASK REG: 0x%0x\n",
1904                                 readw(iadev->seg_reg+SEG_MASK_REG));)
1905
1906         /* Allocate 4k (boundary aligned) bytes */
1907         dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE,
1908                                         &iadev->tx_dle_dma);
1909         if (!dle_addr)  {
1910                 printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n");
1911                 goto err_out;
1912         }
1913         iadev->tx_dle_q.start = (struct dle*)dle_addr;
1914         iadev->tx_dle_q.read = iadev->tx_dle_q.start;
1915         iadev->tx_dle_q.write = iadev->tx_dle_q.start;
1916         iadev->tx_dle_q.end = (struct dle*)((u32)dle_addr+sizeof(struct dle)*DLE_ENTRIES);
1917
1918         /* write the upper 20 bits of the start address to tx list address register */
1919         writel(iadev->tx_dle_dma & 0xfffff000,
1920                iadev->dma + IPHASE5575_TX_LIST_ADDR);
1921         writew(0xffff, iadev->seg_reg+SEG_MASK_REG);
1922         writew(0, iadev->seg_reg+MODE_REG_0);
1923         writew(RESET_SEG, iadev->seg_reg+SEG_COMMAND_REG);
1924         iadev->MAIN_VC_TABLE_ADDR = iadev->seg_ram+MAIN_VC_TABLE*iadev->memSize;
1925         iadev->EXT_VC_TABLE_ADDR = iadev->seg_ram+EXT_VC_TABLE*iadev->memSize;
1926         iadev->ABR_SCHED_TABLE_ADDR=iadev->seg_ram+ABR_SCHED_TABLE*iadev->memSize;
1927
1928         /*
1929            Transmit side control memory map
1930            --------------------------------
1931          Buffer descr   0x0000 (128 - 4K)
1932          Commn queues   0x1000  Transmit comp, Packet ready(0x1400)
1933                                         (512 - 1K) each
1934                                         TCQ - 4K, PRQ - 5K
1935          CBR Table      0x1800 (as needed) - 6K
1936          UBR Table      0x3000 (1K - 4K) - 12K
1937          UBR Wait queue 0x4000 (1K - 4K) - 16K
1938          ABR sched      0x5000  and ABR wait queue (1K - 2K) each
1939                                 ABR Tbl - 20K, ABR Wq - 22K
1940          extended VC    0x6000 (1K - 8K) - 24K
1941          VC Table       0x8000 (1K - 32K) - 32K
1942
1943         Between 0x2000 (8K) and 0x3000 (12K) there is 4K space left for VBR Tbl
1944         and Wait q, which can be allotted later.
1945         */
1946
1947         /* Buffer Descriptor Table Base address */
1948         writew(TX_DESC_BASE, iadev->seg_reg+SEG_DESC_BASE);
1949
1950         /* initialize each entry in the buffer descriptor table */
1951         buf_desc_ptr =(struct tx_buf_desc *)(iadev->seg_ram+TX_DESC_BASE);
1952         memset((caddr_t)buf_desc_ptr, 0, sizeof(*buf_desc_ptr));
1953         buf_desc_ptr++;
1954         tx_pkt_start = TX_PACKET_RAM;
1955         for(i=1; i<=iadev->num_tx_desc; i++)
1956         {
1957                 memset((caddr_t)buf_desc_ptr, 0, sizeof(*buf_desc_ptr));
1958                 buf_desc_ptr->desc_mode = AAL5;
1959                 buf_desc_ptr->buf_start_hi = tx_pkt_start >> 16;
1960                 buf_desc_ptr->buf_start_lo = tx_pkt_start & 0x0000ffff;
1961                 buf_desc_ptr++;
1962                 tx_pkt_start += iadev->tx_buf_sz;
1963         }
1964         iadev->tx_buf = kmalloc(iadev->num_tx_desc*sizeof(struct cpcs_trailer_desc), GFP_KERNEL);
1965         if (!iadev->tx_buf) {
1966             printk(KERN_ERR DEV_LABEL " couldn't get mem\n");
1967             goto err_free_dle;
1968         }
1969         for (i= 0; i< iadev->num_tx_desc; i++)
1970         {
1971             struct cpcs_trailer *cpcs;
1972
1973             cpcs = kmalloc(sizeof(*cpcs), GFP_KERNEL|GFP_DMA);
1974             if(!cpcs) {
1975                 printk(KERN_ERR DEV_LABEL " couldn't get freepage\n");
1976                 goto err_free_tx_bufs;
1977             }
1978             iadev->tx_buf[i].cpcs = cpcs;
1979             iadev->tx_buf[i].dma_addr = pci_map_single(iadev->pci,
1980                 cpcs, sizeof(*cpcs), PCI_DMA_TODEVICE);
1981         }
1982         iadev->desc_tbl = kmalloc(iadev->num_tx_desc *
1983                                    sizeof(struct desc_tbl_t), GFP_KERNEL);
1984         if (!iadev->desc_tbl) {
1985                 printk(KERN_ERR DEV_LABEL " couldn't get mem\n");
1986                 goto err_free_all_tx_bufs;
1987         }
1988
1989         /* Communication Queues base address */
1990         i = TX_COMP_Q * iadev->memSize;
1991         writew(i >> 16, iadev->seg_reg+SEG_QUEUE_BASE);
1992
1993         /* Transmit Complete Queue */
1994         writew(i, iadev->seg_reg+TCQ_ST_ADR);
1995         writew(i, iadev->seg_reg+TCQ_RD_PTR);
1996         writew(i+iadev->num_tx_desc*sizeof(u_short),iadev->seg_reg+TCQ_WR_PTR);
1997         iadev->host_tcq_wr = i + iadev->num_tx_desc*sizeof(u_short);
1998         writew(i+2 * iadev->num_tx_desc * sizeof(u_short),
1999                                               iadev->seg_reg+TCQ_ED_ADR);
2000         /* Fill the TCQ with all the free descriptors. */
2001         tcq_st_adr = readw(iadev->seg_reg+TCQ_ST_ADR);
2002         tcq_start = (u_short *)(iadev->seg_ram+tcq_st_adr);
2003         for(i=1; i<=iadev->num_tx_desc; i++)
2004         {
2005                 *tcq_start = (u_short)i;
2006                 tcq_start++;
2007         }
2008
2009         /* Packet Ready Queue */
2010         i = PKT_RDY_Q * iadev->memSize;
2011         writew(i, iadev->seg_reg+PRQ_ST_ADR);
2012         writew(i+2 * iadev->num_tx_desc * sizeof(u_short),
2013                                               iadev->seg_reg+PRQ_ED_ADR);
2014         writew(i, iadev->seg_reg+PRQ_RD_PTR);
2015         writew(i, iadev->seg_reg+PRQ_WR_PTR);
2016
2017         /* Load local copy of PRQ and TCQ ptrs */
2018         iadev->ffL.prq_st = readw(iadev->seg_reg+PRQ_ST_ADR) & 0xffff;
2019         iadev->ffL.prq_ed = readw(iadev->seg_reg+PRQ_ED_ADR) & 0xffff;
2020         iadev->ffL.prq_wr = readw(iadev->seg_reg+PRQ_WR_PTR) & 0xffff;
2021
2022         iadev->ffL.tcq_st = readw(iadev->seg_reg+TCQ_ST_ADR) & 0xffff;
2023         iadev->ffL.tcq_ed = readw(iadev->seg_reg+TCQ_ED_ADR) & 0xffff;
2024         iadev->ffL.tcq_rd = readw(iadev->seg_reg+TCQ_RD_PTR) & 0xffff;
2025
2026         /* Just for safety initializing the queue to have desc 1 always */
2027         /* Fill the PRQ with all the free descriptors. */
2028         prq_st_adr = readw(iadev->seg_reg+PRQ_ST_ADR);
2029         prq_start = (u_short *)(iadev->seg_ram+prq_st_adr);
2030         for(i=1; i<=iadev->num_tx_desc; i++)
2031         {
2032                 *prq_start = (u_short)0;        /* desc 1 in all entries */
2033                 prq_start++;
2034         }
2035         /* CBR Table */
2036         IF_INIT(printk("Start CBR Init\n");)
2037 #if 1  /* for 1K VC board, CBR_PTR_BASE is 0 */
2038         writew(0,iadev->seg_reg+CBR_PTR_BASE);
2039 #else /* Charlie's logic is wrong ? */
2040         tmp16 = (iadev->seg_ram+CBR_SCHED_TABLE*iadev->memSize)>>17;
2041         IF_INIT(printk("cbr_ptr_base = 0x%x ", tmp16);)
2042         writew(tmp16,iadev->seg_reg+CBR_PTR_BASE);
2043 #endif
2044
2045         IF_INIT(printk("value in register = 0x%x\n",
2046                                    readw(iadev->seg_reg+CBR_PTR_BASE));)
2047         tmp16 = (CBR_SCHED_TABLE*iadev->memSize) >> 1;
2048         writew(tmp16, iadev->seg_reg+CBR_TAB_BEG);
2049         IF_INIT(printk("cbr_tab_beg = 0x%x in reg = 0x%x \n", tmp16,
2050                                         readw(iadev->seg_reg+CBR_TAB_BEG));)
2051         writew(tmp16, iadev->seg_reg+CBR_TAB_END+1); // CBR_PTR;
2052         tmp16 = (CBR_SCHED_TABLE*iadev->memSize + iadev->num_vc*6 - 2) >> 1;
2053         writew(tmp16, iadev->seg_reg+CBR_TAB_END);
2054         IF_INIT(printk("iadev->seg_reg = 0x%x CBR_PTR_BASE = 0x%x\n",
2055                (u32)iadev->seg_reg, readw(iadev->seg_reg+CBR_PTR_BASE));)
2056         IF_INIT(printk("CBR_TAB_BEG = 0x%x, CBR_TAB_END = 0x%x, CBR_PTR = 0x%x\n",
2057           readw(iadev->seg_reg+CBR_TAB_BEG), readw(iadev->seg_reg+CBR_TAB_END),
2058           readw(iadev->seg_reg+CBR_TAB_END+1));)
2059
2060         /* Initialize the CBR Schedualing Table */
2061         memset_io(iadev->seg_ram+CBR_SCHED_TABLE*iadev->memSize,
2062                                                           0, iadev->num_vc*6);
2063         iadev->CbrRemEntries = iadev->CbrTotEntries = iadev->num_vc*3;
2064         iadev->CbrEntryPt = 0;
2065         iadev->Granularity = MAX_ATM_155 / iadev->CbrTotEntries;
2066         iadev->NumEnabledCBR = 0;
2067
2068         /* UBR scheduling Table and wait queue */
2069         /* initialize all bytes of UBR scheduler table and wait queue to 0
2070                 - SCHEDSZ is 1K (# of entries).
2071                 - UBR Table size is 4K
2072                 - UBR wait queue is 4K
2073            since the table and wait queues are contiguous, all the bytes
2074            can be initialized by one memeset.
2075         */
2076
2077         vcsize_sel = 0;
2078         i = 8*1024;
2079         while (i != iadev->num_vc) {
2080           i /= 2;
2081           vcsize_sel++;
2082         }
2083
2084         i = MAIN_VC_TABLE * iadev->memSize;
2085         writew(vcsize_sel | ((i >> 8) & 0xfff8),iadev->seg_reg+VCT_BASE);
2086         i =  EXT_VC_TABLE * iadev->memSize;
2087         writew((i >> 8) & 0xfffe, iadev->seg_reg+VCTE_BASE);
2088         i = UBR_SCHED_TABLE * iadev->memSize;
2089         writew((i & 0xffff) >> 11,  iadev->seg_reg+UBR_SBPTR_BASE);
2090         i = UBR_WAIT_Q * iadev->memSize;
2091         writew((i >> 7) & 0xffff,  iadev->seg_reg+UBRWQ_BASE);
2092         memset((caddr_t)(iadev->seg_ram+UBR_SCHED_TABLE*iadev->memSize),
2093                                                        0, iadev->num_vc*8);
2094         /* ABR scheduling Table(0x5000-0x57ff) and wait queue(0x5800-0x5fff)*/
2095         /* initialize all bytes of ABR scheduler table and wait queue to 0
2096                 - SCHEDSZ is 1K (# of entries).
2097                 - ABR Table size is 2K
2098                 - ABR wait queue is 2K
2099            since the table and wait queues are contiguous, all the bytes
2100            can be intialized by one memeset.
2101         */
2102         i = ABR_SCHED_TABLE * iadev->memSize;
2103         writew((i >> 11) & 0xffff, iadev->seg_reg+ABR_SBPTR_BASE);
2104         i = ABR_WAIT_Q * iadev->memSize;
2105         writew((i >> 7) & 0xffff, iadev->seg_reg+ABRWQ_BASE);
2106
2107         i = ABR_SCHED_TABLE*iadev->memSize;
2108         memset((caddr_t)(iadev->seg_ram+i),  0, iadev->num_vc*4);
2109         vc = (struct main_vc *)iadev->MAIN_VC_TABLE_ADDR;
2110         evc = (struct ext_vc *)iadev->EXT_VC_TABLE_ADDR;
2111         iadev->testTable = kmalloc(sizeof(long)*iadev->num_vc, GFP_KERNEL);
2112         if (!iadev->testTable) {
2113            printk("Get freepage  failed\n");
2114            goto err_free_desc_tbl;
2115         }
2116         for(i=0; i<iadev->num_vc; i++)
2117         {
2118                 memset((caddr_t)vc, 0, sizeof(*vc));
2119                 memset((caddr_t)evc, 0, sizeof(*evc));
2120                 iadev->testTable[i] = kmalloc(sizeof(struct testTable_t),
2121                                                 GFP_KERNEL);
2122                 if (!iadev->testTable[i])
2123                         goto err_free_test_tables;
2124                 iadev->testTable[i]->lastTime = 0;
2125                 iadev->testTable[i]->fract = 0;
2126                 iadev->testTable[i]->vc_status = VC_UBR;
2127                 vc++;
2128                 evc++;
2129         }
2130
2131         /* Other Initialization */
2132
2133         /* Max Rate Register */
2134         if (iadev->phy_type & FE_25MBIT_PHY) {
2135            writew(RATE25, iadev->seg_reg+MAXRATE);
2136            writew((UBR_EN | (0x23 << 2)), iadev->seg_reg+STPARMS);
2137         }
2138         else {
2139            writew(cellrate_to_float(iadev->LineRate),iadev->seg_reg+MAXRATE);
2140            writew((UBR_EN | ABR_EN | (0x23 << 2)), iadev->seg_reg+STPARMS);
2141         }
2142         /* Set Idle Header Reigisters to be sure */
2143         writew(0, iadev->seg_reg+IDLEHEADHI);
2144         writew(0, iadev->seg_reg+IDLEHEADLO);
2145
2146         /* Program ABR UBR Priority Register  as  PRI_ABR_UBR_EQUAL */
2147         writew(0xaa00, iadev->seg_reg+ABRUBR_ARB);
2148
2149         iadev->close_pending = 0;
2150         init_waitqueue_head(&iadev->close_wait);
2151         init_waitqueue_head(&iadev->timeout_wait);
2152         skb_queue_head_init(&iadev->tx_dma_q);
2153         ia_init_rtn_q(&iadev->tx_return_q);
2154
2155         /* RM Cell Protocol ID and Message Type */
2156         writew(RM_TYPE_4_0, iadev->seg_reg+RM_TYPE);
2157         skb_queue_head_init (&iadev->tx_backlog);
2158
2159         /* Mode Register 1 */
2160         writew(MODE_REG_1_VAL, iadev->seg_reg+MODE_REG_1);
2161
2162         /* Mode Register 0 */
2163         writew(T_ONLINE, iadev->seg_reg+MODE_REG_0);
2164
2165         /* Interrupt Status Register - read to clear */
2166         readw(iadev->seg_reg+SEG_INTR_STATUS_REG);
2167
2168         /* Interrupt Mask Reg- don't mask TCQ_NOT_EMPTY interrupt generation */
2169         writew(~(TRANSMIT_DONE | TCQ_NOT_EMPTY), iadev->seg_reg+SEG_MASK_REG);
2170         writew(TRANSMIT_DONE, iadev->seg_reg+SEG_INTR_STATUS_REG);
2171         iadev->tx_pkt_cnt = 0;
2172         iadev->rate_limit = iadev->LineRate / 3;
2173
2174         return 0;
2175
2176 err_free_test_tables:
2177         while (--i >= 0)
2178                 kfree(iadev->testTable[i]);
2179         kfree(iadev->testTable);
2180 err_free_desc_tbl:
2181         kfree(iadev->desc_tbl);
2182 err_free_all_tx_bufs:
2183         i = iadev->num_tx_desc;
2184 err_free_tx_bufs:
2185         while (--i >= 0) {
2186                 struct cpcs_trailer_desc *desc = iadev->tx_buf + i;
2187
2188                 pci_unmap_single(iadev->pci, desc->dma_addr,
2189                         sizeof(*desc->cpcs), PCI_DMA_TODEVICE);
2190                 kfree(desc->cpcs);
2191         }
2192         kfree(iadev->tx_buf);
2193 err_free_dle:
2194         pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start,
2195                             iadev->tx_dle_dma);
2196 err_out:
2197         return -ENOMEM;
2198 }
2199
2200 static irqreturn_t ia_int(int irq, void *dev_id)
2201 {
2202    struct atm_dev *dev;
2203    IADEV *iadev;
2204    unsigned int status;
2205    int handled = 0;
2206
2207    dev = dev_id;
2208    iadev = INPH_IA_DEV(dev);
2209    while( (status = readl(iadev->reg+IPHASE5575_BUS_STATUS_REG) & 0x7f))
2210    {
2211         handled = 1;
2212         IF_EVENT(printk("ia_int: status = 0x%x\n", status);)
2213         if (status & STAT_REASSINT)
2214         {
2215            /* do something */
2216            IF_EVENT(printk("REASSINT Bus status reg: %08x\n", status);)
2217            rx_intr(dev);
2218         }
2219         if (status & STAT_DLERINT)
2220         {
2221            /* Clear this bit by writing a 1 to it. */
2222            *(u_int *)(iadev->reg+IPHASE5575_BUS_STATUS_REG) = STAT_DLERINT;
2223            rx_dle_intr(dev);
2224         }
2225         if (status & STAT_SEGINT)
2226         {
2227            /* do something */
2228            IF_EVENT(printk("IA: tx_intr \n");)
2229            tx_intr(dev);
2230         }
2231         if (status & STAT_DLETINT)
2232         {
2233            *(u_int *)(iadev->reg+IPHASE5575_BUS_STATUS_REG) = STAT_DLETINT;
2234            tx_dle_intr(dev);
2235         }
2236         if (status & (STAT_FEINT | STAT_ERRINT | STAT_MARKINT))
2237         {
2238            if (status & STAT_FEINT)
2239                IaFrontEndIntr(iadev);
2240         }
2241    }
2242    return IRQ_RETVAL(handled);
2243 }
2244
2245
2246
2247 /*----------------------------- entries --------------------------------*/
2248 static int get_esi(struct atm_dev *dev)
2249 {
2250         IADEV *iadev;
2251         int i;
2252         u32 mac1;
2253         u16 mac2;
2254
2255         iadev = INPH_IA_DEV(dev);
2256         mac1 = cpu_to_be32(le32_to_cpu(readl(
2257                                 iadev->reg+IPHASE5575_MAC1)));
2258         mac2 = cpu_to_be16(le16_to_cpu(readl(iadev->reg+IPHASE5575_MAC2)));
2259         IF_INIT(printk("ESI: 0x%08x%04x\n", mac1, mac2);)
2260         for (i=0; i<MAC1_LEN; i++)
2261                 dev->esi[i] = mac1 >>(8*(MAC1_LEN-1-i));
2262
2263         for (i=0; i<MAC2_LEN; i++)
2264                 dev->esi[i+MAC1_LEN] = mac2 >>(8*(MAC2_LEN - 1 -i));
2265         return 0;
2266 }
2267
2268 static int reset_sar(struct atm_dev *dev)
2269 {
2270         IADEV *iadev;
2271         int i, error = 1;
2272         unsigned int pci[64];
2273
2274         iadev = INPH_IA_DEV(dev);
2275         for(i=0; i<64; i++)
2276           if ((error = pci_read_config_dword(iadev->pci,
2277                                 i*4, &pci[i])) != PCIBIOS_SUCCESSFUL)
2278               return error;
2279         writel(0, iadev->reg+IPHASE5575_EXT_RESET);
2280         for(i=0; i<64; i++)
2281           if ((error = pci_write_config_dword(iadev->pci,
2282                                         i*4, pci[i])) != PCIBIOS_SUCCESSFUL)
2283             return error;
2284         udelay(5);
2285         return 0;
2286 }
2287
2288
2289 static int __devinit ia_init(struct atm_dev *dev)
2290 {
2291         IADEV *iadev;
2292         unsigned long real_base;
2293         void __iomem *base;
2294         unsigned short command;
2295         int error, i;
2296
2297         /* The device has been identified and registered. Now we read
2298            necessary configuration info like memory base address,
2299            interrupt number etc */
2300
2301         IF_INIT(printk(">ia_init\n");)
2302         dev->ci_range.vpi_bits = 0;
2303         dev->ci_range.vci_bits = NR_VCI_LD;
2304
2305         iadev = INPH_IA_DEV(dev);
2306         real_base = pci_resource_start (iadev->pci, 0);
2307         iadev->irq = iadev->pci->irq;
2308
2309         error = pci_read_config_word(iadev->pci, PCI_COMMAND, &command);
2310         if (error) {
2311                 printk(KERN_ERR DEV_LABEL "(itf %d): init error 0x%x\n",
2312                                 dev->number,error);
2313                 return -EINVAL;
2314         }
2315         IF_INIT(printk(DEV_LABEL "(itf %d): rev.%d,realbase=0x%lx,irq=%d\n",
2316                         dev->number, iadev->pci->revision, real_base, iadev->irq);)
2317
2318         /* find mapping size of board */
2319
2320         iadev->pci_map_size = pci_resource_len(iadev->pci, 0);
2321
2322         if (iadev->pci_map_size == 0x100000){
2323           iadev->num_vc = 4096;
2324           dev->ci_range.vci_bits = NR_VCI_4K_LD;
2325           iadev->memSize = 4;
2326         }
2327         else if (iadev->pci_map_size == 0x40000) {
2328           iadev->num_vc = 1024;
2329           iadev->memSize = 1;
2330         }
2331         else {
2332            printk("Unknown pci_map_size = 0x%x\n", iadev->pci_map_size);
2333            return -EINVAL;
2334         }
2335         IF_INIT(printk (DEV_LABEL "map size: %i\n", iadev->pci_map_size);)
2336
2337         /* enable bus mastering */
2338         pci_set_master(iadev->pci);
2339
2340         /*
2341          * Delay at least 1us before doing any mem accesses (how 'bout 10?)
2342          */
2343         udelay(10);
2344
2345         /* mapping the physical address to a virtual address in address space */
2346         base = ioremap(real_base,iadev->pci_map_size);  /* ioremap is not resolved ??? */
2347
2348         if (!base)
2349         {
2350                 printk(DEV_LABEL " (itf %d): can't set up page mapping\n",
2351                             dev->number);
2352                 return error;
2353         }
2354         IF_INIT(printk(DEV_LABEL " (itf %d): rev.%d,base=%p,irq=%d\n",
2355                         dev->number, iadev->pci->revision, base, iadev->irq);)
2356
2357         /* filling the iphase dev structure */
2358         iadev->mem = iadev->pci_map_size /2;
2359         iadev->real_base = real_base;
2360         iadev->base = base;
2361
2362         /* Bus Interface Control Registers */
2363         iadev->reg = base + REG_BASE;
2364         /* Segmentation Control Registers */
2365         iadev->seg_reg = base + SEG_BASE;
2366         /* Reassembly Control Registers */
2367         iadev->reass_reg = base + REASS_BASE;
2368         /* Front end/ DMA control registers */
2369         iadev->phy = base + PHY_BASE;
2370         iadev->dma = base + PHY_BASE;
2371         /* RAM - Segmentation RAm and Reassembly RAM */
2372         iadev->ram = base + ACTUAL_RAM_BASE;
2373         iadev->seg_ram = base + ACTUAL_SEG_RAM_BASE;
2374         iadev->reass_ram = base + ACTUAL_REASS_RAM_BASE;
2375
2376         /* lets print out the above */
2377         IF_INIT(printk("Base addrs: %p %p %p \n %p %p %p %p\n",
2378           iadev->reg,iadev->seg_reg,iadev->reass_reg,
2379           iadev->phy, iadev->ram, iadev->seg_ram,
2380           iadev->reass_ram);)
2381
2382         /* lets try reading the MAC address */
2383         error = get_esi(dev);
2384         if (error) {
2385           iounmap(iadev->base);
2386           return error;
2387         }
2388         printk("IA: ");
2389         for (i=0; i < ESI_LEN; i++)
2390                 printk("%s%02X",i ? "-" : "",dev->esi[i]);
2391         printk("\n");
2392
2393         /* reset SAR */
2394         if (reset_sar(dev)) {
2395            iounmap(iadev->base);
2396            printk("IA: reset SAR fail, please try again\n");
2397            return 1;
2398         }
2399         return 0;
2400 }
2401
2402 static void ia_update_stats(IADEV *iadev) {
2403     if (!iadev->carrier_detect)
2404         return;
2405     iadev->rx_cell_cnt += readw(iadev->reass_reg+CELL_CTR0)&0xffff;
2406     iadev->rx_cell_cnt += (readw(iadev->reass_reg+CELL_CTR1) & 0xffff) << 16;
2407     iadev->drop_rxpkt +=  readw(iadev->reass_reg + DRP_PKT_CNTR ) & 0xffff;
2408     iadev->drop_rxcell += readw(iadev->reass_reg + ERR_CNTR) & 0xffff;
2409     iadev->tx_cell_cnt += readw(iadev->seg_reg + CELL_CTR_LO_AUTO)&0xffff;
2410     iadev->tx_cell_cnt += (readw(iadev->seg_reg+CELL_CTR_HIGH_AUTO)&0xffff)<<16;
2411     return;
2412 }
2413
2414 static void ia_led_timer(unsigned long arg) {
2415         unsigned long flags;
2416         static u_char blinking[8] = {0, 0, 0, 0, 0, 0, 0, 0};
2417         u_char i;
2418         static u32 ctrl_reg;
2419         for (i = 0; i < iadev_count; i++) {
2420            if (ia_dev[i]) {
2421               ctrl_reg = readl(ia_dev[i]->reg+IPHASE5575_BUS_CONTROL_REG);
2422               if (blinking[i] == 0) {
2423                  blinking[i]++;
2424                  ctrl_reg &= (~CTRL_LED);
2425                  writel(ctrl_reg, ia_dev[i]->reg+IPHASE5575_BUS_CONTROL_REG);
2426                  ia_update_stats(ia_dev[i]);
2427               }
2428               else {
2429                  blinking[i] = 0;
2430                  ctrl_reg |= CTRL_LED;
2431                  writel(ctrl_reg, ia_dev[i]->reg+IPHASE5575_BUS_CONTROL_REG);
2432                  spin_lock_irqsave(&ia_dev[i]->tx_lock, flags);
2433                  if (ia_dev[i]->close_pending)
2434                     wake_up(&ia_dev[i]->close_wait);
2435                  ia_tx_poll(ia_dev[i]);
2436                  spin_unlock_irqrestore(&ia_dev[i]->tx_lock, flags);
2437               }
2438            }
2439         }
2440         mod_timer(&ia_timer, jiffies + HZ / 4);
2441         return;
2442 }
2443
2444 static void ia_phy_put(struct atm_dev *dev, unsigned char value,
2445         unsigned long addr)
2446 {
2447         writel(value, INPH_IA_DEV(dev)->phy+addr);
2448 }
2449
2450 static unsigned char ia_phy_get(struct atm_dev *dev, unsigned long addr)
2451 {
2452         return readl(INPH_IA_DEV(dev)->phy+addr);
2453 }
2454
2455 static void ia_free_tx(IADEV *iadev)
2456 {
2457         int i;
2458
2459         kfree(iadev->desc_tbl);
2460         for (i = 0; i < iadev->num_vc; i++)
2461                 kfree(iadev->testTable[i]);
2462         kfree(iadev->testTable);
2463         for (i = 0; i < iadev->num_tx_desc; i++) {
2464                 struct cpcs_trailer_desc *desc = iadev->tx_buf + i;
2465
2466                 pci_unmap_single(iadev->pci, desc->dma_addr,
2467                         sizeof(*desc->cpcs), PCI_DMA_TODEVICE);
2468                 kfree(desc->cpcs);
2469         }
2470         kfree(iadev->tx_buf);
2471         pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start,
2472                             iadev->tx_dle_dma);
2473 }
2474
2475 static void ia_free_rx(IADEV *iadev)
2476 {
2477         kfree(iadev->rx_open);
2478         pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start,
2479                           iadev->rx_dle_dma);
2480 }
2481
2482 static int __devinit ia_start(struct atm_dev *dev)
2483 {
2484         IADEV *iadev;
2485         int error;
2486         unsigned char phy;
2487         u32 ctrl_reg;
2488         IF_EVENT(printk(">ia_start\n");)
2489         iadev = INPH_IA_DEV(dev);
2490         if (request_irq(iadev->irq, &ia_int, IRQF_SHARED, DEV_LABEL, dev)) {
2491                 printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
2492                     dev->number, iadev->irq);
2493                 error = -EAGAIN;
2494                 goto err_out;
2495         }
2496         /* @@@ should release IRQ on error */
2497         /* enabling memory + master */
2498         if ((error = pci_write_config_word(iadev->pci,
2499                                 PCI_COMMAND,
2500                                 PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER )))
2501         {
2502                 printk(KERN_ERR DEV_LABEL "(itf %d): can't enable memory+"
2503                     "master (0x%x)\n",dev->number, error);
2504                 error = -EIO;
2505                 goto err_free_irq;
2506         }
2507         udelay(10);
2508
2509         /* Maybe we should reset the front end, initialize Bus Interface Control
2510                 Registers and see. */
2511
2512         IF_INIT(printk("Bus ctrl reg: %08x\n",
2513                             readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG));)
2514         ctrl_reg = readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG);
2515         ctrl_reg = (ctrl_reg & (CTRL_LED | CTRL_FE_RST))
2516                         | CTRL_B8
2517                         | CTRL_B16
2518                         | CTRL_B32
2519                         | CTRL_B48
2520                         | CTRL_B64
2521                         | CTRL_B128
2522                         | CTRL_ERRMASK
2523                         | CTRL_DLETMASK         /* shud be removed l8r */
2524                         | CTRL_DLERMASK
2525                         | CTRL_SEGMASK
2526                         | CTRL_REASSMASK
2527                         | CTRL_FEMASK
2528                         | CTRL_CSPREEMPT;
2529
2530        writel(ctrl_reg, iadev->reg+IPHASE5575_BUS_CONTROL_REG);
2531
2532         IF_INIT(printk("Bus ctrl reg after initializing: %08x\n",
2533                            readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG));
2534            printk("Bus status reg after init: %08x\n",
2535                             readl(iadev->reg+IPHASE5575_BUS_STATUS_REG));)
2536
2537         ia_hw_type(iadev);
2538         error = tx_init(dev);
2539         if (error)
2540                 goto err_free_irq;
2541         error = rx_init(dev);
2542         if (error)
2543                 goto err_free_tx;
2544
2545         ctrl_reg = readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG);
2546         writel(ctrl_reg | CTRL_FE_RST, iadev->reg+IPHASE5575_BUS_CONTROL_REG);
2547         IF_INIT(printk("Bus ctrl reg after initializing: %08x\n",
2548                                readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG));)
2549         phy = 0; /* resolve compiler complaint */
2550         IF_INIT (
2551         if ((phy=ia_phy_get(dev,0)) == 0x30)
2552                 printk("IA: pm5346,rev.%d\n",phy&0x0f);
2553         else
2554                 printk("IA: utopia,rev.%0x\n",phy);)
2555
2556         if (iadev->phy_type &  FE_25MBIT_PHY)
2557            ia_mb25_init(iadev);
2558         else if (iadev->phy_type & (FE_DS3_PHY | FE_E3_PHY))
2559            ia_suni_pm7345_init(iadev);
2560         else {
2561                 error = suni_init(dev);
2562                 if (error)
2563                         goto err_free_rx;
2564                 /*
2565                  * Enable interrupt on loss of signal
2566                  * SUNI_RSOP_CIE - 0x10
2567                  * SUNI_RSOP_CIE_LOSE - 0x04
2568                  */
2569                 ia_phy_put(dev, ia_phy_get(dev, 0x10) | 0x04, 0x10);
2570 #ifndef MODULE
2571                 error = dev->phy->start(dev);
2572                 if (error)
2573                         goto err_free_rx;
2574 #endif
2575                 /* Get iadev->carrier_detect status */
2576                 IaFrontEndIntr(iadev);
2577         }
2578         return 0;
2579
2580 err_free_rx:
2581         ia_free_rx(iadev);
2582 err_free_tx:
2583         ia_free_tx(iadev);
2584 err_free_irq:
2585         free_irq(iadev->irq, dev);
2586 err_out:
2587         return error;
2588 }
2589
2590 static void ia_close(struct atm_vcc *vcc)
2591 {
2592         DEFINE_WAIT(wait);
2593         u16 *vc_table;
2594         IADEV *iadev;
2595         struct ia_vcc *ia_vcc;
2596         struct sk_buff *skb = NULL;
2597         struct sk_buff_head tmp_tx_backlog, tmp_vcc_backlog;
2598         unsigned long closetime, flags;
2599
2600         iadev = INPH_IA_DEV(vcc->dev);
2601         ia_vcc = INPH_IA_VCC(vcc);
2602         if (!ia_vcc) return;
2603
2604         IF_EVENT(printk("ia_close: ia_vcc->vc_desc_cnt = %d  vci = %d\n",
2605                                               ia_vcc->vc_desc_cnt,vcc->vci);)
2606         clear_bit(ATM_VF_READY,&vcc->flags);
2607         skb_queue_head_init (&tmp_tx_backlog);
2608         skb_queue_head_init (&tmp_vcc_backlog);
2609         if (vcc->qos.txtp.traffic_class != ATM_NONE) {
2610            iadev->close_pending++;
2611            prepare_to_wait(&iadev->timeout_wait, &wait, TASK_UNINTERRUPTIBLE);
2612            schedule_timeout(50);
2613            finish_wait(&iadev->timeout_wait, &wait);
2614            spin_lock_irqsave(&iadev->tx_lock, flags);
2615            while((skb = skb_dequeue(&iadev->tx_backlog))) {
2616               if (ATM_SKB(skb)->vcc == vcc){
2617                  if (vcc->pop) vcc->pop(vcc, skb);
2618                  else dev_kfree_skb_any(skb);
2619               }
2620               else
2621                  skb_queue_tail(&tmp_tx_backlog, skb);
2622            }
2623            while((skb = skb_dequeue(&tmp_tx_backlog)))
2624              skb_queue_tail(&iadev->tx_backlog, skb);
2625            IF_EVENT(printk("IA TX Done decs_cnt = %d\n", ia_vcc->vc_desc_cnt);)
2626            closetime = 300000 / ia_vcc->pcr;
2627            if (closetime == 0)
2628               closetime = 1;
2629            spin_unlock_irqrestore(&iadev->tx_lock, flags);
2630            wait_event_timeout(iadev->close_wait, (ia_vcc->vc_desc_cnt <= 0), closetime);
2631            spin_lock_irqsave(&iadev->tx_lock, flags);
2632            iadev->close_pending--;
2633            iadev->testTable[vcc->vci]->lastTime = 0;
2634            iadev->testTable[vcc->vci]->fract = 0;
2635            iadev->testTable[vcc->vci]->vc_status = VC_UBR;
2636            if (vcc->qos.txtp.traffic_class == ATM_ABR) {
2637               if (vcc->qos.txtp.min_pcr > 0)
2638                  iadev->sum_mcr -= vcc->qos.txtp.min_pcr;
2639            }
2640            if (vcc->qos.txtp.traffic_class == ATM_CBR) {
2641               ia_vcc = INPH_IA_VCC(vcc);
2642               iadev->sum_mcr -= ia_vcc->NumCbrEntry*iadev->Granularity;
2643               ia_cbrVc_close (vcc);
2644            }
2645            spin_unlock_irqrestore(&iadev->tx_lock, flags);
2646         }
2647
2648         if (vcc->qos.rxtp.traffic_class != ATM_NONE) {
2649            // reset reass table
2650            vc_table = (u16 *)(iadev->reass_ram+REASS_TABLE*iadev->memSize);
2651            vc_table += vcc->vci;
2652            *vc_table = NO_AAL5_PKT;
2653            // reset vc table
2654            vc_table = (u16 *)(iadev->reass_ram+RX_VC_TABLE*iadev->memSize);
2655            vc_table += vcc->vci;
2656            *vc_table = (vcc->vci << 6) | 15;
2657            if (vcc->qos.rxtp.traffic_class == ATM_ABR) {
2658               struct abr_vc_table __iomem *abr_vc_table =
2659                                 (iadev->reass_ram+ABR_VC_TABLE*iadev->memSize);
2660               abr_vc_table +=  vcc->vci;
2661               abr_vc_table->rdf = 0x0003;
2662               abr_vc_table->air = 0x5eb1;
2663            }
2664            // Drain the packets
2665            rx_dle_intr(vcc->dev);
2666            iadev->rx_open[vcc->vci] = NULL;
2667         }
2668         kfree(INPH_IA_VCC(vcc));
2669         ia_vcc = NULL;
2670         vcc->dev_data = NULL;
2671         clear_bit(ATM_VF_ADDR,&vcc->flags);
2672         return;
2673 }
2674
2675 static int ia_open(struct atm_vcc *vcc)
2676 {
2677         IADEV *iadev;
2678         struct ia_vcc *ia_vcc;
2679         int error;
2680         if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
2681         {
2682                 IF_EVENT(printk("ia: not partially allocated resources\n");)
2683                 vcc->dev_data = NULL;
2684         }
2685         iadev = INPH_IA_DEV(vcc->dev);
2686         if (vcc->vci != ATM_VPI_UNSPEC && vcc->vpi != ATM_VCI_UNSPEC)
2687         {
2688                 IF_EVENT(printk("iphase open: unspec part\n");)
2689                 set_bit(ATM_VF_ADDR,&vcc->flags);
2690         }
2691         if (vcc->qos.aal != ATM_AAL5)
2692                 return -EINVAL;
2693         IF_EVENT(printk(DEV_LABEL "(itf %d): open %d.%d\n",
2694                                  vcc->dev->number, vcc->vpi, vcc->vci);)
2695
2696         /* Device dependent initialization */
2697         ia_vcc = kmalloc(sizeof(*ia_vcc), GFP_KERNEL);
2698         if (!ia_vcc) return -ENOMEM;
2699         vcc->dev_data = ia_vcc;
2700
2701         if ((error = open_rx(vcc)))
2702         {
2703                 IF_EVENT(printk("iadev: error in open_rx, closing\n");)
2704                 ia_close(vcc);
2705                 return error;
2706         }
2707
2708         if ((error = open_tx(vcc)))
2709         {
2710                 IF_EVENT(printk("iadev: error in open_tx, closing\n");)
2711                 ia_close(vcc);
2712                 return error;
2713         }
2714
2715         set_bit(ATM_VF_READY,&vcc->flags);
2716
2717 #if 0
2718         {
2719            static u8 first = 1;
2720            if (first) {
2721               ia_timer.expires = jiffies + 3*HZ;
2722               add_timer(&ia_timer);
2723               first = 0;
2724            }
2725         }
2726 #endif
2727         IF_EVENT(printk("ia open returning\n");)
2728         return 0;
2729 }
2730
2731 static int ia_change_qos(struct atm_vcc *vcc, struct atm_qos *qos, int flags)
2732 {
2733         IF_EVENT(printk(">ia_change_qos\n");)
2734         return 0;
2735 }
2736
2737 static int ia_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
2738 {
2739    IA_CMDBUF ia_cmds;
2740    IADEV *iadev;
2741    int i, board;
2742    u16 __user *tmps;
2743    IF_EVENT(printk(">ia_ioctl\n");)
2744    if (cmd != IA_CMD) {
2745       if (!dev->phy->ioctl) return -EINVAL;
2746       return dev->phy->ioctl(dev,cmd,arg);
2747    }
2748    if (copy_from_user(&ia_cmds, arg, sizeof ia_cmds)) return -EFAULT;
2749    board = ia_cmds.status;
2750    if ((board < 0) || (board > iadev_count))
2751          board = 0;
2752    iadev = ia_dev[board];
2753    switch (ia_cmds.cmd) {
2754    case MEMDUMP:
2755    {
2756         switch (ia_cmds.sub_cmd) {
2757           case MEMDUMP_DEV:
2758              if (!capable(CAP_NET_ADMIN)) return -EPERM;
2759              if (copy_to_user(ia_cmds.buf, iadev, sizeof(IADEV)))
2760                 return -EFAULT;
2761              ia_cmds.status = 0;
2762              break;
2763           case MEMDUMP_SEGREG:
2764              if (!capable(CAP_NET_ADMIN)) return -EPERM;
2765              tmps = (u16 __user *)ia_cmds.buf;
2766              for(i=0; i<0x80; i+=2, tmps++)
2767                 if(put_user((u16)(readl(iadev->seg_reg+i) & 0xffff), tmps)) return -EFAULT;
2768              ia_cmds.status = 0;
2769              ia_cmds.len = 0x80;
2770              break;
2771           case MEMDUMP_REASSREG:
2772              if (!capable(CAP_NET_ADMIN)) return -EPERM;
2773              tmps = (u16 __user *)ia_cmds.buf;
2774              for(i=0; i<0x80; i+=2, tmps++)
2775                 if(put_user((u16)(readl(iadev->reass_reg+i) & 0xffff), tmps)) return -EFAULT;
2776              ia_cmds.status = 0;
2777              ia_cmds.len = 0x80;
2778              break;
2779           case MEMDUMP_FFL:
2780           {
2781              ia_regs_t       *regs_local;
2782              ffredn_t        *ffL;
2783              rfredn_t        *rfL;
2784
2785              if (!capable(CAP_NET_ADMIN)) return -EPERM;
2786              regs_local = kmalloc(sizeof(*regs_local), GFP_KERNEL);
2787              if (!regs_local) return -ENOMEM;
2788              ffL = &regs_local->ffredn;
2789              rfL = &regs_local->rfredn;
2790              /* Copy real rfred registers into the local copy */
2791              for (i=0; i<(sizeof (rfredn_t))/4; i++)
2792                 ((u_int *)rfL)[i] = readl(iadev->reass_reg + i) & 0xffff;
2793                 /* Copy real ffred registers into the local copy */
2794              for (i=0; i<(sizeof (ffredn_t))/4; i++)
2795                 ((u_int *)ffL)[i] = readl(iadev->seg_reg + i) & 0xffff;
2796
2797              if (copy_to_user(ia_cmds.buf, regs_local,sizeof(ia_regs_t))) {
2798                 kfree(regs_local);
2799                 return -EFAULT;
2800              }
2801              kfree(regs_local);
2802              printk("Board %d registers dumped\n", board);
2803              ia_cmds.status = 0;
2804          }
2805              break;
2806          case READ_REG:
2807          {
2808              if (!capable(CAP_NET_ADMIN)) return -EPERM;
2809              desc_dbg(iadev);
2810              ia_cmds.status = 0;
2811          }
2812              break;
2813          case 0x6:
2814          {
2815              ia_cmds.status = 0;
2816              printk("skb = 0x%lx\n", (long)skb_peek(&iadev->tx_backlog));
2817              printk("rtn_q: 0x%lx\n",(long)ia_deque_rtn_q(&iadev->tx_return_q));
2818          }
2819              break;
2820          case 0x8:
2821          {
2822              struct k_sonet_stats *stats;
2823              stats = &PRIV(_ia_dev[board])->sonet_stats;
2824              printk("section_bip: %d\n", atomic_read(&stats->section_bip));
2825              printk("line_bip   : %d\n", atomic_read(&stats->line_bip));
2826              printk("path_bip   : %d\n", atomic_read(&stats->path_bip));
2827              printk("line_febe  : %d\n", atomic_read(&stats->line_febe));
2828              printk("path_febe  : %d\n", atomic_read(&stats->path_febe));
2829              printk("corr_hcs   : %d\n", atomic_read(&stats->corr_hcs));
2830              printk("uncorr_hcs : %d\n", atomic_read(&stats->uncorr_hcs));
2831              printk("tx_cells   : %d\n", atomic_read(&stats->tx_cells));
2832              printk("rx_cells   : %d\n", atomic_read(&stats->rx_cells));
2833          }
2834             ia_cmds.status = 0;
2835             break;
2836          case 0x9:
2837             if (!capable(CAP_NET_ADMIN)) return -EPERM;
2838             for (i = 1; i <= iadev->num_rx_desc; i++)
2839                free_desc(_ia_dev[board], i);
2840             writew( ~(RX_FREEQ_EMPT | RX_EXCP_RCVD),
2841                                             iadev->reass_reg+REASS_MASK_REG);
2842             iadev->rxing = 1;
2843
2844             ia_cmds.status = 0;
2845             break;
2846
2847          case 0xb:
2848             if (!capable(CAP_NET_ADMIN)) return -EPERM;
2849             IaFrontEndIntr(iadev);
2850             break;
2851          case 0xa:
2852             if (!capable(CAP_NET_ADMIN)) return -EPERM;
2853          {
2854              ia_cmds.status = 0;
2855              IADebugFlag = ia_cmds.maddr;
2856              printk("New debug option loaded\n");
2857          }
2858              break;
2859          default:
2860              ia_cmds.status = 0;
2861              break;
2862       }
2863    }
2864       break;
2865    default:
2866       break;
2867
2868    }
2869    return 0;
2870 }
2871
2872 static int ia_getsockopt(struct atm_vcc *vcc, int level, int optname,
2873         void __user *optval, int optlen)
2874 {
2875         IF_EVENT(printk(">ia_getsockopt\n");)
2876         return -EINVAL;
2877 }
2878
2879 static int ia_setsockopt(struct atm_vcc *vcc, int level, int optname,
2880         void __user *optval, int optlen)
2881 {
2882         IF_EVENT(printk(">ia_setsockopt\n");)
2883         return -EINVAL;
2884 }
2885
2886 static int ia_pkt_tx (struct atm_vcc *vcc, struct sk_buff *skb) {
2887         IADEV *iadev;
2888         struct dle *wr_ptr;
2889         struct tx_buf_desc __iomem *buf_desc_ptr;
2890         int desc;
2891         int comp_code;
2892         int total_len;
2893         struct cpcs_trailer *trailer;
2894         struct ia_vcc *iavcc;
2895
2896         iadev = INPH_IA_DEV(vcc->dev);
2897         iavcc = INPH_IA_VCC(vcc);
2898         if (!iavcc->txing) {
2899            printk("discard packet on closed VC\n");
2900            if (vcc->pop)
2901                 vcc->pop(vcc, skb);
2902            else
2903                 dev_kfree_skb_any(skb);
2904            return 0;
2905         }
2906
2907         if (skb->len > iadev->tx_buf_sz - 8) {
2908            printk("Transmit size over tx buffer size\n");
2909            if (vcc->pop)
2910                  vcc->pop(vcc, skb);
2911            else
2912                  dev_kfree_skb_any(skb);
2913           return 0;
2914         }
2915         if ((u32)skb->data & 3) {
2916            printk("Misaligned SKB\n");
2917            if (vcc->pop)
2918                  vcc->pop(vcc, skb);
2919            else
2920                  dev_kfree_skb_any(skb);
2921            return 0;
2922         }
2923         /* Get a descriptor number from our free descriptor queue
2924            We get the descr number from the TCQ now, since I am using
2925            the TCQ as a free buffer queue. Initially TCQ will be
2926            initialized with all the descriptors and is hence, full.
2927         */
2928         desc = get_desc (iadev, iavcc);
2929         if (desc == 0xffff)
2930             return 1;
2931         comp_code = desc >> 13;
2932         desc &= 0x1fff;
2933
2934         if ((desc == 0) || (desc > iadev->num_tx_desc))
2935         {
2936                 IF_ERR(printk(DEV_LABEL "invalid desc for send: %d\n", desc);)
2937                 atomic_inc(&vcc->stats->tx);
2938                 if (vcc->pop)
2939                     vcc->pop(vcc, skb);
2940                 else
2941                     dev_kfree_skb_any(skb);
2942                 return 0;   /* return SUCCESS */
2943         }
2944
2945         if (comp_code)
2946         {
2947             IF_ERR(printk(DEV_LABEL "send desc:%d completion code %d error\n",
2948                                                             desc, comp_code);)
2949         }
2950
2951         /* remember the desc and vcc mapping */
2952         iavcc->vc_desc_cnt++;
2953         iadev->desc_tbl[desc-1].iavcc = iavcc;
2954         iadev->desc_tbl[desc-1].txskb = skb;
2955         IA_SKB_STATE(skb) = 0;
2956
2957         iadev->ffL.tcq_rd += 2;
2958         if (iadev->ffL.tcq_rd > iadev->ffL.tcq_ed)
2959                 iadev->ffL.tcq_rd  = iadev->ffL.tcq_st;
2960         writew(iadev->ffL.tcq_rd, iadev->seg_reg+TCQ_RD_PTR);
2961
2962         /* Put the descriptor number in the packet ready queue
2963                 and put the updated write pointer in the DLE field
2964         */
2965         *(u16*)(iadev->seg_ram+iadev->ffL.prq_wr) = desc;
2966
2967         iadev->ffL.prq_wr += 2;
2968         if (iadev->ffL.prq_wr > iadev->ffL.prq_ed)
2969                 iadev->ffL.prq_wr = iadev->ffL.prq_st;
2970
2971         /* Figure out the exact length of the packet and padding required to
2972            make it  aligned on a 48 byte boundary.  */
2973         total_len = skb->len + sizeof(struct cpcs_trailer);
2974         total_len = ((total_len + 47) / 48) * 48;
2975         IF_TX(printk("ia packet len:%d padding:%d\n", total_len, total_len - skb->len);)
2976
2977         /* Put the packet in a tx buffer */
2978         trailer = iadev->tx_buf[desc-1].cpcs;
2979         IF_TX(printk("Sent: skb = 0x%x skb->data: 0x%x len: %d, desc: %d\n",
2980                   (u32)skb, (u32)skb->data, skb->len, desc);)
2981         trailer->control = 0;
2982         /*big endian*/
2983         trailer->length = ((skb->len & 0xff) << 8) | ((skb->len & 0xff00) >> 8);
2984         trailer->crc32 = 0;     /* not needed - dummy bytes */
2985
2986         /* Display the packet */
2987         IF_TXPKT(printk("Sent data: len = %d MsgNum = %d\n",
2988                                                         skb->len, tcnter++);
2989         xdump(skb->data, skb->len, "TX: ");
2990         printk("\n");)
2991
2992         /* Build the buffer descriptor */
2993         buf_desc_ptr = iadev->seg_ram+TX_DESC_BASE;
2994         buf_desc_ptr += desc;   /* points to the corresponding entry */
2995         buf_desc_ptr->desc_mode = AAL5 | EOM_EN | APP_CRC32 | CMPL_INT;
2996         /* Huh ? p.115 of users guide describes this as a read-only register */
2997         writew(TRANSMIT_DONE, iadev->seg_reg+SEG_INTR_STATUS_REG);
2998         buf_desc_ptr->vc_index = vcc->vci;
2999         buf_desc_ptr->bytes = total_len;
3000
3001         if (vcc->qos.txtp.traffic_class == ATM_ABR)
3002            clear_lockup (vcc, iadev);
3003
3004         /* Build the DLE structure */
3005         wr_ptr = iadev->tx_dle_q.write;
3006         memset((caddr_t)wr_ptr, 0, sizeof(*wr_ptr));
3007         wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data,
3008                 skb->len, PCI_DMA_TODEVICE);
3009         wr_ptr->local_pkt_addr = (buf_desc_ptr->buf_start_hi << 16) |
3010                                                   buf_desc_ptr->buf_start_lo;
3011         /* wr_ptr->bytes = swap(total_len);     didn't seem to affect ?? */
3012         wr_ptr->bytes = skb->len;
3013
3014         /* hw bug - DLEs of 0x2d, 0x2e, 0x2f cause DMA lockup */
3015         if ((wr_ptr->bytes >> 2) == 0xb)
3016            wr_ptr->bytes = 0x30;
3017
3018         wr_ptr->mode = TX_DLE_PSI;
3019         wr_ptr->prq_wr_ptr_data = 0;
3020
3021         /* end is not to be used for the DLE q */
3022         if (++wr_ptr == iadev->tx_dle_q.end)
3023                 wr_ptr = iadev->tx_dle_q.start;
3024
3025         /* Build trailer dle */
3026         wr_ptr->sys_pkt_addr = iadev->tx_buf[desc-1].dma_addr;
3027         wr_ptr->local_pkt_addr = ((buf_desc_ptr->buf_start_hi << 16) |
3028           buf_desc_ptr->buf_start_lo) + total_len - sizeof(struct cpcs_trailer);
3029
3030         wr_ptr->bytes = sizeof(struct cpcs_trailer);
3031         wr_ptr->mode = DMA_INT_ENABLE;
3032         wr_ptr->prq_wr_ptr_data = iadev->ffL.prq_wr;
3033
3034         /* end is not to be used for the DLE q */
3035         if (++wr_ptr == iadev->tx_dle_q.end)
3036                 wr_ptr = iadev->tx_dle_q.start;
3037
3038         iadev->tx_dle_q.write = wr_ptr;
3039         ATM_DESC(skb) = vcc->vci;
3040         skb_queue_tail(&iadev->tx_dma_q, skb);
3041
3042         atomic_inc(&vcc->stats->tx);
3043         iadev->tx_pkt_cnt++;
3044         /* Increment transaction counter */
3045         writel(2, iadev->dma+IPHASE5575_TX_COUNTER);
3046
3047 #if 0
3048         /* add flow control logic */
3049         if (atomic_read(&vcc->stats->tx) % 20 == 0) {
3050           if (iavcc->vc_desc_cnt > 10) {
3051              vcc->tx_quota =  vcc->tx_quota * 3 / 4;
3052             printk("Tx1:  vcc->tx_quota = %d \n", (u32)vcc->tx_quota );
3053               iavcc->flow_inc = -1;
3054               iavcc->saved_tx_quota = vcc->tx_quota;
3055            } else if ((iavcc->flow_inc < 0) && (iavcc->vc_desc_cnt < 3)) {
3056              // vcc->tx_quota = 3 * iavcc->saved_tx_quota / 4;
3057              printk("Tx2:  vcc->tx_quota = %d \n", (u32)vcc->tx_quota );
3058               iavcc->flow_inc = 0;
3059            }
3060         }
3061 #endif
3062         IF_TX(printk("ia send done\n");)
3063         return 0;
3064 }
3065
3066 static int ia_send(struct atm_vcc *vcc, struct sk_buff *skb)
3067 {
3068         IADEV *iadev;
3069         struct ia_vcc *iavcc;
3070         unsigned long flags;
3071
3072         iadev = INPH_IA_DEV(vcc->dev);
3073         iavcc = INPH_IA_VCC(vcc);
3074         if ((!skb)||(skb->len>(iadev->tx_buf_sz-sizeof(struct cpcs_trailer))))
3075         {
3076             if (!skb)
3077                 printk(KERN_CRIT "null skb in ia_send\n");
3078             else dev_kfree_skb_any(skb);
3079             return -EINVAL;
3080         }
3081         spin_lock_irqsave(&iadev->tx_lock, flags);
3082         if (!test_bit(ATM_VF_READY,&vcc->flags)){
3083             dev_kfree_skb_any(skb);
3084             spin_unlock_irqrestore(&iadev->tx_lock, flags);
3085             return -EINVAL;
3086         }
3087         ATM_SKB(skb)->vcc = vcc;
3088
3089         if (skb_peek(&iadev->tx_backlog)) {
3090            skb_queue_tail(&iadev->tx_backlog, skb);
3091         }
3092         else {
3093            if (ia_pkt_tx (vcc, skb)) {
3094               skb_queue_tail(&iadev->tx_backlog, skb);
3095            }
3096         }
3097         spin_unlock_irqrestore(&iadev->tx_lock, flags);
3098         return 0;
3099
3100 }
3101
3102 static int ia_proc_read(struct atm_dev *dev,loff_t *pos,char *page)
3103 {
3104   int   left = *pos, n;
3105   char  *tmpPtr;
3106   IADEV *iadev = INPH_IA_DEV(dev);
3107   if(!left--) {
3108      if (iadev->phy_type == FE_25MBIT_PHY) {
3109        n = sprintf(page, "  Board Type         :  Iphase5525-1KVC-128K\n");
3110        return n;
3111      }
3112      if (iadev->phy_type == FE_DS3_PHY)
3113         n = sprintf(page, "  Board Type         :  Iphase-ATM-DS3");
3114      else if (iadev->phy_type == FE_E3_PHY)
3115         n = sprintf(page, "  Board Type         :  Iphase-ATM-E3");
3116      else if (iadev->phy_type == FE_UTP_OPTION)
3117          n = sprintf(page, "  Board Type         :  Iphase-ATM-UTP155");
3118      else
3119         n = sprintf(page, "  Board Type         :  Iphase-ATM-OC3");
3120      tmpPtr = page + n;
3121      if (iadev->pci_map_size == 0x40000)
3122         n += sprintf(tmpPtr, "-1KVC-");
3123      else
3124         n += sprintf(tmpPtr, "-4KVC-");
3125      tmpPtr = page + n;
3126      if ((iadev->memType & MEM_SIZE_MASK) == MEM_SIZE_1M)
3127         n += sprintf(tmpPtr, "1M  \n");
3128      else if ((iadev->memType & MEM_SIZE_MASK) == MEM_SIZE_512K)
3129         n += sprintf(tmpPtr, "512K\n");
3130      else
3131        n += sprintf(tmpPtr, "128K\n");
3132      return n;
3133   }
3134   if (!left) {
3135      return  sprintf(page, "  Number of Tx Buffer:  %u\n"
3136                            "  Size of Tx Buffer  :  %u\n"
3137                            "  Number of Rx Buffer:  %u\n"
3138                            "  Size of Rx Buffer  :  %u\n"
3139                            "  Packets Receiverd  :  %u\n"
3140                            "  Packets Transmitted:  %u\n"
3141                            "  Cells Received     :  %u\n"
3142                            "  Cells Transmitted  :  %u\n"
3143                            "  Board Dropped Cells:  %u\n"
3144                            "  Board Dropped Pkts :  %u\n",
3145                            iadev->num_tx_desc,  iadev->tx_buf_sz,
3146                            iadev->num_rx_desc,  iadev->rx_buf_sz,
3147                            iadev->rx_pkt_cnt,   iadev->tx_pkt_cnt,
3148                            iadev->rx_cell_cnt, iadev->tx_cell_cnt,
3149                            iadev->drop_rxcell, iadev->drop_rxpkt);
3150   }
3151   return 0;
3152 }
3153
3154 static const struct atmdev_ops ops = {
3155         .open           = ia_open,
3156         .close          = ia_close,
3157         .ioctl          = ia_ioctl,
3158         .getsockopt     = ia_getsockopt,
3159         .setsockopt     = ia_setsockopt,
3160         .send           = ia_send,
3161         .phy_put        = ia_phy_put,
3162         .phy_get        = ia_phy_get,
3163         .change_qos     = ia_change_qos,
3164         .proc_read      = ia_proc_read,
3165         .owner          = THIS_MODULE,
3166 };
3167
3168 static int __devinit ia_init_one(struct pci_dev *pdev,
3169                                  const struct pci_device_id *ent)
3170 {
3171         struct atm_dev *dev;
3172         IADEV *iadev;
3173         unsigned long flags;
3174         int ret;
3175
3176         iadev = kzalloc(sizeof(*iadev), GFP_KERNEL);
3177         if (!iadev) {
3178                 ret = -ENOMEM;
3179                 goto err_out;
3180         }
3181
3182         iadev->pci = pdev;
3183
3184         IF_INIT(printk("ia detected at bus:%d dev: %d function:%d\n",
3185                 pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));)
3186         if (pci_enable_device(pdev)) {
3187                 ret = -ENODEV;
3188                 goto err_out_free_iadev;
3189         }
3190         dev = atm_dev_register(DEV_LABEL, &ops, -1, NULL);
3191         if (!dev) {
3192                 ret = -ENOMEM;
3193                 goto err_out_disable_dev;
3194         }
3195         dev->dev_data = iadev;
3196         IF_INIT(printk(DEV_LABEL "registered at (itf :%d)\n", dev->number);)
3197         IF_INIT(printk("dev_id = 0x%x iadev->LineRate = %d \n", (u32)dev,
3198                 iadev->LineRate);)
3199
3200         ia_dev[iadev_count] = iadev;
3201         _ia_dev[iadev_count] = dev;
3202         iadev_count++;
3203         spin_lock_init(&iadev->misc_lock);
3204         /* First fixes first. I don't want to think about this now. */
3205         spin_lock_irqsave(&iadev->misc_lock, flags);
3206         if (ia_init(dev) || ia_start(dev)) {
3207                 IF_INIT(printk("IA register failed!\n");)
3208                 iadev_count--;
3209                 ia_dev[iadev_count] = NULL;
3210                 _ia_dev[iadev_count] = NULL;
3211                 spin_unlock_irqrestore(&iadev->misc_lock, flags);
3212                 ret = -EINVAL;
3213                 goto err_out_deregister_dev;
3214         }
3215         spin_unlock_irqrestore(&iadev->misc_lock, flags);
3216         IF_EVENT(printk("iadev_count = %d\n", iadev_count);)
3217
3218         iadev->next_board = ia_boards;
3219         ia_boards = dev;
3220
3221         pci_set_drvdata(pdev, dev);
3222
3223         return 0;
3224
3225 err_out_deregister_dev:
3226         atm_dev_deregister(dev);
3227 err_out_disable_dev:
3228         pci_disable_device(pdev);
3229 err_out_free_iadev:
3230         kfree(iadev);
3231 err_out:
3232         return ret;
3233 }
3234
3235 static void __devexit ia_remove_one(struct pci_dev *pdev)
3236 {
3237         struct atm_dev *dev = pci_get_drvdata(pdev);
3238         IADEV *iadev = INPH_IA_DEV(dev);
3239
3240         ia_phy_put(dev, ia_phy_get(dev,0x10) & ~(0x4), 0x10);
3241         udelay(1);
3242
3243         /* De-register device */
3244         free_irq(iadev->irq, dev);
3245         iadev_count--;
3246         ia_dev[iadev_count] = NULL;
3247         _ia_dev[iadev_count] = NULL;
3248         IF_EVENT(printk("deregistering iav at (itf:%d)\n", dev->number);)
3249         atm_dev_deregister(dev);
3250
3251         iounmap(iadev->base);
3252         pci_disable_device(pdev);
3253
3254         ia_free_rx(iadev);
3255         ia_free_tx(iadev);
3256
3257         kfree(iadev);
3258 }
3259
3260 static struct pci_device_id ia_pci_tbl[] = {
3261         { PCI_VENDOR_ID_IPHASE, 0x0008, PCI_ANY_ID, PCI_ANY_ID, },
3262         { PCI_VENDOR_ID_IPHASE, 0x0009, PCI_ANY_ID, PCI_ANY_ID, },
3263         { 0,}
3264 };
3265 MODULE_DEVICE_TABLE(pci, ia_pci_tbl);
3266
3267 static struct pci_driver ia_driver = {
3268         .name =         DEV_LABEL,
3269         .id_table =     ia_pci_tbl,
3270         .probe =        ia_init_one,
3271         .remove =       __devexit_p(ia_remove_one),
3272 };
3273
3274 static int __init ia_module_init(void)
3275 {
3276         int ret;
3277
3278         ret = pci_register_driver(&ia_driver);
3279         if (ret >= 0) {
3280                 ia_timer.expires = jiffies + 3*HZ;
3281                 add_timer(&ia_timer);
3282         } else
3283                 printk(KERN_ERR DEV_LABEL ": no adapter found\n");
3284         return ret;
3285 }
3286
3287 static void __exit ia_module_exit(void)
3288 {
3289         pci_unregister_driver(&ia_driver);
3290
3291         del_timer(&ia_timer);
3292 }
3293
3294 module_init(ia_module_init);
3295 module_exit(ia_module_exit);