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