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