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