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