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