?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.18pre1
[davej-history.git] / drivers / atm / eni.c
blob18c7cb35f7e9c6267064a50c0f0208d3e0cf3e92
1 /* drivers/atm/eni.c - Efficient Networks ENI155P device driver */
2
3 /* Written 1995-1999 by Werner Almesberger, EPFL LRC/ICA */
4
5
6 #include <linux/module.h>
7 #include <linux/config.h>
8 #include <linux/kernel.h>
9 #include <linux/mm.h>
10 #include <linux/pci.h>
11 #include <linux/errno.h>
12 #include <linux/atm.h>
13 #include <linux/atmdev.h>
14 #include <linux/sonet.h>
15 #include <linux/skbuff.h>
16 #include <linux/time.h>
17 #include <linux/sched.h> /* for xtime */
18 #include <linux/delay.h>
19 #include <linux/uio.h>
20 #include <linux/init.h>
21 #include <linux/atm_eni.h>
22 #include <asm/system.h>
23 #include <asm/io.h>
24 #include <asm/uaccess.h>
25 #include <asm/string.h>
26 #include <asm/byteorder.h>
27
28 #include "tonga.h"
29 #include "midway.h"
30 #include "suni.h"
31 #include "eni.h"
32
33 #ifndef __i386__
34 #ifndef ioremap_nocache
35 #define ioremap_nocache(X,Y) ioremap(X,Y)
36 #endif
37 #endif
38
39 /*
40 * TODO:
41 *
42 * Show stoppers
43 * none
44 *
45 * Minor
46 * - OAM support
47 * - fix bugs listed below
48 */
49
50 /*
51 * KNOWN BUGS:
52 *
53 * - may run into JK-JK bug and deadlock
54 * - should allocate UBR channel first
55 * - buffer space allocation algorithm is stupid
56 * (RX: should be maxSDU+maxdelay*rate
57 * TX: should be maxSDU+min(maxSDU,maxdelay*rate) )
58 * - doesn't support OAM cells
59 * - eni_put_free may hang if not putting memory fragments that _complete_
60 * 2^n block (never happens in real life, though)
61 * - keeps IRQ even if initialization fails
62 */
63
64
65 #if 0
66 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
67 #else
68 #define DPRINTK(format,args...)
69 #endif
70
71
72 #ifndef CONFIG_ATM_ENI_TUNE_BURST
73 #define CONFIG_ATM_ENI_BURST_TX_8W
74 #define CONFIG_ATM_ENI_BURST_RX_4W
75 #endif
76
77
78 #ifndef CONFIG_ATM_ENI_DEBUG
79
80
81 #define NULLCHECK(x)
82
83 #define EVENT(s,a,b)
84
85
86 static void event_dump(void)
87 {
88 }
89
90
91 #else
92
93
94 /*
95 * NULL pointer checking
96 */
97
98 #define NULLCHECK(x) \
99 if ((unsigned long) (x) < 0x30) \
100 printk(KERN_CRIT #x "==0x%lx\n",(unsigned long) (x))
101
102 /*
103 * Very extensive activity logging. Greatly improves bug detection speed but
104 * costs a few Mbps if enabled.
105 */
106
107 #define EV 64
108
109 static const char *ev[EV];
110 static unsigned long ev_a[EV],ev_b[EV];
111 static int ec = 0;
112
113
114 static void EVENT(const char *s,unsigned long a,unsigned long b)
115 {
116 ev[ec] = s;
117 ev_a[ec] = a;
118 ev_b[ec] = b;
119 ec = (ec+1) % EV;
120 }
121
122
123 static void event_dump(void)
124 {
125 int n,i;
126
127 for (n = 0; n < EV; n++) {
128 i = (ec+n) % EV;
129 printk(KERN_NOTICE);
130 printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]);
131 }
132 }
133
134
135 #endif /* CONFIG_ATM_ENI_DEBUG */
136
137
138 /*
139 * NExx must not be equal at end
140 * EExx may be equal at end
141 * xxPJOK verify validity of pointer jumps
142 * xxPMOK operating on a circular buffer of "c" words
143 */
144
145 #define NEPJOK(a0,a1,b) \
146 ((a0) < (a1) ? (b) <= (a0) || (b) > (a1) : (b) <= (a0) && (b) > (a1))
147 #define EEPJOK(a0,a1,b) \
148 ((a0) < (a1) ? (b) < (a0) || (b) >= (a1) : (b) < (a0) && (b) >= (a1))
149 #define NEPMOK(a0,d,b,c) NEPJOK(a0,(a0+d) & (c-1),b)
150 #define EEPMOK(a0,d,b,c) EEPJOK(a0,(a0+d) & (c-1),b)
151
152
153 static int tx_complete = 0,dma_complete = 0,queued = 0,requeued = 0,
154 backlogged = 0,rx_enqueued = 0,rx_dequeued = 0,pushed = 0,submitted = 0,
155 putting = 0;
156
157 static struct atm_dev *eni_boards = NULL;
158
159 static u32 *zeroes = NULL; /* aligned "magic" zeroes */
160
161 /* Read/write registers on card */
162 #define eni_in(r) readl(eni_dev->reg+(r)*4)
163 #define eni_out(v,r) writel((v),eni_dev->reg+(r)*4)
164
165
166 /*-------------------------------- utilities --------------------------------*/
167
168
169 static void dump_mem(struct eni_dev *eni_dev)
170 {
171 int i;
172
173 for (i = 0; i < eni_dev->free_len; i++)
174 printk(KERN_DEBUG " %d: 0x%lx %d\n",i,
175 eni_dev->free_list[i].start,
176 1 << eni_dev->free_list[i].order);
177 }
178
179
180 static void dump(struct atm_dev *dev)
181 {
182 struct eni_dev *eni_dev;
183
184 int i;
185
186 eni_dev = ENI_DEV(dev);
187 printk(KERN_NOTICE "Free memory\n");
188 dump_mem(eni_dev);
189 printk(KERN_NOTICE "TX buffers\n");
190 for (i = 0; i < NR_CHAN; i++)
191 if (eni_dev->tx[i].send)
192 printk(KERN_NOTICE " TX %d @ 0x%lx: %ld\n",i,
193 eni_dev->tx[i].send,eni_dev->tx[i].words*4);
194 printk(KERN_NOTICE "RX buffers\n");
195 for (i = 0; i < 1024; i++)
196 if (eni_dev->rx_map[i] && ENI_VCC(eni_dev->rx_map[i])->rx)
197 printk(KERN_NOTICE " RX %d @ 0x%lx: %ld\n",i,
198 ENI_VCC(eni_dev->rx_map[i])->recv,
199 ENI_VCC(eni_dev->rx_map[i])->words*4);
200 printk(KERN_NOTICE "----\n");
201 }
202
203
204 static void eni_put_free(struct eni_dev *eni_dev,unsigned long start,
205 unsigned long size)
206 {
207 struct eni_free *list;
208 int len,order;
209
210 DPRINTK("init 0x%lx+%ld(0x%lx)\n",start,size,size);
211 start += eni_dev->base_diff;
212 list = eni_dev->free_list;
213 len = eni_dev->free_len;
214 while (size) {
215 if (len >= eni_dev->free_list_size) {
216 printk(KERN_CRIT "eni_put_free overflow (0x%lx,%ld)\n",
217 start,size);
218 break;
219 }
220 for (order = 0; !((start | size) & (1 << order)); order++);
221 if (MID_MIN_BUF_SIZE > (1 << order)) {
222 printk(KERN_CRIT "eni_put_free: order %d too small\n",
223 order);
224 break;
225 }
226 list[len].start = start;
227 list[len].order = order;
228 len++;
229 start += 1 << order;
230 size -= 1 << order;
231 }
232 eni_dev->free_len = len;
233 /*dump_mem(eni_dev);*/
234 }
235
236
237 static unsigned long eni_alloc_mem(struct eni_dev *eni_dev,unsigned long *size)
238 {
239 struct eni_free *list;
240 unsigned long start;
241 int len,i,order,best_order,index;
242
243 list = eni_dev->free_list;
244 len = eni_dev->free_len;
245 if (*size < MID_MIN_BUF_SIZE) *size = MID_MIN_BUF_SIZE;
246 if (*size > MID_MAX_BUF_SIZE) return 0;
247 for (order = 0; (1 << order) < *size; order++);
248 DPRINTK("trying: %ld->%d\n",*size,order);
249 best_order = 65; /* we don't have more than 2^64 of anything ... */
250 index = 0; /* silence GCC */
251 for (i = 0; i < len; i++)
252 if (list[i].order == order) {
253 best_order = order;
254 index = i;
255 break;
256 }
257 else if (best_order > list[i].order && list[i].order > order) {
258 best_order = list[i].order;
259 index = i;
260 }
261 if (best_order == 65) return 0;
262 start = list[index].start-eni_dev->base_diff;
263 list[index] = list[--len];
264 eni_dev->free_len = len;
265 *size = 1 << order;
266 eni_put_free(eni_dev,start+*size,(1 << best_order)-*size);
267 DPRINTK("%ld bytes (order %d) at 0x%lx\n",*size,order,start);
268 memset_io(start,0,*size); /* never leak data */
269 /*dump_mem(eni_dev);*/
270 return start;
271 }
272
273
274 static void eni_free_mem(struct eni_dev *eni_dev,unsigned long start,
275 unsigned long size)
276 {
277 struct eni_free *list;
278 int len,i,order;
279
280 start += eni_dev->base_diff;
281 list = eni_dev->free_list;
282 len = eni_dev->free_len;
283 for (order = -1; size; order++) size >>= 1;
284 DPRINTK("eni_free_mem: 0x%lx+0x%lx (order %d)\n",start,size,order);
285 for (i = 0; i < len; i++)
286 if (list[i].start == (start^(1 << order)) &&
287 list[i].order == order) {
288 DPRINTK("match[%d]: 0x%lx/0x%lx(0x%x), %d/%d\n",i,
289 list[i].start,start,1 << order,list[i].order,order);
290 list[i] = list[--len];
291 start &= ~(unsigned long) (1 << order);
292 order++;
293 i = -1;
294 continue;
295 }
296 if (len >= eni_dev->free_list_size) {
297 printk(KERN_ALERT "eni_free_mem overflow (0x%lx,%d)\n",start,
298 order);
299 return;
300 }
301 list[len].start = start;
302 list[len].order = order;
303 eni_dev->free_len = len+1;
304 /*dump_mem(eni_dev);*/
305 }
306
307
308 /*----------------------------------- RX ------------------------------------*/
309
310
311 #define ENI_VCC_NOS ((struct atm_vcc *) 1)
312
313
314 static void rx_ident_err(struct atm_vcc *vcc)
315 {
316 struct atm_dev *dev;
317 struct eni_dev *eni_dev;
318 struct eni_vcc *eni_vcc;
319
320 dev = vcc->dev;
321 eni_dev = ENI_DEV(dev);
322 /* immediately halt adapter */
323 eni_out(eni_in(MID_MC_S) &
324 ~(MID_DMA_ENABLE | MID_TX_ENABLE | MID_RX_ENABLE),MID_MC_S);
325 /* dump useful information */
326 eni_vcc = ENI_VCC(vcc);
327 printk(KERN_ALERT DEV_LABEL "(itf %d): driver error - RX ident "
328 "mismatch\n",dev->number);
329 printk(KERN_ALERT " VCI %d, rxing %d, words %ld\n",vcc->vci,
330 eni_vcc->rxing,eni_vcc->words);
331 printk(KERN_ALERT " host descr 0x%lx, rx pos 0x%lx, descr value "
332 "0x%x\n",eni_vcc->descr,eni_vcc->rx_pos,
333 (unsigned) readl(eni_vcc->recv+eni_vcc->descr*4));
334 printk(KERN_ALERT " last 0x%p, servicing %d\n",eni_vcc->last,
335 eni_vcc->servicing);
336 EVENT("---dump ends here---\n",0,0);
337 printk(KERN_NOTICE "---recent events---\n");
338 event_dump();
339 ENI_DEV(dev)->fast = NULL; /* really stop it */
340 ENI_DEV(dev)->slow = NULL;
341 skb_queue_head_init(&ENI_DEV(dev)->rx_queue);
342 }
343
344
345 static int do_rx_dma(struct atm_vcc *vcc,struct sk_buff *skb,
346 unsigned long skip,unsigned long size,unsigned long eff)
347 {
348 struct eni_dev *eni_dev;
349 struct eni_vcc *eni_vcc;
350 u32 dma_rd,dma_wr;
351 u32 dma[RX_DMA_BUF*2];
352 unsigned long paddr,here;
353 int i,j;
354
355 eni_dev = ENI_DEV(vcc->dev);
356 eni_vcc = ENI_VCC(vcc);
357 paddr = 0; /* GCC, shut up */
358 if (skb) {
359 paddr = (unsigned long) skb->data;
360 if (paddr & 3)
361 printk(KERN_CRIT DEV_LABEL "(itf %d): VCI %d has "
362 "mis-aligned RX data (0x%lx)\n",vcc->dev->number,
363 vcc->vci,paddr);
364 ENI_PRV_SIZE(skb) = size+skip;
365 /* PDU plus descriptor */
366 ATM_SKB(skb)->vcc = vcc;
367 }
368 j = 0;
369 if ((eff && skip) || 1) { /* @@@ actually, skip is always == 1 ... */
370 here = (eni_vcc->descr+skip) & (eni_vcc->words-1);
371 dma[j++] = (here << MID_DMA_COUNT_SHIFT) | (vcc->vci
372 << MID_DMA_VCI_SHIFT) | MID_DT_JK;
373 j++;
374 }
375 here = (eni_vcc->descr+size+skip) & (eni_vcc->words-1);
376 if (!eff) size += skip;
377 else {
378 unsigned long words;
379
380 if (!size) {
381 DPRINTK("strange things happen ...\n");
382 EVENT("strange things happen ... (skip=%ld,eff=%ld)\n",
383 size,eff);
384 }
385 words = eff;
386 if (paddr & 15) {
387 unsigned long init;
388
389 init = 4-((paddr & 15) >> 2);
390 if (init > words) init = words;
391 dma[j++] = MID_DT_WORD | (init << MID_DMA_COUNT_SHIFT) |
392 (vcc->vci << MID_DMA_VCI_SHIFT);
393 dma[j++] = virt_to_bus((void *) paddr);
394 paddr += init << 2;
395 words -= init;
396 }
397 #ifdef CONFIG_ATM_ENI_BURST_RX_16W /* may work with some PCI chipsets ... */
398 if (words & ~15) {
399 dma[j++] = MID_DT_16W | ((words >> 4) <<
400 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
401 MID_DMA_VCI_SHIFT);
402 dma[j++] = virt_to_bus((void *) paddr);
403 paddr += (words & ~15) << 2;
404 words &= 15;
405 }
406 #endif
407 #ifdef CONFIG_ATM_ENI_BURST_RX_8W /* works only with *some* PCI chipsets ... */
408 if (words & ~7) {
409 dma[j++] = MID_DT_8W | ((words >> 3) <<
410 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
411 MID_DMA_VCI_SHIFT);
412 dma[j++] = virt_to_bus((void *) paddr);
413 paddr += (words & ~7) << 2;
414 words &= 7;
415 }
416 #endif
417 #ifdef CONFIG_ATM_ENI_BURST_RX_4W /* recommended */
418 if (words & ~3) {
419 dma[j++] = MID_DT_4W | ((words >> 2) <<
420 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
421 MID_DMA_VCI_SHIFT);
422 dma[j++] = virt_to_bus((void *) paddr);
423 paddr += (words & ~3) << 2;
424 words &= 3;
425 }
426 #endif
427 #ifdef CONFIG_ATM_ENI_BURST_RX_2W /* probably useless if RX_4W, RX_8W, ... */
428 if (words & ~1) {
429 dma[j++] = MID_DT_2W | ((words >> 1) <<
430 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
431 MID_DMA_VCI_SHIFT);
432 dma[j++] = virt_to_bus((void *) paddr);
433 paddr += (words & ~1) << 2;
434 words &= 1;
435 }
436 #endif
437 if (words) {
438 dma[j++] = MID_DT_WORD | (words << MID_DMA_COUNT_SHIFT)
439 | (vcc->vci << MID_DMA_VCI_SHIFT);
440 dma[j++] = virt_to_bus((void *) paddr);
441 }
442 }
443 if (size != eff) {
444 dma[j++] = (here << MID_DMA_COUNT_SHIFT) |
445 (vcc->vci << MID_DMA_VCI_SHIFT) | MID_DT_JK;
446 j++;
447 }
448 if (!j || j > 2*RX_DMA_BUF) {
449 printk(KERN_CRIT DEV_LABEL "!j or j too big!!!\n");
450 if (skb) kfree_skb(skb);
451 return -1;
452 }
453 dma[j-2] |= MID_DMA_END;
454 j = j >> 1;
455 dma_wr = eni_in(MID_DMA_WR_RX);
456 dma_rd = eni_in(MID_DMA_RD_RX);
457 /*
458 * Can I move the dma_wr pointer by 2j+1 positions without overwriting
459 * data that hasn't been read (position of dma_rd) yet ?
460 */
461 if (!NEPMOK(dma_wr,j+j+1,dma_rd,NR_DMA_RX)) { /* @@@ +1 is ugly */
462 printk(KERN_WARNING DEV_LABEL "(itf %d): RX DMA full\n",
463 vcc->dev->number);
464 if (skb) kfree_skb(skb);
465 return -1;
466 }
467 for (i = 0; i < j; i++) {
468 writel(dma[i*2],eni_dev->rx_dma+dma_wr*8);
469 writel(dma[i*2+1],eni_dev->rx_dma+dma_wr*8+4);
470 dma_wr = (dma_wr+1) & (NR_DMA_RX-1);
471 }
472 if (skb) {
473 ENI_PRV_POS(skb) = eni_vcc->descr+size+1;
474 skb_queue_tail(&eni_dev->rx_queue,skb);
475 eni_vcc->last = skb;
476 rx_enqueued++;
477 }
478 eni_vcc->descr = here;
479 eni_out(dma_wr,MID_DMA_WR_RX);
480 return 0;
481 }
482
483
484 static void discard(struct atm_vcc *vcc,unsigned long size)
485 {
486 struct eni_vcc *eni_vcc;
487
488 eni_vcc = ENI_VCC(vcc);
489 EVENT("discard (size=%ld)\n",size,0);
490 while (do_rx_dma(vcc,NULL,1,size,0)) EVENT("BUSY LOOP",0,0);
491 /* could do a full fallback, but that might be more expensive */
492 if (eni_vcc->rxing) ENI_PRV_POS(eni_vcc->last) += size+1;
493 else eni_vcc->rx_pos = (eni_vcc->rx_pos+size+1) & (eni_vcc->words-1);
494 }
495
496
497 /*
498 * TODO: should check whether direct copies (without DMA setup, dequeuing on
499 * interrupt, etc.) aren't much faster for AAL0
500 */
501
502 static int rx_aal0(struct atm_vcc *vcc)
503 {
504 struct eni_vcc *eni_vcc;
505 unsigned long descr;
506 unsigned long length;
507 struct sk_buff *skb;
508
509 DPRINTK(">rx_aal0\n");
510 eni_vcc = ENI_VCC(vcc);
511 descr = readl(eni_vcc->recv+eni_vcc->descr*4);
512 if ((descr & MID_RED_IDEN) != (MID_RED_RX_ID << MID_RED_SHIFT)) {
513 rx_ident_err(vcc);
514 return 1;
515 }
516 if (descr & MID_RED_T) {
517 DPRINTK(DEV_LABEL "(itf %d): trashing empty cell\n",
518 vcc->dev->number);
519 length = 0;
520 vcc->stats->rx_err++;
521 }
522 else {
523 length = ATM_CELL_SIZE-1; /* no HEC */
524 }
525 skb = length ? atm_alloc_charge(vcc,length,GFP_ATOMIC) : NULL;
526 if (!skb) {
527 discard(vcc,length >> 2);
528 return 0;
529 }
530 skb_put(skb,length);
531 skb->stamp = eni_vcc->timestamp;
532 DPRINTK("got len %ld\n",length);
533 if (do_rx_dma(vcc,skb,1,length >> 2,length >> 2)) return 1;
534 eni_vcc->rxing++;
535 return 0;
536 }
537
538
539 static int rx_aal5(struct atm_vcc *vcc)
540 {
541 struct eni_vcc *eni_vcc;
542 unsigned long descr;
543 unsigned long size,eff,length;
544 struct sk_buff *skb;
545
546 EVENT("rx_aal5\n",0,0);
547 DPRINTK(">rx_aal5\n");
548 eni_vcc = ENI_VCC(vcc);
549 descr = readl(eni_vcc->recv+eni_vcc->descr*4);
550 if ((descr & MID_RED_IDEN) != (MID_RED_RX_ID << MID_RED_SHIFT)) {
551 rx_ident_err(vcc);
552 return 1;
553 }
554 if (descr & (MID_RED_T | MID_RED_CRC_ERR)) {
555 if (descr & MID_RED_T) {
556 EVENT("empty cell (descr=0x%lx)\n",descr,0);
557 DPRINTK(DEV_LABEL "(itf %d): trashing empty cell\n",
558 vcc->dev->number);
559 size = 0;
560 }
561 else {
562 static unsigned long silence = 0;
563
564 if (time_after(jiffies, silence) || silence == 0) {
565 printk(KERN_WARNING DEV_LABEL "(itf %d): "
566 "discarding PDU(s) with CRC error\n",
567 vcc->dev->number);
568 silence = (jiffies+2*HZ)|1;
569 }
570 size = (descr & MID_RED_COUNT)*(ATM_CELL_PAYLOAD >> 2);
571 EVENT("CRC error (descr=0x%lx,size=%ld)\n",descr,
572 size);
573 }
574 eff = length = 0;
575 vcc->stats->rx_err++;
576 }
577 else {
578 size = (descr & MID_RED_COUNT)*(ATM_CELL_PAYLOAD >> 2);
579 DPRINTK("size=%ld\n",size);
580 length = readl(eni_vcc->recv+(((eni_vcc->descr+size-1) &
581 (eni_vcc->words-1)))*4) & 0xffff;
582 /* -trailer(2)+header(1) */
583 if (length && length <= (size << 2)-8 && length <=
584 ATM_MAX_AAL5_PDU) eff = (length+3) >> 2;
585 else { /* ^ trailer length (8) */
586 EVENT("bad PDU (descr=0x08%lx,length=%ld)\n",descr,
587 length);
588 printk(KERN_ERR DEV_LABEL "(itf %d): bad AAL5 PDU "
589 "(VCI=%d,length=%ld,size=%ld (descr 0x%lx))\n",
590 vcc->dev->number,vcc->vci,length,size << 2,descr);
591 length = eff = 0;
592 vcc->stats->rx_err++;
593 }
594 }
595 skb = eff ? atm_alloc_charge(vcc,eff << 2,GFP_ATOMIC) : NULL;
596 if (!skb) {
597 discard(vcc,size);
598 return 0;
599 }
600 skb_put(skb,length);
601 DPRINTK("got len %ld\n",length);
602 if (do_rx_dma(vcc,skb,1,size,eff)) return 1;
603 eni_vcc->rxing++;
604 return 0;
605 }
606
607
608 static inline int rx_vcc(struct atm_vcc *vcc)
609 {
610 unsigned long vci_dsc,tmp;
611 struct eni_vcc *eni_vcc;
612
613 eni_vcc = ENI_VCC(vcc);
614 vci_dsc = ENI_DEV(vcc->dev)->vci+vcc->vci*16;
615 EVENT("rx_vcc(1)\n",0,0);
616 while (eni_vcc->descr != (tmp = (readl(vci_dsc+4) & MID_VCI_DESCR) >>
617 MID_VCI_DESCR_SHIFT)) {
618 EVENT("rx_vcc(2: host dsc=0x%lx, nic dsc=0x%lx)\n",
619 eni_vcc->descr,tmp);
620 DPRINTK("CB_DESCR %ld REG_DESCR %d\n",ENI_VCC(vcc)->descr,
621 (((unsigned) readl(vci_dsc+4) & MID_VCI_DESCR) >>
622 MID_VCI_DESCR_SHIFT));
623 if (ENI_VCC(vcc)->rx(vcc)) return 1;
624 }
625 /* clear IN_SERVICE flag */
626 writel(readl(vci_dsc) & ~MID_VCI_IN_SERVICE,vci_dsc);
627 /*
628 * If new data has arrived between evaluating the while condition and
629 * clearing IN_SERVICE, we wouldn't be notified until additional data
630 * follows. So we have to loop again to be sure.
631 */
632 EVENT("rx_vcc(3)\n",0,0);
633 while (ENI_VCC(vcc)->descr != (tmp = (readl(vci_dsc+4) & MID_VCI_DESCR)
634 >> MID_VCI_DESCR_SHIFT)) {
635 EVENT("rx_vcc(4: host dsc=0x%lx, nic dsc=0x%lx)\n",
636 eni_vcc->descr,tmp);
637 DPRINTK("CB_DESCR %ld REG_DESCR %d\n",ENI_VCC(vcc)->descr,
638 (((unsigned) readl(vci_dsc+4) & MID_VCI_DESCR) >>
639 MID_VCI_DESCR_SHIFT));
640 if (ENI_VCC(vcc)->rx(vcc)) return 1;
641 }
642 return 0;
643 }
644
645
646 static void poll_rx(struct atm_dev *dev)
647 {
648 struct eni_dev *eni_dev;
649 struct atm_vcc *curr;
650
651 eni_dev = ENI_DEV(dev);
652 while ((curr = eni_dev->fast)) {
653 EVENT("poll_rx.fast\n",0,0);
654 if (rx_vcc(curr)) return;
655 eni_dev->fast = ENI_VCC(curr)->next;
656 ENI_VCC(curr)->next = ENI_VCC_NOS;
657 ENI_VCC(curr)->servicing--;
658 }
659 while ((curr = eni_dev->slow)) {
660 EVENT("poll_rx.slow\n",0,0);
661 if (rx_vcc(curr)) return;
662 eni_dev->slow = ENI_VCC(curr)->next;
663 ENI_VCC(curr)->next = ENI_VCC_NOS;
664 ENI_VCC(curr)->servicing--;
665 }
666 }
667
668
669 static void get_service(struct atm_dev *dev)
670 {
671 struct eni_dev *eni_dev;
672 struct atm_vcc *vcc;
673 unsigned long vci;
674
675 DPRINTK(">get_service\n");
676 eni_dev = ENI_DEV(dev);
677 while (eni_in(MID_SERV_WRITE) != eni_dev->serv_read) {
678 vci = readl(eni_dev->service+eni_dev->serv_read*4);
679 eni_dev->serv_read = (eni_dev->serv_read+1) & (NR_SERVICE-1);
680 vcc = eni_dev->rx_map[vci & 1023];
681 if (!vcc) {
682 printk(KERN_CRIT DEV_LABEL "(itf %d): VCI %ld not "
683 "found\n",dev->number,vci);
684 continue; /* nasty but we try to go on anyway */
685 /* @@@ nope, doesn't work */
686 }
687 EVENT("getting from service\n",0,0);
688 if (ENI_VCC(vcc)->next != ENI_VCC_NOS) {
689 EVENT("double service\n",0,0);
690 DPRINTK("Grr, servicing VCC %ld twice\n",vci);
691 continue;
692 }
693 ENI_VCC(vcc)->timestamp = xtime;
694 ENI_VCC(vcc)->next = NULL;
695 if (vcc->qos.rxtp.traffic_class == ATM_CBR) {
696 if (eni_dev->fast)
697 ENI_VCC(eni_dev->last_fast)->next = vcc;
698 else eni_dev->fast = vcc;
699 eni_dev->last_fast = vcc;
700 }
701 else {
702 if (eni_dev->slow)
703 ENI_VCC(eni_dev->last_slow)->next = vcc;
704 else eni_dev->slow = vcc;
705 eni_dev->last_slow = vcc;
706 }
707 putting++;
708 ENI_VCC(vcc)->servicing++;
709 }
710 }
711
712
713 static void dequeue_rx(struct atm_dev *dev)
714 {
715 struct eni_dev *eni_dev;
716 struct eni_vcc *eni_vcc;
717 struct atm_vcc *vcc;
718 struct sk_buff *skb;
719 unsigned long vci_dsc;
720 int first;
721
722 eni_dev = ENI_DEV(dev);
723 first = 1;
724 while (1) {
725 skb = skb_dequeue(&eni_dev->rx_queue);
726 if (!skb) {
727 if (first) {
728 DPRINTK(DEV_LABEL "(itf %d): RX but not "
729 "rxing\n",dev->number);
730 EVENT("nothing to dequeue\n",0,0);
731 }
732 break;
733 }
734 EVENT("dequeued (size=%ld,pos=0x%lx)\n",ENI_PRV_SIZE(skb),
735 ENI_PRV_POS(skb));
736 rx_dequeued++;
737 vcc = ATM_SKB(skb)->vcc;
738 eni_vcc = ENI_VCC(vcc);
739 first = 0;
740 vci_dsc = eni_dev->vci+vcc->vci*16;
741 if (!EEPMOK(eni_vcc->rx_pos,ENI_PRV_SIZE(skb),
742 (readl(vci_dsc+4) & MID_VCI_READ) >> MID_VCI_READ_SHIFT,
743 eni_vcc->words)) {
744 EVENT("requeuing\n",0,0);
745 skb_queue_head(&eni_dev->rx_queue,skb);
746 break;
747 }
748 eni_vcc->rxing--;
749 eni_vcc->rx_pos = ENI_PRV_POS(skb) & (eni_vcc->words-1);
750 if (!skb->len) kfree_skb(skb);
751 else {
752 EVENT("pushing (len=%ld)\n",skb->len,0);
753 if (vcc->qos.aal == ATM_AAL0)
754 *(unsigned long *) skb->data =
755 ntohl(*(unsigned long *) skb->data);
756 memset(skb->cb,0,sizeof(struct eni_skb_prv));
757 vcc->push(vcc,skb);
758 pushed++;
759 }
760 vcc->stats->rx++;
761 }
762 wake_up(&eni_dev->rx_wait);
763 }
764
765
766 static int open_rx_first(struct atm_vcc *vcc)
767 {
768 struct eni_dev *eni_dev;
769 struct eni_vcc *eni_vcc;
770 unsigned long size;
771
772 DPRINTK("open_rx_first\n");
773 eni_dev = ENI_DEV(vcc->dev);
774 eni_vcc = ENI_VCC(vcc);
775 eni_vcc->rx = NULL;
776 if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0;
777 size = vcc->qos.rxtp.max_sdu*3; /* @@@ improve this */
778 if (size > MID_MAX_BUF_SIZE && vcc->qos.rxtp.max_sdu <=
779 MID_MAX_BUF_SIZE)
780 size = MID_MAX_BUF_SIZE;
781 eni_vcc->recv = eni_alloc_mem(eni_dev,&size);
782 DPRINTK("rx at 0x%lx\n",eni_vcc->recv);
783 eni_vcc->words = size >> 2;
784 if (!eni_vcc->recv) return -ENOBUFS;
785 eni_vcc->rx = vcc->qos.aal == ATM_AAL5 ? rx_aal5 : rx_aal0;
786 eni_vcc->descr = 0;
787 eni_vcc->rx_pos = 0;
788 eni_vcc->rxing = 0;
789 eni_vcc->servicing = 0;
790 eni_vcc->next = ENI_VCC_NOS;
791 return 0;
792 }
793
794
795 static int open_rx_second(struct atm_vcc *vcc)
796 {
797 unsigned long here;
798 struct eni_dev *eni_dev;
799 struct eni_vcc *eni_vcc;
800 unsigned long size;
801 int order;
802
803 DPRINTK("open_rx_second\n");
804 eni_dev = ENI_DEV(vcc->dev);
805 eni_vcc = ENI_VCC(vcc);
806 if (!eni_vcc->rx) return 0;
807 /* set up VCI descriptor */
808 here = eni_dev->vci+vcc->vci*16;
809 DPRINTK("loc 0x%x\n",(unsigned) (eni_vcc->recv-eni_dev->ram)/4);
810 size = eni_vcc->words >> 8;
811 for (order = -1; size; order++) size >>= 1;
812 writel(0,here+4); /* descr, read = 0 */
813 writel(0,here+8); /* write, state, count = 0 */
814 if (eni_dev->rx_map[vcc->vci])
815 printk(KERN_CRIT DEV_LABEL "(itf %d): BUG - VCI %d already "
816 "in use\n",vcc->dev->number,vcc->vci);
817 eni_dev->rx_map[vcc->vci] = vcc; /* now it counts */
818 writel(((vcc->qos.aal != ATM_AAL5 ? MID_MODE_RAW : MID_MODE_AAL5) <<
819 MID_VCI_MODE_SHIFT) | MID_VCI_PTI_MODE |
820 (((eni_vcc->recv-eni_dev->ram) >> (MID_LOC_SKIP+2)) <<
821 MID_VCI_LOCATION_SHIFT) | (order << MID_VCI_SIZE_SHIFT),here);
822 return 0;
823 }
824
825
826 static void close_rx(struct atm_vcc *vcc)
827 {
828 unsigned long here,flags;
829 struct eni_dev *eni_dev;
830 struct eni_vcc *eni_vcc;
831 u32 tmp;
832
833 eni_vcc = ENI_VCC(vcc);
834 if (!eni_vcc->rx) return;
835 eni_dev = ENI_DEV(vcc->dev);
836 if (vcc->vpi != ATM_VPI_UNSPEC && vcc->vci != ATM_VCI_UNSPEC) {
837 here = eni_dev->vci+vcc->vci*16;
838 /* block receiver */
839 writel((readl(here) & ~MID_VCI_MODE) | (MID_MODE_TRASH <<
840 MID_VCI_MODE_SHIFT),here);
841 /* wait for receiver to become idle */
842 udelay(27);
843 /* discard pending cell */
844 writel(readl(here) & ~MID_VCI_IN_SERVICE,here);
845 /* don't accept any new ones */
846 eni_dev->rx_map[vcc->vci] = NULL;
847 /* wait for RX queue to drain */
848 DPRINTK("eni_close: waiting for RX ...\n");
849 EVENT("RX closing\n",0,0);
850 save_flags(flags);
851 cli();
852 while (eni_vcc->rxing || eni_vcc->servicing) {
853 EVENT("drain PDUs (rx %ld, serv %ld)\n",eni_vcc->rxing,
854 eni_vcc->servicing);
855 printk(KERN_INFO "%d+%d RX left\n",eni_vcc->servicing,
856 eni_vcc->rxing);
857 sleep_on(&eni_dev->rx_wait);
858 }
859 while (eni_vcc->rx_pos != (tmp =
860 readl(eni_dev->vci+vcc->vci*16+4) & MID_VCI_READ)>>
861 MID_VCI_READ_SHIFT) {
862 EVENT("drain discard (host 0x%lx, nic 0x%lx)\n",
863 eni_vcc->rx_pos,tmp);
864 printk(KERN_INFO "draining RX: host 0x%lx, nic 0x%x\n",
865 eni_vcc->rx_pos,tmp);
866 sleep_on(&eni_dev->rx_wait);
867 }
868 restore_flags(flags);
869 }
870 eni_free_mem(eni_dev,eni_vcc->recv,eni_vcc->words << 2);
871 eni_vcc->rx = NULL;
872 }
873
874
875 static int start_rx(struct atm_dev *dev)
876 {
877 struct eni_dev *eni_dev;
878
879 eni_dev = ENI_DEV(dev);
880 eni_dev->rx_map = (struct atm_vcc **) get_free_page(GFP_KERNEL);
881 if (!eni_dev->rx_map) {
882 printk(KERN_ERR DEV_LABEL "(itf %d): couldn't get free page\n",
883 dev->number);
884 free_page((unsigned long) eni_dev->free_list);
885 return -ENOMEM;
886 }
887 memset(eni_dev->rx_map,0,PAGE_SIZE);
888 eni_dev->fast = eni_dev->last_fast = NULL;
889 eni_dev->slow = eni_dev->last_slow = NULL;
890 init_waitqueue_head(&eni_dev->rx_wait);
891 skb_queue_head_init(&eni_dev->rx_queue);
892 eni_dev->serv_read = eni_in(MID_SERV_WRITE);
893 eni_out(0,MID_DMA_WR_RX);
894 return 0;
895 }
896
897
898 /*----------------------------------- TX ------------------------------------*/
899
900
901 enum enq_res { enq_ok,enq_next,enq_jam };
902
903
904 static inline void put_dma(int chan,u32 *dma,int *j,unsigned long paddr,
905 u32 size)
906 {
907 u32 init,words;
908
909 DPRINTK("put_dma: 0x%lx+0x%x\n",paddr,size);
910 EVENT("put_dma: 0x%lx+0x%lx\n",paddr,size);
911 #if 0 /* don't complain anymore */
912 if (paddr & 3)
913 printk(KERN_ERR "put_dma: unaligned addr (0x%lx)\n",paddr);
914 if (size & 3)
915 printk(KERN_ERR "put_dma: unaligned size (0x%lx)\n",size);
916 #endif
917 if (paddr & 3) {
918 init = 4-(paddr & 3);
919 if (init > size || size < 7) init = size;
920 DPRINTK("put_dma: %lx DMA: %d/%d bytes\n",paddr,init,size);
921 dma[(*j)++] = MID_DT_BYTE | (init << MID_DMA_COUNT_SHIFT) |
922 (chan << MID_DMA_CHAN_SHIFT);
923 dma[(*j)++] = virt_to_bus((void *) paddr);
924 paddr += init;
925 size -= init;
926 }
927 words = size >> 2;
928 size &= 3;
929 if (words && (paddr & 31)) {
930 init = 8-((paddr & 31) >> 2);
931 if (init > words) init = words;
932 DPRINTK("put_dma: %lx DMA: %d/%d words\n",paddr,init,words);
933 dma[(*j)++] = MID_DT_WORD | (init << MID_DMA_COUNT_SHIFT) |
934 (chan << MID_DMA_CHAN_SHIFT);
935 dma[(*j)++] = virt_to_bus((void *) paddr);
936 paddr += init << 2;
937 words -= init;
938 }
939 #ifdef CONFIG_ATM_ENI_BURST_TX_16W /* may work with some PCI chipsets ... */
940 if (words & ~15) {
941 DPRINTK("put_dma: %lx DMA: %d*16/%d words\n",paddr,words >> 4,
942 words);
943 dma[(*j)++] = MID_DT_16W | ((words >> 4) << MID_DMA_COUNT_SHIFT)
944 | (chan << MID_DMA_CHAN_SHIFT);
945 dma[(*j)++] = virt_to_bus((void *) paddr);
946 paddr += (words & ~15) << 2;
947 words &= 15;
948 }
949 #endif
950 #ifdef CONFIG_ATM_ENI_BURST_TX_8W /* recommended */
951 if (words & ~7) {
952 DPRINTK("put_dma: %lx DMA: %d*8/%d words\n",paddr,words >> 3,
953 words);
954 dma[(*j)++] = MID_DT_8W | ((words >> 3) << MID_DMA_COUNT_SHIFT)
955 | (chan << MID_DMA_CHAN_SHIFT);
956 dma[(*j)++] = virt_to_bus((void *) paddr);
957 paddr += (words & ~7) << 2;
958 words &= 7;
959 }
960 #endif
961 #ifdef CONFIG_ATM_ENI_BURST_TX_4W /* probably useless if TX_8W or TX_16W */
962 if (words & ~3) {
963 DPRINTK("put_dma: %lx DMA: %d*4/%d words\n",paddr,words >> 2,
964 words);
965 dma[(*j)++] = MID_DT_4W | ((words >> 2) << MID_DMA_COUNT_SHIFT)
966 | (chan << MID_DMA_CHAN_SHIFT);
967 dma[(*j)++] = virt_to_bus((void *) paddr);
968 paddr += (words & ~3) << 2;
969 words &= 3;
970 }
971 #endif
972 #ifdef CONFIG_ATM_ENI_BURST_TX_2W /* probably useless if TX_4W, TX_8W, ... */
973 if (words & ~1) {
974 DPRINTK("put_dma: %lx DMA: %d*2/%d words\n",paddr,words >> 1,
975 words);
976 dma[(*j)++] = MID_DT_2W | ((words >> 1) << MID_DMA_COUNT_SHIFT)
977 | (chan << MID_DMA_CHAN_SHIFT);
978 dma[(*j)++] = virt_to_bus((void *) paddr);
979 paddr += (words & ~1) << 2;
980 words &= 1;
981 }
982 #endif
983 if (words) {
984 DPRINTK("put_dma: %lx DMA: %d words\n",paddr,words);
985 dma[(*j)++] = MID_DT_WORD | (words << MID_DMA_COUNT_SHIFT) |
986 (chan << MID_DMA_CHAN_SHIFT);
987 dma[(*j)++] = virt_to_bus((void *) paddr);
988 paddr += words << 2;
989 }
990 if (size) {
991 DPRINTK("put_dma: %lx DMA: %d bytes\n",paddr,size);
992 dma[(*j)++] = MID_DT_BYTE | (size << MID_DMA_COUNT_SHIFT) |
993 (chan << MID_DMA_CHAN_SHIFT);
994 dma[(*j)++] = virt_to_bus((void *) paddr);
995 }
996 }
997
998
999 static enum enq_res do_tx(struct sk_buff *skb)
1000 {
1001 struct atm_vcc *vcc;
1002 struct eni_dev *eni_dev;
1003 struct eni_vcc *eni_vcc;
1004 struct eni_tx *tx;
1005 u32 dma_rd,dma_wr;
1006 u32 size; /* in words */
1007 int aal5,dma_size,i,j;
1008
1009 DPRINTK(">do_tx\n");
1010 NULLCHECK(skb);
1011 EVENT("do_tx: skb=0x%lx, %ld bytes\n",(unsigned long) skb,skb->len);
1012 vcc = ATM_SKB(skb)->vcc;
1013 NULLCHECK(vcc);
1014 eni_dev = ENI_DEV(vcc->dev);
1015 NULLCHECK(eni_dev);
1016 eni_vcc = ENI_VCC(vcc);
1017 tx = eni_vcc->tx;
1018 NULLCHECK(tx);
1019 #if 0 /* Enable this for testing with the "align" program */
1020 {
1021 unsigned int hack = *((char *) skb->data)-'0';
1022
1023 if (hack < 8) {
1024 skb->data += hack;
1025 skb->len -= hack;
1026 }
1027 }
1028 #endif
1029 #if 0 /* should work now */
1030 if ((unsigned long) skb->data & 3)
1031 printk(KERN_ERR DEV_LABEL "(itf %d): VCI %d has mis-aligned "
1032 "TX data\n",vcc->dev->number,vcc->vci);
1033 #endif
1034 /*
1035 * Potential future IP speedup: make hard_header big enough to put
1036 * segmentation descriptor directly into PDU. Saves: 4 slave writes,
1037 * 1 DMA xfer & 2 DMA'ed bytes (protocol layering is for wimps :-)
1038 */
1039
1040 /* check space in buffer */
1041 if (!(aal5 = vcc->qos.aal == ATM_AAL5))
1042 size = (ATM_CELL_PAYLOAD >> 2)+TX_DESCR_SIZE;
1043 /* cell without HEC plus segmentation header (includes
1044 four-byte cell header) */
1045 else {
1046 size = skb->len+4*AAL5_TRAILER+ATM_CELL_PAYLOAD-1;
1047 /* add AAL5 trailer */
1048 size = ((size-(size % ATM_CELL_PAYLOAD)) >> 2)+TX_DESCR_SIZE;
1049 /* add segmentation header */
1050 }
1051 /*
1052 * Can I move tx_pos by size bytes without getting closer than TX_GAP
1053 * to the read pointer ? TX_GAP means to leave some space for what
1054 * the manual calls "too close".
1055 */
1056 if (!NEPMOK(tx->tx_pos,size+TX_GAP,
1057 eni_in(MID_TX_RDPTR(tx->index)),tx->words)) {
1058 DPRINTK(DEV_LABEL "(itf %d): TX full (size %d)\n",
1059 vcc->dev->number,size);
1060 return enq_next;
1061 }
1062 /* check DMA */
1063 dma_wr = eni_in(MID_DMA_WR_TX);
1064 dma_rd = eni_in(MID_DMA_RD_TX);
1065 dma_size = 3; /* JK for descriptor and final fill, plus final size
1066 mis-alignment fix */
1067 DPRINTK("iovcnt = %d\n",ATM_SKB(skb)->iovcnt);
1068 if (!ATM_SKB(skb)->iovcnt) dma_size += 5;
1069 else dma_size += 5*ATM_SKB(skb)->iovcnt;
1070 if (dma_size > TX_DMA_BUF) {
1071 printk(KERN_CRIT DEV_LABEL "(itf %d): needs %d DMA entries "
1072 "(got only %d)\n",vcc->dev->number,dma_size,TX_DMA_BUF);
1073 }
1074 DPRINTK("dma_wr is %d, tx_pos is %ld\n",dma_wr,tx->tx_pos);
1075 if (dma_wr != dma_rd && ((dma_rd+NR_DMA_TX-dma_wr) & (NR_DMA_TX-1)) <
1076 dma_size) {
1077 printk(KERN_WARNING DEV_LABEL "(itf %d): TX DMA full\n",
1078 vcc->dev->number);
1079 return enq_jam;
1080 }
1081 /* prepare DMA queue entries */
1082 j = 0;
1083 eni_dev->dma[j++] = (((tx->tx_pos+TX_DESCR_SIZE) & (tx->words-1)) <<
1084 MID_DMA_COUNT_SHIFT) | (tx->index << MID_DMA_CHAN_SHIFT) |
1085 MID_DT_JK;
1086 j++;
1087 if (!ATM_SKB(skb)->iovcnt)
1088 if (aal5)
1089 put_dma(tx->index,eni_dev->dma,&j,
1090 (unsigned long) skb->data,skb->len);
1091 else put_dma(tx->index,eni_dev->dma,&j,
1092 (unsigned long) skb->data+4,skb->len-4);
1093 else {
1094 DPRINTK("doing direct send\n");
1095 for (i = 0; i < ATM_SKB(skb)->iovcnt; i++)
1096 put_dma(tx->index,eni_dev->dma,&j,(unsigned long)
1097 ((struct iovec *) skb->data)[i].iov_base,
1098 ((struct iovec *) skb->data)[i].iov_len);
1099 }
1100 if (skb->len & 3)
1101 put_dma(tx->index,eni_dev->dma,&j,
1102 (unsigned long) zeroes,4-(skb->len & 3));
1103 /* JK for AAL5 trailer - AAL0 doesn't need it, but who cares ... */
1104 eni_dev->dma[j++] = (((tx->tx_pos+size) & (tx->words-1)) <<
1105 MID_DMA_COUNT_SHIFT) | (tx->index << MID_DMA_CHAN_SHIFT) |
1106 MID_DMA_END | MID_DT_JK;
1107 j++;
1108 DPRINTK("DMA at end: %d\n",j);
1109 /* store frame */
1110 writel((MID_SEG_TX_ID << MID_SEG_ID_SHIFT) |
1111 (aal5 ? MID_SEG_AAL5 : 0) | (tx->prescaler << MID_SEG_PR_SHIFT) |
1112 (tx->resolution << MID_SEG_RATE_SHIFT) |
1113 (size/(ATM_CELL_PAYLOAD/4)),tx->send+tx->tx_pos*4);
1114 /*printk("dsc = 0x%08lx\n",(unsigned long) readl(tx->send+tx->tx_pos*4));*/
1115 writel((vcc->vci << MID_SEG_VCI_SHIFT) |
1116 (aal5 ? 0 : (skb->data[3] & 0xf)) |
1117 (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ? MID_SEG_CLP : 0),
1118 tx->send+((tx->tx_pos+1) & (tx->words-1))*4);
1119 DPRINTK("size: %d, len:%d\n",size,skb->len);
1120 if (aal5)
1121 writel(skb->len,tx->send+
1122 ((tx->tx_pos+size-AAL5_TRAILER) & (tx->words-1))*4);
1123 j = j >> 1;
1124 for (i = 0; i < j; i++) {
1125 writel(eni_dev->dma[i*2],eni_dev->tx_dma+dma_wr*8);
1126 writel(eni_dev->dma[i*2+1],eni_dev->tx_dma+dma_wr*8+4);
1127 dma_wr = (dma_wr+1) & (NR_DMA_TX-1);
1128 }
1129 ENI_PRV_POS(skb) = tx->tx_pos;
1130 ENI_PRV_SIZE(skb) = size;
1131 ENI_VCC(vcc)->txing += size;
1132 tx->tx_pos = (tx->tx_pos+size) & (tx->words-1);
1133 DPRINTK("dma_wr set to %d, tx_pos is now %ld\n",dma_wr,tx->tx_pos);
1134 eni_out(dma_wr,MID_DMA_WR_TX);
1135 skb_queue_tail(&eni_dev->tx_queue,skb);
1136 queued++;
1137 return enq_ok;
1138 }
1139
1140
1141 static void poll_tx(struct atm_dev *dev)
1142 {
1143 struct eni_tx *tx;
1144 struct sk_buff *skb;
1145 enum enq_res res;
1146 int i;
1147
1148 DPRINTK(">poll_tx\n");
1149 for (i = NR_CHAN-1; i >= 0; i--) {
1150 tx = &ENI_DEV(dev)->tx[i];
1151 if (tx->send)
1152 while ((skb = skb_dequeue(&tx->backlog))) {
1153 res = do_tx(skb);
1154 if (res != enq_ok) {
1155 DPRINTK("re-queuing TX PDU\n");
1156 skb_queue_head(&tx->backlog,skb);
1157 requeued++;
1158 if (res == enq_jam) return;
1159 else break;
1160 }
1161 }
1162 }
1163 }
1164
1165
1166 static void dequeue_tx(struct atm_dev *dev)
1167 {
1168 struct eni_dev *eni_dev;
1169 struct atm_vcc *vcc;
1170 struct sk_buff *skb;
1171 struct eni_tx *tx;
1172
1173 NULLCHECK(dev);
1174 eni_dev = ENI_DEV(dev);
1175 NULLCHECK(eni_dev);
1176 while ((skb = skb_dequeue(&eni_dev->tx_queue))) {
1177 vcc = ATM_SKB(skb)->vcc;
1178 NULLCHECK(vcc);
1179 tx = ENI_VCC(vcc)->tx;
1180 NULLCHECK(ENI_VCC(vcc)->tx);
1181 DPRINTK("dequeue_tx: next 0x%lx curr 0x%x\n",ENI_PRV_POS(skb),
1182 (unsigned) eni_in(MID_TX_DESCRSTART(tx->index)));
1183 if (ENI_VCC(vcc)->txing < tx->words && ENI_PRV_POS(skb) ==
1184 eni_in(MID_TX_DESCRSTART(tx->index))) {
1185 skb_queue_head(&eni_dev->tx_queue,skb);
1186 break;
1187 }
1188 ENI_VCC(vcc)->txing -= ENI_PRV_SIZE(skb);
1189 if (vcc->pop) vcc->pop(vcc,skb);
1190 else dev_kfree_skb(skb);
1191 vcc->stats->tx++;
1192 wake_up(&eni_dev->tx_wait);
1193 dma_complete++;
1194 }
1195 }
1196
1197
1198 static struct eni_tx *alloc_tx(struct eni_dev *eni_dev,int ubr)
1199 {
1200 int i;
1201
1202 for (i = !ubr; i < NR_CHAN; i++)
1203 if (!eni_dev->tx[i].send) return eni_dev->tx+i;
1204 return NULL;
1205 }
1206
1207
1208 static int comp_tx(struct eni_dev *eni_dev,int *pcr,int reserved,int *pre,
1209 int *res,int unlimited)
1210 {
1211 static const int pre_div[] = { 4,16,128,2048 };
1212 /* 2^(((x+2)^2-(x+2))/2+1) */
1213
1214 if (unlimited) *pre = *res = 0;
1215 else {
1216 if (*pcr > 0) {
1217 int div;
1218
1219 for (*pre = 0; *pre < 3; (*pre)++)
1220 if (TS_CLOCK/pre_div[*pre]/64 <= *pcr) break;
1221 div = pre_div[*pre]**pcr;
1222 DPRINTK("min div %d\n",div);
1223 *res = TS_CLOCK/div-1;
1224 }
1225 else {
1226 int div;
1227
1228 if (!*pcr) *pcr = eni_dev->tx_bw+reserved;
1229 for (*pre = 3; *pre >= 0; (*pre)--)
1230 if (TS_CLOCK/pre_div[*pre]/64 > -*pcr) break;
1231 if (*pre < 3) (*pre)++; /* else fail later */
1232 div = pre_div[*pre]*-*pcr;
1233 DPRINTK("max div %d\n",div);
1234 *res = (TS_CLOCK+div-1)/div-1;
1235 }
1236 if (*res < 0) *res = 0;
1237 if (*res > MID_SEG_MAX_RATE) *res = MID_SEG_MAX_RATE;
1238 }
1239 *pcr = TS_CLOCK/pre_div[*pre]/(*res+1);
1240 DPRINTK("out pcr: %d (%d:%d)\n",*pcr,*pre,*res);
1241 return 0;
1242 }
1243
1244
1245 static int reserve_or_set_tx(struct atm_vcc *vcc,struct atm_trafprm *txtp,
1246 int set_rsv,int set_shp)
1247 {
1248 struct eni_dev *eni_dev = ENI_DEV(vcc->dev);
1249 struct eni_vcc *eni_vcc = ENI_VCC(vcc);
1250 struct eni_tx *tx;
1251 unsigned long size,mem;
1252 int rate,ubr,unlimited,new_tx;
1253 int pre,res,order;
1254 int error;
1255
1256 rate = atm_pcr_goal(txtp);
1257 ubr = txtp->traffic_class == ATM_UBR;
1258 unlimited = ubr && (!rate || rate <= -ATM_OC3_PCR ||
1259 rate >= ATM_OC3_PCR);
1260 if (!unlimited) {
1261 size = txtp->max_sdu*3; /* @@@ improve */
1262 if (size > MID_MAX_BUF_SIZE && txtp->max_sdu <=
1263 MID_MAX_BUF_SIZE)
1264 size = MID_MAX_BUF_SIZE;
1265 }
1266 else {
1267 if (eni_dev->ubr) {
1268 eni_vcc->tx = eni_dev->ubr;
1269 txtp->pcr = ATM_OC3_PCR;
1270 return 0;
1271 }
1272 size = UBR_BUFFER;
1273 }
1274 new_tx = !eni_vcc->tx;
1275 mem = 0; /* for gcc */
1276 if (!new_tx) tx = eni_vcc->tx;
1277 else {
1278 mem = eni_alloc_mem(eni_dev,&size);
1279 if (!mem) return -ENOBUFS;
1280 tx = alloc_tx(eni_dev,unlimited);
1281 if (!tx) {
1282 eni_free_mem(eni_dev,mem,size);
1283 return -EBUSY;
1284 }
1285 DPRINTK("got chan %d\n",tx->index);
1286 tx->reserved = tx->shaping = 0;
1287 tx->send = mem;
1288 tx->words = size >> 2;
1289 skb_queue_head_init(&tx->backlog);
1290 for (order = 0; size > (1 << (order+10)); order++);
1291 eni_out((order << MID_SIZE_SHIFT) |
1292 ((tx->send-eni_dev->ram) >> (MID_LOC_SKIP+2)),
1293 MID_TX_PLACE(tx->index));
1294 tx->tx_pos = eni_in(MID_TX_DESCRSTART(tx->index)) &
1295 MID_DESCR_START;
1296 }
1297 error = comp_tx(eni_dev,&rate,tx->reserved,&pre,&res,unlimited);
1298 if (!error && txtp->min_pcr > rate) error = -EINVAL;
1299 if (!error && txtp->max_pcr && txtp->max_pcr != ATM_MAX_PCR &&
1300 txtp->max_pcr < rate) error = -EINVAL;
1301 if (!error && !ubr && rate > eni_dev->tx_bw+tx->reserved)
1302 error = -EINVAL;
1303 if (!error && set_rsv && !set_shp && rate < tx->shaping)
1304 error = -EINVAL;
1305 if (!error && !set_rsv && rate > tx->reserved && !ubr)
1306 error = -EINVAL;
1307 if (error) {
1308 if (new_tx) {
1309 tx->send = 0;
1310 eni_free_mem(eni_dev,mem,size);
1311 }
1312 return error;
1313 }
1314 txtp->pcr = rate;
1315 if (set_rsv && !ubr) {
1316 eni_dev->tx_bw += tx->reserved;
1317 tx->reserved = rate;
1318 eni_dev->tx_bw -= rate;
1319 }
1320 if (set_shp || (unlimited && new_tx)) {
1321 if (unlimited && new_tx) eni_dev->ubr = tx;
1322 tx->prescaler = pre;
1323 tx->resolution = res;
1324 tx->shaping = rate;
1325 }
1326 if (set_shp) eni_vcc->tx = tx;
1327 DPRINTK("rsv %d shp %d\n",tx->reserved,tx->shaping);
1328 return 0;
1329 }
1330
1331
1332 static int open_tx_first(struct atm_vcc *vcc)
1333 {
1334 ENI_VCC(vcc)->tx = NULL;
1335 if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0;
1336 ENI_VCC(vcc)->txing = 0;
1337 return reserve_or_set_tx(vcc,&vcc->qos.txtp,1,1);
1338 }
1339
1340
1341 static int open_tx_second(struct atm_vcc *vcc)
1342 {
1343 return 0; /* nothing to do */
1344 }
1345
1346
1347 static void close_tx(struct atm_vcc *vcc)
1348 {
1349 struct eni_dev *eni_dev;
1350 struct eni_vcc *eni_vcc;
1351 unsigned long flags;
1352
1353 eni_vcc = ENI_VCC(vcc);
1354 if (!eni_vcc->tx) return;
1355 eni_dev = ENI_DEV(vcc->dev);
1356 /* wait for TX queue to drain */
1357 DPRINTK("eni_close: waiting for TX ...\n");
1358 save_flags(flags);
1359 cli();
1360 while (skb_peek(&eni_vcc->tx->backlog) || eni_vcc->txing) {
1361 DPRINTK("%d TX left\n",eni_vcc->txing);
1362 sleep_on(&eni_dev->tx_wait);
1363 }
1364 /*
1365 * Looping a few times in here is probably far cheaper than keeping
1366 * track of TX completions all the time, so let's poll a bit ...
1367 */
1368 while (eni_in(MID_TX_RDPTR(eni_vcc->tx->index)) !=
1369 eni_in(MID_TX_DESCRSTART(eni_vcc->tx->index)))
1370 schedule();
1371 restore_flags(flags);
1372 #if 0
1373 if (skb_peek(&eni_vcc->tx->backlog))
1374 printk(KERN_CRIT DEV_LABEL "SKBs in BACKLOG !!!\n");
1375 #endif
1376 if (eni_vcc->tx != eni_dev->ubr) {
1377 eni_free_mem(eni_dev,eni_vcc->tx->send,eni_vcc->tx->words << 2);
1378 eni_vcc->tx->send = 0;
1379 eni_dev->tx_bw += eni_vcc->tx->reserved;
1380 }
1381 eni_vcc->tx = NULL;
1382 }
1383
1384
1385 static int start_tx(struct atm_dev *dev)
1386 {
1387 struct eni_dev *eni_dev;
1388 int i;
1389
1390 eni_dev = ENI_DEV(dev);
1391 eni_dev->lost = 0;
1392 eni_dev->tx_bw = ATM_OC3_PCR;
1393 init_waitqueue_head(&eni_dev->tx_wait);
1394 eni_dev->ubr = NULL;
1395 skb_queue_head_init(&eni_dev->tx_queue);
1396 eni_out(0,MID_DMA_WR_TX);
1397 for (i = 0; i < NR_CHAN; i++) {
1398 eni_dev->tx[i].send = 0;
1399 eni_dev->tx[i].index = i;
1400 }
1401 return 0;
1402 }
1403
1404
1405 /*--------------------------------- common ----------------------------------*/
1406
1407
1408 #if 0 /* may become useful again when tuning things */
1409
1410 static void foo(void)
1411 {
1412 printk(KERN_INFO
1413 "tx_complete=%d,dma_complete=%d,queued=%d,requeued=%d,sub=%d,\n"
1414 "backlogged=%d,rx_enqueued=%d,rx_dequeued=%d,putting=%d,pushed=%d\n",
1415 tx_complete,dma_complete,queued,requeued,submitted,backlogged,
1416 rx_enqueued,rx_dequeued,putting,pushed);
1417 if (eni_boards) printk(KERN_INFO "loss: %ld\n",ENI_DEV(eni_boards)->lost);
1418 }
1419
1420 #endif
1421
1422
1423 static void misc_int(struct atm_dev *dev,unsigned long reason)
1424 {
1425 struct eni_dev *eni_dev;
1426
1427 DPRINTK(">misc_int\n");
1428 eni_dev = ENI_DEV(dev);
1429 if (reason & MID_STAT_OVFL) {
1430 EVENT("stat overflow\n",0,0);
1431 eni_dev->lost += eni_in(MID_STAT) & MID_OVFL_TRASH;
1432 }
1433 if (reason & MID_SUNI_INT) {
1434 EVENT("SUNI int\n",0,0);
1435 dev->phy->interrupt(dev);
1436 #if 0
1437 foo();
1438 #endif
1439 }
1440 if (reason & MID_DMA_ERR_ACK) {
1441 printk(KERN_CRIT DEV_LABEL "(itf %d): driver error - DMA "
1442 "error\n",dev->number);
1443 EVENT("---dump ends here---\n",0,0);
1444 printk(KERN_NOTICE "---recent events---\n");
1445 event_dump();
1446 }
1447 if (reason & MID_TX_IDENT_MISM) {
1448 printk(KERN_CRIT DEV_LABEL "(itf %d): driver error - ident "
1449 "mismatch\n",dev->number);
1450 EVENT("---dump ends here---\n",0,0);
1451 printk(KERN_NOTICE "---recent events---\n");
1452 event_dump();
1453 }
1454 if (reason & MID_TX_DMA_OVFL) {
1455 printk(KERN_CRIT DEV_LABEL "(itf %d): driver error - DMA "
1456 "overflow\n",dev->number);
1457 EVENT("---dump ends here---\n",0,0);
1458 printk(KERN_NOTICE "---recent events---\n");
1459 event_dump();
1460 }
1461 }
1462
1463
1464 static void eni_int(int irq,void *dev_id,struct pt_regs *regs)
1465 {
1466 struct atm_dev *dev;
1467 struct eni_dev *eni_dev;
1468 unsigned long reason;
1469
1470 DPRINTK(">eni_int\n");
1471 dev = dev_id;
1472 eni_dev = ENI_DEV(dev);
1473 while ((reason = eni_in(MID_ISA))) {
1474 DPRINTK(DEV_LABEL ": int 0x%lx\n",reason);
1475 if (reason & MID_RX_DMA_COMPLETE) {
1476 EVENT("INT: RX DMA complete, starting dequeue_rx\n",
1477 0,0);
1478 dequeue_rx(dev);
1479 EVENT("dequeue_rx done, starting poll_rx\n",0,0);
1480 poll_rx(dev);
1481 EVENT("poll_rx done\n",0,0);
1482 /* poll_tx ? */
1483 }
1484 if (reason & MID_SERVICE) {
1485 EVENT("INT: service, starting get_service\n",0,0);
1486 get_service(dev);
1487 EVENT("get_service done, starting poll_rx\n",0,0);
1488 poll_rx(dev);
1489 EVENT("poll_rx done\n",0,0);
1490 }
1491 if (reason & MID_TX_DMA_COMPLETE) {
1492 EVENT("INT: TX DMA COMPLETE\n",0,0);
1493 dequeue_tx(dev);
1494 }
1495 if (reason & MID_TX_COMPLETE) {
1496 EVENT("INT: TX COMPLETE\n",0,0);
1497 tx_complete++;
1498 wake_up(&eni_dev->tx_wait);
1499 poll_tx(dev);
1500 /* poll_rx ? */
1501 }
1502 if (reason & (MID_STAT_OVFL | MID_SUNI_INT | MID_DMA_ERR_ACK |
1503 MID_TX_IDENT_MISM | MID_TX_DMA_OVFL)) {
1504 EVENT("misc interrupt\n",0,0);
1505 misc_int(dev,reason);
1506 }
1507 }
1508 }
1509
1510
1511 /*--------------------------------- entries ---------------------------------*/
1512
1513
1514 static const char *media_name[] __initdata = {
1515 "MMF", "SMF", "MMF", "03?", /* 0- 3 */
1516 "UTP", "05?", "06?", "07?", /* 4- 7 */
1517 "TAXI","09?", "10?", "11?", /* 8-11 */
1518 "12?", "13?", "14?", "15?", /* 12-15 */
1519 "MMF", "SMF", "18?", "19?", /* 16-19 */
1520 "UTP", "21?", "22?", "23?", /* 20-23 */
1521 "24?", "25?", "26?", "27?", /* 24-27 */
1522 "28?", "29?", "30?", "31?" /* 28-31 */
1523 };
1524
1525
1526 #define SET_SEPROM \
1527 ({ if (!error && !pci_error) { \
1528 pci_error = pci_write_config_byte(eni_dev->pci_dev,PCI_TONGA_CTRL,tonga); \
1529 udelay(10); /* 10 usecs */ \
1530 } })
1531 #define GET_SEPROM \
1532 ({ if (!error && !pci_error) { \
1533 pci_error = pci_read_config_byte(eni_dev->pci_dev,PCI_TONGA_CTRL,&tonga); \
1534 udelay(10); /* 10 usecs */ \
1535 } })
1536
1537
1538 static int __init get_esi_asic(struct atm_dev *dev)
1539 {
1540 struct eni_dev *eni_dev;
1541 unsigned char tonga;
1542 int error,failed,pci_error;
1543 int address,i,j;
1544
1545 eni_dev = ENI_DEV(dev);
1546 error = pci_error = 0;
1547 tonga = SEPROM_MAGIC | SEPROM_DATA | SEPROM_CLK;
1548 SET_SEPROM;
1549 for (i = 0; i < ESI_LEN && !error && !pci_error; i++) {
1550 /* start operation */
1551 tonga |= SEPROM_DATA;
1552 SET_SEPROM;
1553 tonga |= SEPROM_CLK;
1554 SET_SEPROM;
1555 tonga &= ~SEPROM_DATA;
1556 SET_SEPROM;
1557 tonga &= ~SEPROM_CLK;
1558 SET_SEPROM;
1559 /* send address */
1560 address = ((i+SEPROM_ESI_BASE) << 1)+1;
1561 for (j = 7; j >= 0; j--) {
1562 tonga = (address >> j) & 1 ? tonga | SEPROM_DATA :
1563 tonga & ~SEPROM_DATA;
1564 SET_SEPROM;
1565 tonga |= SEPROM_CLK;
1566 SET_SEPROM;
1567 tonga &= ~SEPROM_CLK;
1568 SET_SEPROM;
1569 }
1570 /* get ack */
1571 tonga |= SEPROM_DATA;
1572 SET_SEPROM;
1573 tonga |= SEPROM_CLK;
1574 SET_SEPROM;
1575 GET_SEPROM;
1576 failed = tonga & SEPROM_DATA;
1577 tonga &= ~SEPROM_CLK;
1578 SET_SEPROM;
1579 tonga |= SEPROM_DATA;
1580 SET_SEPROM;
1581 if (failed) error = -EIO;
1582 else {
1583 dev->esi[i] = 0;
1584 for (j = 7; j >= 0; j--) {
1585 dev->esi[i] <<= 1;
1586 tonga |= SEPROM_DATA;
1587 SET_SEPROM;
1588 tonga |= SEPROM_CLK;
1589 SET_SEPROM;
1590 GET_SEPROM;
1591 if (tonga & SEPROM_DATA) dev->esi[i] |= 1;
1592 tonga &= ~SEPROM_CLK;
1593 SET_SEPROM;
1594 tonga |= SEPROM_DATA;
1595 SET_SEPROM;
1596 }
1597 /* get ack */
1598 tonga |= SEPROM_DATA;
1599 SET_SEPROM;
1600 tonga |= SEPROM_CLK;
1601 SET_SEPROM;
1602 GET_SEPROM;
1603 if (!(tonga & SEPROM_DATA)) error = -EIO;
1604 tonga &= ~SEPROM_CLK;
1605 SET_SEPROM;
1606 tonga |= SEPROM_DATA;
1607 SET_SEPROM;
1608 }
1609 /* stop operation */
1610 tonga &= ~SEPROM_DATA;
1611 SET_SEPROM;
1612 tonga |= SEPROM_CLK;
1613 SET_SEPROM;
1614 tonga |= SEPROM_DATA;
1615 SET_SEPROM;
1616 }
1617 if (pci_error) {
1618 printk(KERN_ERR DEV_LABEL "(itf %d): error reading ESI "
1619 "(0x%02x)\n",dev->number,pci_error);
1620 error = -EIO;
1621 }
1622 return error;
1623 }
1624
1625
1626 #undef SET_SEPROM
1627 #undef GET_SEPROM
1628
1629
1630 static int __init get_esi_fpga(struct atm_dev *dev,unsigned long base)
1631 {
1632 unsigned long mac_base;
1633 int i;
1634
1635 mac_base = base+EPROM_SIZE-sizeof(struct midway_eprom);
1636 for (i = 0; i < ESI_LEN; i++) dev->esi[i] = readb(mac_base+(i^3));
1637 return 0;
1638 }
1639
1640
1641 static int __init eni_init(struct atm_dev *dev)
1642 {
1643 struct midway_eprom *eprom;
1644 struct eni_dev *eni_dev;
1645 struct pci_dev *pci_dev;
1646 unsigned int real_base,base;
1647 unsigned char revision;
1648 int error,i,last;
1649
1650 DPRINTK(">eni_init\n");
1651 dev->ci_range.vpi_bits = 0;
1652 dev->ci_range.vci_bits = NR_VCI_LD;
1653 dev->link_rate = ATM_OC3_PCR;
1654 eni_dev = ENI_DEV(dev);
1655 pci_dev = eni_dev->pci_dev;
1656 real_base = pci_dev->resource[0].start;
1657 eni_dev->irq = pci_dev->irq;
1658 error = pci_read_config_byte(pci_dev,PCI_REVISION_ID,&revision);
1659 if (error) {
1660 printk(KERN_ERR DEV_LABEL "(itf %d): init error 0x%02x\n",
1661 dev->number,error);
1662 return -EINVAL;
1663 }
1664 if ((error = pci_write_config_word(pci_dev,PCI_COMMAND,
1665 PCI_COMMAND_MEMORY |
1666 (eni_dev->asic ? PCI_COMMAND_PARITY | PCI_COMMAND_SERR : 0)))) {
1667 printk(KERN_ERR DEV_LABEL "(itf %d): can't enable memory "
1668 "(0x%02x)\n",dev->number,error);
1669 return error;
1670 }
1671 printk(KERN_NOTICE DEV_LABEL "(itf %d): rev.%d,base=0x%x,irq=%d,",
1672 dev->number,revision,real_base,eni_dev->irq);
1673 if (!(base = (unsigned long) ioremap_nocache(real_base,MAP_MAX_SIZE))) {
1674 printk("\n");
1675 printk(KERN_ERR DEV_LABEL "(itf %d): can't set up page "
1676 "mapping\n",dev->number);
1677 return error;
1678 }
1679 eni_dev->base_diff = real_base-base;
1680 /* id may not be present in ASIC Tonga boards - check this @@@ */
1681 if (!eni_dev->asic) {
1682 eprom = (struct midway_eprom *) (base+EPROM_SIZE-sizeof(struct
1683 midway_eprom));
1684 if (readl(&eprom->magic) != ENI155_MAGIC) {
1685 printk("\n");
1686 printk(KERN_ERR KERN_ERR DEV_LABEL "(itf %d): bad "
1687 "magic - expected 0x%x, got 0x%x\n",dev->number,
1688 ENI155_MAGIC,(unsigned) readl(&eprom->magic));
1689 return -EINVAL;
1690 }
1691 }
1692 eni_dev->phy = base+PHY_BASE;
1693 eni_dev->reg = base+REG_BASE;
1694 eni_dev->ram = base+RAM_BASE;
1695 last = MAP_MAX_SIZE-RAM_BASE;
1696 for (i = last-RAM_INCREMENT; i >= 0; i -= RAM_INCREMENT) {
1697 writel(0x55555555,eni_dev->ram+i);
1698 if (readl(eni_dev->ram+i) != 0x55555555) last = i;
1699 else {
1700 writel(0xAAAAAAAA,eni_dev->ram+i);
1701 if (readl(eni_dev->ram+i) != 0xAAAAAAAA) last = i;
1702 else writel(i,eni_dev->ram+i);
1703 }
1704 }
1705 for (i = 0; i < last; i += RAM_INCREMENT)
1706 if (readl(eni_dev->ram+i) != i) break;
1707 eni_dev->mem = i;
1708 memset_io(eni_dev->ram,0,eni_dev->mem);
1709 /* TODO: should shrink allocation now */
1710 printk("mem=%dkB (",eni_dev->mem >> 10);
1711 /* TODO: check for non-SUNI, check for TAXI ? */
1712 if (!(eni_in(MID_RES_ID_MCON) & 0x200) != !eni_dev->asic) {
1713 printk(")\n");
1714 printk(KERN_ERR DEV_LABEL "(itf %d): ERROR - wrong id 0x%x\n",
1715 dev->number,(unsigned) eni_in(MID_RES_ID_MCON));
1716 return -EINVAL;
1717 }
1718 error = eni_dev->asic ? get_esi_asic(dev) : get_esi_fpga(dev,base);
1719 if (error) return error;
1720 for (i = 0; i < ESI_LEN; i++)
1721 printk("%s%02X",i ? "-" : "",dev->esi[i]);
1722 printk(")\n");
1723 printk(KERN_NOTICE DEV_LABEL "(itf %d): %s,%s\n",dev->number,
1724 eni_in(MID_RES_ID_MCON) & 0x200 ? "ASIC" : "FPGA",
1725 media_name[eni_in(MID_RES_ID_MCON) & DAUGTHER_ID]);
1726 return suni_init(dev);
1727 }
1728
1729
1730 static int __init eni_start(struct atm_dev *dev)
1731 {
1732 struct eni_dev *eni_dev;
1733 unsigned long buf,buffer_mem;
1734 int error;
1735
1736 DPRINTK(">eni_start\n");
1737 eni_dev = ENI_DEV(dev);
1738 if (request_irq(eni_dev->irq,&eni_int,SA_SHIRQ,DEV_LABEL,dev)) {
1739 printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
1740 dev->number,eni_dev->irq);
1741 return -EAGAIN;
1742 }
1743 /* @@@ should release IRQ on error */
1744 if ((error = pci_write_config_word(eni_dev->pci_dev,PCI_COMMAND,
1745 PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
1746 (eni_dev->asic ? PCI_COMMAND_PARITY | PCI_COMMAND_SERR : 0)))) {
1747 printk(KERN_ERR DEV_LABEL "(itf %d): can't enable memory+"
1748 "master (0x%02x)\n",dev->number,error);
1749 return error;
1750 }
1751 if ((error = pci_write_config_byte(eni_dev->pci_dev,PCI_TONGA_CTRL,
1752 END_SWAP_DMA))) {
1753 printk(KERN_ERR DEV_LABEL "(itf %d): can't set endian swap "
1754 "(0x%02x)\n",dev->number,error);
1755 return error;
1756 }
1757 /* determine addresses of internal tables */
1758 eni_dev->vci = eni_dev->ram;
1759 eni_dev->rx_dma = eni_dev->ram+NR_VCI*16;
1760 eni_dev->tx_dma = eni_dev->rx_dma+NR_DMA_RX*8;
1761 eni_dev->service = eni_dev->tx_dma+NR_DMA_TX*8;
1762 buf = eni_dev->service+NR_SERVICE*4;
1763 DPRINTK("vci 0x%lx,rx 0x%lx, tx 0x%lx,srv 0x%lx,buf 0x%lx\n",
1764 eni_dev->vci,eni_dev->rx_dma,eni_dev->tx_dma,
1765 eni_dev->service,buf);
1766 /* initialize memory management */
1767 buffer_mem = eni_dev->mem-(buf-eni_dev->ram);
1768 eni_dev->free_list_size = buffer_mem/MID_MIN_BUF_SIZE/2;
1769 eni_dev->free_list = (struct eni_free *) kmalloc(
1770 sizeof(struct eni_free)*(eni_dev->free_list_size+1),GFP_KERNEL);
1771 if (!eni_dev->free_list) {
1772 printk(KERN_ERR DEV_LABEL "(itf %d): couldn't get free page\n",
1773 dev->number);
1774 return -ENOMEM;
1775 }
1776 eni_dev->free_len = 0;
1777 eni_put_free(eni_dev,buf,buffer_mem);
1778 memset_io(eni_dev->vci,0,16*NR_VCI); /* clear VCI table */
1779 /*
1780 * byte_addr free (k)
1781 * 0x00000000 512 VCI table
1782 * 0x00004000 496 RX DMA
1783 * 0x00005000 492 TX DMA
1784 * 0x00006000 488 service list
1785 * 0x00007000 484 buffers
1786 * 0x00080000 0 end (512kB)
1787 */
1788 eni_out(0xffffffff,MID_IE);
1789 error = start_tx(dev);
1790 if (error) return error;
1791 error = start_rx(dev);
1792 if (error) return error;
1793 error = dev->phy->start(dev);
1794 if (error) return error;
1795 eni_out(eni_in(MID_MC_S) | (1 << MID_INT_SEL_SHIFT) |
1796 MID_TX_LOCK_MODE | MID_DMA_ENABLE | MID_TX_ENABLE | MID_RX_ENABLE,
1797 MID_MC_S);
1798 /* Tonga uses SBus INTReq1 */
1799 (void) eni_in(MID_ISA); /* clear Midway interrupts */
1800 return 0;
1801 }
1802
1803
1804 static void eni_close(struct atm_vcc *vcc)
1805 {
1806 DPRINTK(">eni_close\n");
1807 if (!ENI_VCC(vcc)) return;
1808 vcc->flags &= ~ATM_VF_READY;
1809 close_rx(vcc);
1810 close_tx(vcc);
1811 DPRINTK("eni_close: done waiting\n");
1812 /* deallocate memory */
1813 kfree(ENI_VCC(vcc));
1814 ENI_VCC(vcc) = NULL;
1815 vcc->flags &= ~ATM_VF_ADDR;
1816 /*foo();*/
1817 }
1818
1819
1820 static int get_ci(struct atm_vcc *vcc,short *vpi,int *vci)
1821 {
1822 struct atm_vcc *walk;
1823
1824 if (*vpi == ATM_VPI_ANY) *vpi = 0;
1825 if (*vci == ATM_VCI_ANY) {
1826 for (*vci = ATM_NOT_RSV_VCI; *vci < NR_VCI; (*vci)++) {
1827 if (vcc->qos.rxtp.traffic_class != ATM_NONE &&
1828 ENI_DEV(vcc->dev)->rx_map[*vci])
1829 continue;
1830 if (vcc->qos.txtp.traffic_class != ATM_NONE) {
1831 for (walk = vcc->dev->vccs; walk;
1832 walk = walk->next)
1833 if ((walk->flags & ATM_VF_ADDR) &&
1834 walk->vci == *vci &&
1835 walk->qos.txtp.traffic_class !=
1836 ATM_NONE)
1837 break;
1838 if (walk) continue;
1839 }
1840 break;
1841 }
1842 return *vci == NR_VCI ? -EADDRINUSE : 0;
1843 }
1844 if (*vci == ATM_VCI_UNSPEC) return 0;
1845 if (vcc->qos.rxtp.traffic_class != ATM_NONE &&
1846 ENI_DEV(vcc->dev)->rx_map[*vci])
1847 return -EADDRINUSE;
1848 if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0;
1849 for (walk = vcc->dev->vccs; walk; walk = walk->next)
1850 if ((walk->flags & ATM_VF_ADDR) && walk->vci == *vci &&
1851 walk->qos.txtp.traffic_class != ATM_NONE)
1852 return -EADDRINUSE;
1853 return 0;
1854 }
1855
1856
1857 static int eni_open(struct atm_vcc *vcc,short vpi,int vci)
1858 {
1859 struct eni_dev *eni_dev;
1860 struct eni_vcc *eni_vcc;
1861 int error;
1862
1863 DPRINTK(">eni_open\n");
1864 EVENT("eni_open\n",0,0);
1865 if (!(vcc->flags & ATM_VF_PARTIAL)) ENI_VCC(vcc) = NULL;
1866 eni_dev = ENI_DEV(vcc->dev);
1867 error = get_ci(vcc,&vpi,&vci);
1868 if (error) return error;
1869 vcc->vpi = vpi;
1870 vcc->vci = vci;
1871 if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1872 vcc->flags |= ATM_VF_ADDR;
1873 if (vcc->qos.aal != ATM_AAL0 && vcc->qos.aal != ATM_AAL5)
1874 return -EINVAL;
1875 DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1876 vcc->vci);
1877 if (!(vcc->flags & ATM_VF_PARTIAL)) {
1878 eni_vcc = kmalloc(sizeof(struct eni_vcc),GFP_KERNEL);
1879 if (!eni_vcc) return -ENOMEM;
1880 ENI_VCC(vcc) = eni_vcc;
1881 eni_vcc->tx = NULL; /* for eni_close after open_rx */
1882 if ((error = open_rx_first(vcc))) {
1883 eni_close(vcc);
1884 return error;
1885 }
1886 if ((error = open_tx_first(vcc))) {
1887 eni_close(vcc);
1888 return error;
1889 }
1890 }
1891 if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1892 if ((error = open_rx_second(vcc))) {
1893 eni_close(vcc);
1894 return error;
1895 }
1896 if ((error = open_tx_second(vcc))) {
1897 eni_close(vcc);
1898 return error;
1899 }
1900 vcc->flags |= ATM_VF_READY;
1901 /* should power down SUNI while !ref_count @@@ */
1902 return 0;
1903 }
1904
1905
1906 static int eni_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flgs)
1907 {
1908 struct eni_dev *eni_dev = ENI_DEV(vcc->dev);
1909 struct eni_tx *tx = ENI_VCC(vcc)->tx;
1910 struct sk_buff *skb;
1911 unsigned long flags;
1912 int error,rate,rsv,shp;
1913
1914 if (qos->txtp.traffic_class == ATM_NONE) return 0;
1915 if (tx == eni_dev->ubr) return -EBADFD;
1916 rate = atm_pcr_goal(&qos->txtp);
1917 if (rate < 0) rate = -rate;
1918 rsv = shp = 0;
1919 if ((flgs & ATM_MF_DEC_RSV) && rate && rate < tx->reserved) rsv = 1;
1920 if ((flgs & ATM_MF_INC_RSV) && (!rate || rate > tx->reserved)) rsv = 1;
1921 if ((flgs & ATM_MF_DEC_SHP) && rate && rate < tx->shaping) shp = 1;
1922 if ((flgs & ATM_MF_INC_SHP) && (!rate || rate > tx->shaping)) shp = 1;
1923 if (!rsv && !shp) return 0;
1924 error = reserve_or_set_tx(vcc,&qos->txtp,rsv,shp);
1925 if (error) return error;
1926 if (shp && !(flgs & ATM_MF_IMMED)) return 0;
1927 /*
1928 * Walk through the send buffer and patch the rate information in all
1929 * segmentation buffer descriptors of this VCC.
1930 */
1931 save_flags(flags);
1932 cli();
1933 for (skb = eni_dev->tx_queue.next; skb !=
1934 (struct sk_buff *) &eni_dev->tx_queue; skb = skb->next) {
1935 unsigned long dsc;
1936
1937 if (ATM_SKB(skb)->vcc != vcc) continue;
1938 dsc = tx->send+ENI_PRV_POS(skb)*4;
1939 writel((readl(dsc) & ~(MID_SEG_RATE | MID_SEG_PR)) |
1940 (tx->prescaler << MID_SEG_PR_SHIFT) |
1941 (tx->resolution << MID_SEG_RATE_SHIFT), dsc);
1942 }
1943 restore_flags(flags);
1944 return 0;
1945 }
1946
1947
1948 static int eni_ioctl(struct atm_dev *dev,unsigned int cmd,void *arg)
1949 {
1950 if (cmd == ENI_MEMDUMP) {
1951 printk(KERN_WARNING "Please use /proc/atm/" DEV_LABEL ":%d "
1952 "instead of obsolete ioctl ENI_MEMDUMP\n",dev->number);
1953 dump(dev);
1954 return 0;
1955 }
1956 if (cmd == ATM_SETCIRANGE) {
1957 struct atm_cirange ci;
1958
1959 if (copy_from_user(&ci,(void *) arg,sizeof(struct atm_cirange)))
1960 return -EFAULT;
1961 if ((ci.vpi_bits == 0 || ci.vpi_bits == ATM_CI_MAX) &&
1962 (ci.vci_bits == NR_VCI_LD || ci.vpi_bits == ATM_CI_MAX))
1963 return 0;
1964 return -EINVAL;
1965 }
1966 if (!dev->phy->ioctl) return -EINVAL;
1967 return dev->phy->ioctl(dev,cmd,arg);
1968 }
1969
1970
1971 static int eni_getsockopt(struct atm_vcc *vcc,int level,int optname,
1972 void *optval,int optlen)
1973 {
1974 #ifdef CONFIG_MMU_HACKS
1975
1976 static const struct atm_buffconst bctx = { PAGE_SIZE,0,PAGE_SIZE,0,0,0 };
1977 static const struct atm_buffconst bcrx = { PAGE_SIZE,0,PAGE_SIZE,0,0,0 };
1978
1979 #else
1980
1981 static const struct atm_buffconst bctx = { sizeof(int),0,sizeof(int),0,0,0 };
1982 static const struct atm_buffconst bcrx = { sizeof(int),0,sizeof(int),0,0,0 };
1983
1984 #endif
1985 if (level == SOL_AAL && (optname == SO_BCTXOPT ||
1986 optname == SO_BCRXOPT))
1987 return copy_to_user(optval,optname == SO_BCTXOPT ? &bctx :
1988 &bcrx,sizeof(struct atm_buffconst)) ? -EFAULT : 0;
1989 return -EINVAL;
1990 }
1991
1992
1993 static int eni_setsockopt(struct atm_vcc *vcc,int level,int optname,
1994 void *optval,int optlen)
1995 {
1996 return -EINVAL;
1997 }
1998
1999
2000 static int eni_send(struct atm_vcc *vcc,struct sk_buff *skb)
2001 {
2002 unsigned long flags;
2003
2004 DPRINTK(">eni_send\n");
2005 if (!ENI_VCC(vcc)->tx) {
2006 if (vcc->pop) vcc->pop(vcc,skb);
2007 else dev_kfree_skb(skb);
2008 return -EINVAL;
2009 }
2010 if (!skb) {
2011 printk(KERN_CRIT "!skb in eni_send ?\n");
2012 if (vcc->pop) vcc->pop(vcc,skb);
2013 else dev_kfree_skb(skb);
2014 return -EINVAL;
2015 }
2016 if (vcc->qos.aal == ATM_AAL0) {
2017 if (skb->len != ATM_CELL_SIZE-1) {
2018 if (vcc->pop) vcc->pop(vcc,skb);
2019 else dev_kfree_skb(skb);
2020 return -EINVAL;
2021 }
2022 *(u32 *) skb->data = htonl(*(u32 *) skb->data);
2023 }
2024 submitted++;
2025 ATM_SKB(skb)->vcc = vcc;
2026 save_flags(flags);
2027 cli(); /* brute force */
2028 if (skb_peek(&ENI_VCC(vcc)->tx->backlog) || do_tx(skb)) {
2029 skb_queue_tail(&ENI_VCC(vcc)->tx->backlog,skb);
2030 backlogged++;
2031 }
2032 restore_flags(flags);
2033 return 0;
2034 }
2035
2036
2037 static int eni_sg_send(struct atm_vcc *vcc,unsigned long start,
2038 unsigned long size)
2039 {
2040 return vcc->qos.aal == ATM_AAL5 && !((start | size) & 3);
2041 /* don't tolerate misalignment */
2042 }
2043
2044
2045 static void eni_phy_put(struct atm_dev *dev,unsigned char value,
2046 unsigned long addr)
2047 {
2048 writel(value,ENI_DEV(dev)->phy+addr*4);
2049 }
2050
2051
2052
2053 static unsigned char eni_phy_get(struct atm_dev *dev,unsigned long addr)
2054 {
2055 return readl(ENI_DEV(dev)->phy+addr*4);
2056 }
2057
2058
2059 static int eni_proc_read(struct atm_dev *dev,loff_t *pos,char *page)
2060 {
2061 static const char *signal[] = { "LOST","unknown","okay" };
2062 struct eni_dev *eni_dev = ENI_DEV(dev);
2063 struct atm_vcc *vcc;
2064 int left,i;
2065
2066 left = *pos;
2067 if (!left)
2068 return sprintf(page,DEV_LABEL "(itf %d) signal %s, %dkB, "
2069 "%d cps remaining\n",dev->number,signal[(int) dev->signal],
2070 eni_dev->mem >> 10,eni_dev->tx_bw);
2071 left--;
2072 if (!left)
2073 return sprintf(page,"Bursts: TX"
2074 #if !defined(CONFIG_ATM_ENI_BURST_TX_16W) && \
2075 !defined(CONFIG_ATM_ENI_BURST_TX_8W) && \
2076 !defined(CONFIG_ATM_ENI_BURST_TX_4W) && \
2077 !defined(CONFIG_ATM_ENI_BURST_TX_2W)
2078 " none"
2079 #endif
2080 #ifdef CONFIG_ATM_ENI_BURST_TX_16W
2081 " 16W"
2082 #endif
2083 #ifdef CONFIG_ATM_ENI_BURST_TX_8W
2084 " 8W"
2085 #endif
2086 #ifdef CONFIG_ATM_ENI_BURST_TX_4W
2087 " 4W"
2088 #endif
2089 #ifdef CONFIG_ATM_ENI_BURST_TX_2W
2090 " 2W"
2091 #endif
2092 ", RX"
2093 #if !defined(CONFIG_ATM_ENI_BURST_RX_16W) && \
2094 !defined(CONFIG_ATM_ENI_BURST_RX_8W) && \
2095 !defined(CONFIG_ATM_ENI_BURST_RX_4W) && \
2096 !defined(CONFIG_ATM_ENI_BURST_RX_2W)
2097 " none"
2098 #endif
2099 #ifdef CONFIG_ATM_ENI_BURST_RX_16W
2100 " 16W"
2101 #endif
2102 #ifdef CONFIG_ATM_ENI_BURST_RX_8W
2103 " 8W"
2104 #endif
2105 #ifdef CONFIG_ATM_ENI_BURST_RX_4W
2106 " 4W"
2107 #endif
2108 #ifdef CONFIG_ATM_ENI_BURST_RX_2W
2109 " 2W"
2110 #endif
2111 #ifndef CONFIG_ATM_ENI_TUNE_BURST
2112 " (default)"
2113 #endif
2114 "\n");
2115 for (i = 0; i < NR_CHAN; i++) {
2116 struct eni_tx *tx = eni_dev->tx+i;
2117
2118 if (!tx->send) continue;
2119 if (--left) continue;
2120 return sprintf(page,"tx[%d]: 0x%06lx-0x%06lx (%6ld bytes), "
2121 "rsv %d cps, shp %d cps%s\n",i,
2122 tx->send-eni_dev->ram,
2123 tx->send-eni_dev->ram+tx->words*4-1,tx->words*4,
2124 tx->reserved,tx->shaping,
2125 tx == eni_dev->ubr ? " (UBR)" : "");
2126 }
2127 for (vcc = dev->vccs; vcc; vcc = vcc->next) {
2128 struct eni_vcc *eni_vcc = ENI_VCC(vcc);
2129 int length;
2130
2131 if (--left) continue;
2132 length = sprintf(page,"vcc %4d: ",vcc->vci);
2133 if (eni_vcc->rx) {
2134 length += sprintf(page+length,"0x%06lx-0x%06lx "
2135 "(%6ld bytes)",
2136 eni_vcc->recv-eni_dev->ram,
2137 eni_vcc->recv-eni_dev->ram+eni_vcc->words*4-1,
2138 eni_vcc->words*4);
2139 if (eni_vcc->tx) length += sprintf(page+length,", ");
2140 }
2141 if (eni_vcc->tx)
2142 length += sprintf(page+length,"tx[%d]",
2143 eni_vcc->tx->index);
2144 page[length] = '\n';
2145 return length+1;
2146 }
2147 for (i = 0; i < eni_dev->free_len; i++) {
2148 struct eni_free *fe = eni_dev->free_list+i;
2149 unsigned long offset;
2150
2151 if (--left) continue;
2152 offset = eni_dev->ram+eni_dev->base_diff;
2153 return sprintf(page,"free 0x%06lx-0x%06lx (%6d bytes)\n",
2154 fe->start-offset,fe->start-offset+(1 << fe->order)-1,
2155 1 << fe->order);
2156 }
2157 return 0;
2158 }
2159
2160
2161 static const struct atmdev_ops ops = {
2162 NULL, /* no dev_close */
2163 eni_open,
2164 eni_close,
2165 eni_ioctl,
2166 eni_getsockopt,
2167 eni_setsockopt,
2168 eni_send,
2169 eni_sg_send,
2170 NULL, /* no send_oam */
2171 eni_phy_put,
2172 eni_phy_get,
2173 NULL, /* no feedback */
2174 eni_change_qos, /* no change_qos */
2175 NULL, /* no free_rx_skb */
2176 eni_proc_read
2177 };
2178
2179
2180 int __init eni_detect(void)
2181 {
2182 struct atm_dev *dev;
2183 struct eni_dev *eni_dev;
2184 int devs,type;
2185
2186 eni_dev = (struct eni_dev *) kmalloc(sizeof(struct eni_dev),
2187 GFP_KERNEL);
2188 if (!eni_dev) return -ENOMEM;
2189 devs = 0;
2190 for (type = 0; type < 2; type++) {
2191 struct pci_dev *pci_dev;
2192
2193 pci_dev = NULL;
2194 while ((pci_dev = pci_find_device(PCI_VENDOR_ID_EF,type ?
2195 PCI_DEVICE_ID_EF_ATM_ASIC : PCI_DEVICE_ID_EF_ATM_FPGA,
2196 pci_dev))) {
2197 if (!devs) {
2198 zeroes = kmalloc(4,GFP_KERNEL);
2199 if (!zeroes) {
2200 kfree(eni_dev);
2201 return -ENOMEM;
2202 }
2203 }
2204 dev = atm_dev_register(DEV_LABEL,&ops,-1,0);
2205 if (!dev) break;
2206 eni_dev->pci_dev = pci_dev;
2207 ENI_DEV(dev) = eni_dev;
2208 eni_dev->asic = type;
2209 if (eni_init(dev) || eni_start(dev)) {
2210 atm_dev_deregister(dev);
2211 break;
2212 }
2213 eni_dev->more = eni_boards;
2214 eni_boards = dev;
2215 devs++;
2216 eni_dev = (struct eni_dev *) kmalloc(sizeof(struct
2217 eni_dev),GFP_KERNEL);
2218 if (!eni_dev) break;
2219 }
2220 }
2221 kfree(eni_dev);
2222 if (!devs && zeroes) {
2223 kfree(zeroes);
2224 zeroes = NULL;
2225 }
2226 return devs;
2227 }
2228
2229
2230 #ifdef MODULE
2231
2232 int init_module(void)
2233 {
2234 if (!eni_detect()) {
2235 printk(KERN_ERR DEV_LABEL ": no adapter found\n");
2236 return -ENXIO;
2237 }
2238 MOD_INC_USE_COUNT;
2239 return 0;
2240 }
2241
2242
2243 void cleanup_module(void)
2244 {
2245 /*
2246 * Well, there's no way to get rid of the driver yet, so we don't
2247 * have to clean up, right ? :-)
2248 */
2249 }
2250
2251 #endif
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux