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 DPRINTK(">bug_int\n");
1473 if (reason & MID_DMA_ERR_ACK)
1474 printk(KERN_CRIT DEV_LABEL "(itf %d): driver error - DMA "
1475 "error\n",dev->number);
1476 if (reason & MID_TX_IDENT_MISM)
1477 printk(KERN_CRIT DEV_LABEL "(itf %d): driver error - ident "
1478 "mismatch\n",dev->number);
1479 if (reason & MID_TX_DMA_OVFL)
1480 printk(KERN_CRIT DEV_LABEL "(itf %d): driver error - DMA "
1481 "overflow\n",dev->number);
1482 EVENT("---dump ends here---\n",0,0);
1483 printk(KERN_NOTICE "---recent events---\n");
1484 event_dump();
1485}
1486
1487
1488static irqreturn_t eni_int(int irq,void *dev_id)
1489{
1490 struct atm_dev *dev;
1491 struct eni_dev *eni_dev;
1492 u32 reason;
1493
1494 DPRINTK(">eni_int\n");
1495 dev = dev_id;
1496 eni_dev = ENI_DEV(dev);
1497 reason = eni_in(MID_ISA);
1498 DPRINTK(DEV_LABEL ": int 0x%lx\n",(unsigned long) reason);
1499
1500
1501
1502
1503
1504
1505 if (reason & MID_STAT_OVFL) {
1506 EVENT("stat overflow\n",0,0);
1507 eni_dev->lost += eni_in(MID_STAT) & MID_OVFL_TRASH;
1508 }
1509 if (reason & MID_SUNI_INT) {
1510 EVENT("SUNI int\n",0,0);
1511 dev->phy->interrupt(dev);
1512#if 0
1513 foo();
1514#endif
1515 }
1516 spin_lock(&eni_dev->lock);
1517 eni_dev->events |= reason;
1518 spin_unlock(&eni_dev->lock);
1519 tasklet_schedule(&eni_dev->task);
1520 return IRQ_HANDLED;
1521}
1522
1523
1524static void eni_tasklet(unsigned long data)
1525{
1526 struct atm_dev *dev = (struct atm_dev *) data;
1527 struct eni_dev *eni_dev = ENI_DEV(dev);
1528 unsigned long flags;
1529 u32 events;
1530
1531 DPRINTK("eni_tasklet (dev %p)\n",dev);
1532 spin_lock_irqsave(&eni_dev->lock,flags);
1533 events = xchg(&eni_dev->events,0);
1534 spin_unlock_irqrestore(&eni_dev->lock,flags);
1535 if (events & MID_RX_DMA_COMPLETE) {
1536 EVENT("INT: RX DMA complete, starting dequeue_rx\n",0,0);
1537 dequeue_rx(dev);
1538 EVENT("dequeue_rx done, starting poll_rx\n",0,0);
1539 poll_rx(dev);
1540 EVENT("poll_rx done\n",0,0);
1541
1542 }
1543 if (events & MID_SERVICE) {
1544 EVENT("INT: service, starting get_service\n",0,0);
1545 get_service(dev);
1546 EVENT("get_service done, starting poll_rx\n",0,0);
1547 poll_rx(dev);
1548 EVENT("poll_rx done\n",0,0);
1549 }
1550 if (events & MID_TX_DMA_COMPLETE) {
1551 EVENT("INT: TX DMA COMPLETE\n",0,0);
1552 dequeue_tx(dev);
1553 }
1554 if (events & MID_TX_COMPLETE) {
1555 EVENT("INT: TX COMPLETE\n",0,0);
1556tx_complete++;
1557 wake_up(&eni_dev->tx_wait);
1558
1559 }
1560 if (events & (MID_DMA_ERR_ACK | MID_TX_IDENT_MISM | MID_TX_DMA_OVFL)) {
1561 EVENT("bug interrupt\n",0,0);
1562 bug_int(dev,events);
1563 }
1564 poll_tx(dev);
1565}
1566
1567
1568
1569
1570
1571static const char *media_name[] __devinitdata = {
1572 "MMF", "SMF", "MMF", "03?",
1573 "UTP", "05?", "06?", "07?",
1574 "TAXI","09?", "10?", "11?",
1575 "12?", "13?", "14?", "15?",
1576 "MMF", "SMF", "18?", "19?",
1577 "UTP", "21?", "22?", "23?",
1578 "24?", "25?", "26?", "27?",
1579 "28?", "29?", "30?", "31?"
1580};
1581
1582
1583#define SET_SEPROM \
1584 ({ if (!error && !pci_error) { \
1585 pci_error = pci_write_config_byte(eni_dev->pci_dev,PCI_TONGA_CTRL,tonga); \
1586 udelay(10); \
1587 } })
1588#define GET_SEPROM \
1589 ({ if (!error && !pci_error) { \
1590 pci_error = pci_read_config_byte(eni_dev->pci_dev,PCI_TONGA_CTRL,&tonga); \
1591 udelay(10); \
1592 } })
1593
1594
1595static int __devinit get_esi_asic(struct atm_dev *dev)
1596{
1597 struct eni_dev *eni_dev;
1598 unsigned char tonga;
1599 int error,failed,pci_error;
1600 int address,i,j;
1601
1602 eni_dev = ENI_DEV(dev);
1603 error = pci_error = 0;
1604 tonga = SEPROM_MAGIC | SEPROM_DATA | SEPROM_CLK;
1605 SET_SEPROM;
1606 for (i = 0; i < ESI_LEN && !error && !pci_error; i++) {
1607
1608 tonga |= SEPROM_DATA;
1609 SET_SEPROM;
1610 tonga |= SEPROM_CLK;
1611 SET_SEPROM;
1612 tonga &= ~SEPROM_DATA;
1613 SET_SEPROM;
1614 tonga &= ~SEPROM_CLK;
1615 SET_SEPROM;
1616
1617 address = ((i+SEPROM_ESI_BASE) << 1)+1;
1618 for (j = 7; j >= 0; j--) {
1619 tonga = (address >> j) & 1 ? tonga | SEPROM_DATA :
1620 tonga & ~SEPROM_DATA;
1621 SET_SEPROM;
1622 tonga |= SEPROM_CLK;
1623 SET_SEPROM;
1624 tonga &= ~SEPROM_CLK;
1625 SET_SEPROM;
1626 }
1627
1628 tonga |= SEPROM_DATA;
1629 SET_SEPROM;
1630 tonga |= SEPROM_CLK;
1631 SET_SEPROM;
1632 GET_SEPROM;
1633 failed = tonga & SEPROM_DATA;
1634 tonga &= ~SEPROM_CLK;
1635 SET_SEPROM;
1636 tonga |= SEPROM_DATA;
1637 SET_SEPROM;
1638 if (failed) error = -EIO;
1639 else {
1640 dev->esi[i] = 0;
1641 for (j = 7; j >= 0; j--) {
1642 dev->esi[i] <<= 1;
1643 tonga |= SEPROM_DATA;
1644 SET_SEPROM;
1645 tonga |= SEPROM_CLK;
1646 SET_SEPROM;
1647 GET_SEPROM;
1648 if (tonga & SEPROM_DATA) dev->esi[i] |= 1;
1649 tonga &= ~SEPROM_CLK;
1650 SET_SEPROM;
1651 tonga |= SEPROM_DATA;
1652 SET_SEPROM;
1653 }
1654
1655 tonga |= SEPROM_DATA;
1656 SET_SEPROM;
1657 tonga |= SEPROM_CLK;
1658 SET_SEPROM;
1659 GET_SEPROM;
1660 if (!(tonga & SEPROM_DATA)) error = -EIO;
1661 tonga &= ~SEPROM_CLK;
1662 SET_SEPROM;
1663 tonga |= SEPROM_DATA;
1664 SET_SEPROM;
1665 }
1666
1667 tonga &= ~SEPROM_DATA;
1668 SET_SEPROM;
1669 tonga |= SEPROM_CLK;
1670 SET_SEPROM;
1671 tonga |= SEPROM_DATA;
1672 SET_SEPROM;
1673 }
1674 if (pci_error) {
1675 printk(KERN_ERR DEV_LABEL "(itf %d): error reading ESI "
1676 "(0x%02x)\n",dev->number,pci_error);
1677 error = -EIO;
1678 }
1679 return error;
1680}
1681
1682
1683#undef SET_SEPROM
1684#undef GET_SEPROM
1685
1686
1687static int __devinit get_esi_fpga(struct atm_dev *dev, void __iomem *base)
1688{
1689 void __iomem *mac_base;
1690 int i;
1691
1692 mac_base = base+EPROM_SIZE-sizeof(struct midway_eprom);
1693 for (i = 0; i < ESI_LEN; i++) dev->esi[i] = readb(mac_base+(i^3));
1694 return 0;
1695}
1696
1697
1698static int __devinit eni_do_init(struct atm_dev *dev)
1699{
1700 struct midway_eprom __iomem *eprom;
1701 struct eni_dev *eni_dev;
1702 struct pci_dev *pci_dev;
1703 unsigned long real_base;
1704 void __iomem *base;
1705 int error,i,last;
1706
1707 DPRINTK(">eni_init\n");
1708 dev->ci_range.vpi_bits = 0;
1709 dev->ci_range.vci_bits = NR_VCI_LD;
1710 dev->link_rate = ATM_OC3_PCR;
1711 eni_dev = ENI_DEV(dev);
1712 pci_dev = eni_dev->pci_dev;
1713 real_base = pci_resource_start(pci_dev, 0);
1714 eni_dev->irq = pci_dev->irq;
1715 if ((error = pci_write_config_word(pci_dev,PCI_COMMAND,
1716 PCI_COMMAND_MEMORY |
1717 (eni_dev->asic ? PCI_COMMAND_PARITY | PCI_COMMAND_SERR : 0)))) {
1718 printk(KERN_ERR DEV_LABEL "(itf %d): can't enable memory "
1719 "(0x%02x)\n",dev->number,error);
1720 return -EIO;
1721 }
1722 printk(KERN_NOTICE DEV_LABEL "(itf %d): rev.%d,base=0x%lx,irq=%d,",
1723 dev->number,pci_dev->revision,real_base,eni_dev->irq);
1724 if (!(base = ioremap_nocache(real_base,MAP_MAX_SIZE))) {
1725 printk("\n");
1726 printk(KERN_ERR DEV_LABEL "(itf %d): can't set up page "
1727 "mapping\n",dev->number);
1728 return error;
1729 }
1730 eni_dev->base_diff = real_base - (unsigned long) base;
1731
1732 if (!eni_dev->asic) {
1733 eprom = (base+EPROM_SIZE-sizeof(struct midway_eprom));
1734 if (readl(&eprom->magic) != ENI155_MAGIC) {
1735 printk("\n");
1736 printk(KERN_ERR DEV_LABEL
1737 "(itf %d): bad magic - expected 0x%x, got 0x%x\n",
1738 dev->number, ENI155_MAGIC,
1739 (unsigned)readl(&eprom->magic));
1740 error = -EINVAL;
1741 goto unmap;
1742 }
1743 }
1744 eni_dev->phy = base+PHY_BASE;
1745 eni_dev->reg = base+REG_BASE;
1746 eni_dev->ram = base+RAM_BASE;
1747 last = MAP_MAX_SIZE-RAM_BASE;
1748 for (i = last-RAM_INCREMENT; i >= 0; i -= RAM_INCREMENT) {
1749 writel(0x55555555,eni_dev->ram+i);
1750 if (readl(eni_dev->ram+i) != 0x55555555) last = i;
1751 else {
1752 writel(0xAAAAAAAA,eni_dev->ram+i);
1753 if (readl(eni_dev->ram+i) != 0xAAAAAAAA) last = i;
1754 else writel(i,eni_dev->ram+i);
1755 }
1756 }
1757 for (i = 0; i < last; i += RAM_INCREMENT)
1758 if (readl(eni_dev->ram+i) != i) break;
1759 eni_dev->mem = i;
1760 memset_io(eni_dev->ram,0,eni_dev->mem);
1761
1762 printk("mem=%dkB (",eni_dev->mem >> 10);
1763
1764 if (!(eni_in(MID_RES_ID_MCON) & 0x200) != !eni_dev->asic) {
1765 printk(")\n");
1766 printk(KERN_ERR DEV_LABEL "(itf %d): ERROR - wrong id 0x%x\n",
1767 dev->number,(unsigned) eni_in(MID_RES_ID_MCON));
1768 error = -EINVAL;
1769 goto unmap;
1770 }
1771 error = eni_dev->asic ? get_esi_asic(dev) : get_esi_fpga(dev,base);
1772 if (error)
1773 goto unmap;
1774 for (i = 0; i < ESI_LEN; i++)
1775 printk("%s%02X",i ? "-" : "",dev->esi[i]);
1776 printk(")\n");
1777 printk(KERN_NOTICE DEV_LABEL "(itf %d): %s,%s\n",dev->number,
1778 eni_in(MID_RES_ID_MCON) & 0x200 ? "ASIC" : "FPGA",
1779 media_name[eni_in(MID_RES_ID_MCON) & DAUGTHER_ID]);
1780
1781 error = suni_init(dev);
1782 if (error)
1783 goto unmap;
1784out:
1785 return error;
1786unmap:
1787 iounmap(base);
1788 goto out;
1789}
1790
1791
1792static int __devinit eni_start(struct atm_dev *dev)
1793{
1794 struct eni_dev *eni_dev;
1795
1796 void __iomem *buf;
1797 unsigned long buffer_mem;
1798 int error;
1799
1800 DPRINTK(">eni_start\n");
1801 eni_dev = ENI_DEV(dev);
1802 if (request_irq(eni_dev->irq,&eni_int,IRQF_SHARED,DEV_LABEL,dev)) {
1803 printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
1804 dev->number,eni_dev->irq);
1805 error = -EAGAIN;
1806 goto out;
1807 }
1808 pci_set_master(eni_dev->pci_dev);
1809 if ((error = pci_write_config_word(eni_dev->pci_dev,PCI_COMMAND,
1810 PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
1811 (eni_dev->asic ? PCI_COMMAND_PARITY | PCI_COMMAND_SERR : 0)))) {
1812 printk(KERN_ERR DEV_LABEL "(itf %d): can't enable memory+"
1813 "master (0x%02x)\n",dev->number,error);
1814 goto free_irq;
1815 }
1816 if ((error = pci_write_config_byte(eni_dev->pci_dev,PCI_TONGA_CTRL,
1817 END_SWAP_DMA))) {
1818 printk(KERN_ERR DEV_LABEL "(itf %d): can't set endian swap "
1819 "(0x%02x)\n",dev->number,error);
1820 goto free_irq;
1821 }
1822
1823 eni_dev->vci = eni_dev->ram;
1824 eni_dev->rx_dma = eni_dev->ram+NR_VCI*16;
1825 eni_dev->tx_dma = eni_dev->rx_dma+NR_DMA_RX*8;
1826 eni_dev->service = eni_dev->tx_dma+NR_DMA_TX*8;
1827 buf = eni_dev->service+NR_SERVICE*4;
1828 DPRINTK("vci 0x%lx,rx 0x%lx, tx 0x%lx,srv 0x%lx,buf 0x%lx\n",
1829 eni_dev->vci,eni_dev->rx_dma,eni_dev->tx_dma,
1830 eni_dev->service,buf);
1831 spin_lock_init(&eni_dev->lock);
1832 tasklet_init(&eni_dev->task,eni_tasklet,(unsigned long) dev);
1833 eni_dev->events = 0;
1834
1835 buffer_mem = eni_dev->mem - (buf - eni_dev->ram);
1836 eni_dev->free_list_size = buffer_mem/MID_MIN_BUF_SIZE/2;
1837 eni_dev->free_list = kmalloc(
1838 sizeof(struct eni_free)*(eni_dev->free_list_size+1),GFP_KERNEL);
1839 if (!eni_dev->free_list) {
1840 printk(KERN_ERR DEV_LABEL "(itf %d): couldn't get free page\n",
1841 dev->number);
1842 error = -ENOMEM;
1843 goto free_irq;
1844 }
1845 eni_dev->free_len = 0;
1846 eni_put_free(eni_dev,buf,buffer_mem);
1847 memset_io(eni_dev->vci,0,16*NR_VCI);
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857 eni_out(0xffffffff,MID_IE);
1858 error = start_tx(dev);
1859 if (error) goto free_list;
1860 error = start_rx(dev);
1861 if (error) goto free_list;
1862 error = dev->phy->start(dev);
1863 if (error) goto free_list;
1864 eni_out(eni_in(MID_MC_S) | (1 << MID_INT_SEL_SHIFT) |
1865 MID_TX_LOCK_MODE | MID_DMA_ENABLE | MID_TX_ENABLE | MID_RX_ENABLE,
1866 MID_MC_S);
1867
1868 (void) eni_in(MID_ISA);
1869 return 0;
1870
1871free_list:
1872 kfree(eni_dev->free_list);
1873
1874free_irq:
1875 free_irq(eni_dev->irq, eni_dev);
1876
1877out:
1878 return error;
1879}
1880
1881
1882static void eni_close(struct atm_vcc *vcc)
1883{
1884 DPRINTK(">eni_close\n");
1885 if (!ENI_VCC(vcc)) return;
1886 clear_bit(ATM_VF_READY,&vcc->flags);
1887 close_rx(vcc);
1888 close_tx(vcc);
1889 DPRINTK("eni_close: done waiting\n");
1890
1891 kfree(ENI_VCC(vcc));
1892 vcc->dev_data = NULL;
1893 clear_bit(ATM_VF_ADDR,&vcc->flags);
1894
1895}
1896
1897
1898static int eni_open(struct atm_vcc *vcc)
1899{
1900 struct eni_vcc *eni_vcc;
1901 int error;
1902 short vpi = vcc->vpi;
1903 int vci = vcc->vci;
1904
1905 DPRINTK(">eni_open\n");
1906 EVENT("eni_open\n",0,0);
1907 if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1908 vcc->dev_data = NULL;
1909 if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1910 set_bit(ATM_VF_ADDR,&vcc->flags);
1911 if (vcc->qos.aal != ATM_AAL0 && vcc->qos.aal != ATM_AAL5)
1912 return -EINVAL;
1913 DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1914 vcc->vci);
1915 if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) {
1916 eni_vcc = kmalloc(sizeof(struct eni_vcc),GFP_KERNEL);
1917 if (!eni_vcc) return -ENOMEM;
1918 vcc->dev_data = eni_vcc;
1919 eni_vcc->tx = NULL;
1920 if ((error = open_rx_first(vcc))) {
1921 eni_close(vcc);
1922 return error;
1923 }
1924 if ((error = open_tx_first(vcc))) {
1925 eni_close(vcc);
1926 return error;
1927 }
1928 }
1929 if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1930 if ((error = open_rx_second(vcc))) {
1931 eni_close(vcc);
1932 return error;
1933 }
1934 if ((error = open_tx_second(vcc))) {
1935 eni_close(vcc);
1936 return error;
1937 }
1938 set_bit(ATM_VF_READY,&vcc->flags);
1939
1940 return 0;
1941}
1942
1943
1944static int eni_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flgs)
1945{
1946 struct eni_dev *eni_dev = ENI_DEV(vcc->dev);
1947 struct eni_tx *tx = ENI_VCC(vcc)->tx;
1948 struct sk_buff *skb;
1949 int error,rate,rsv,shp;
1950
1951 if (qos->txtp.traffic_class == ATM_NONE) return 0;
1952 if (tx == eni_dev->ubr) return -EBADFD;
1953 rate = atm_pcr_goal(&qos->txtp);
1954 if (rate < 0) rate = -rate;
1955 rsv = shp = 0;
1956 if ((flgs & ATM_MF_DEC_RSV) && rate && rate < tx->reserved) rsv = 1;
1957 if ((flgs & ATM_MF_INC_RSV) && (!rate || rate > tx->reserved)) rsv = 1;
1958 if ((flgs & ATM_MF_DEC_SHP) && rate && rate < tx->shaping) shp = 1;
1959 if ((flgs & ATM_MF_INC_SHP) && (!rate || rate > tx->shaping)) shp = 1;
1960 if (!rsv && !shp) return 0;
1961 error = reserve_or_set_tx(vcc,&qos->txtp,rsv,shp);
1962 if (error) return error;
1963 if (shp && !(flgs & ATM_MF_IMMED)) return 0;
1964
1965
1966
1967
1968 tasklet_disable(&eni_dev->task);
1969 skb_queue_walk(&eni_dev->tx_queue, skb) {
1970 void __iomem *dsc;
1971
1972 if (ATM_SKB(skb)->vcc != vcc) continue;
1973 dsc = tx->send+ENI_PRV_POS(skb)*4;
1974 writel((readl(dsc) & ~(MID_SEG_RATE | MID_SEG_PR)) |
1975 (tx->prescaler << MID_SEG_PR_SHIFT) |
1976 (tx->resolution << MID_SEG_RATE_SHIFT), dsc);
1977 }
1978 tasklet_enable(&eni_dev->task);
1979 return 0;
1980}
1981
1982
1983static int eni_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
1984{
1985 struct eni_dev *eni_dev = ENI_DEV(dev);
1986
1987 if (cmd == ENI_MEMDUMP) {
1988 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1989 printk(KERN_WARNING "Please use /proc/atm/" DEV_LABEL ":%d "
1990 "instead of obsolete ioctl ENI_MEMDUMP\n",dev->number);
1991 dump(dev);
1992 return 0;
1993 }
1994 if (cmd == ENI_SETMULT) {
1995 struct eni_multipliers mult;
1996
1997 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1998 if (copy_from_user(&mult, arg,
1999 sizeof(struct eni_multipliers)))
2000 return -EFAULT;
2001 if ((mult.tx && mult.tx <= 100) || (mult.rx &&mult.rx <= 100) ||
2002 mult.tx > 65536 || mult.rx > 65536)
2003 return -EINVAL;
2004 if (mult.tx) eni_dev->tx_mult = mult.tx;
2005 if (mult.rx) eni_dev->rx_mult = mult.rx;
2006 return 0;
2007 }
2008 if (cmd == ATM_SETCIRANGE) {
2009 struct atm_cirange ci;
2010
2011 if (copy_from_user(&ci, arg,sizeof(struct atm_cirange)))
2012 return -EFAULT;
2013 if ((ci.vpi_bits == 0 || ci.vpi_bits == ATM_CI_MAX) &&
2014 (ci.vci_bits == NR_VCI_LD || ci.vpi_bits == ATM_CI_MAX))
2015 return 0;
2016 return -EINVAL;
2017 }
2018 if (!dev->phy->ioctl) return -ENOIOCTLCMD;
2019 return dev->phy->ioctl(dev,cmd,arg);
2020}
2021
2022
2023static int eni_getsockopt(struct atm_vcc *vcc,int level,int optname,
2024 void __user *optval,int optlen)
2025{
2026 return -EINVAL;
2027}
2028
2029
2030static int eni_setsockopt(struct atm_vcc *vcc,int level,int optname,
2031 void __user *optval,unsigned int optlen)
2032{
2033 return -EINVAL;
2034}
2035
2036
2037static int eni_send(struct atm_vcc *vcc,struct sk_buff *skb)
2038{
2039 enum enq_res res;
2040
2041 DPRINTK(">eni_send\n");
2042 if (!ENI_VCC(vcc)->tx) {
2043 if (vcc->pop) vcc->pop(vcc,skb);
2044 else dev_kfree_skb(skb);
2045 return -EINVAL;
2046 }
2047 if (!skb) {
2048 printk(KERN_CRIT "!skb in eni_send ?\n");
2049 if (vcc->pop) vcc->pop(vcc,skb);
2050 return -EINVAL;
2051 }
2052 if (vcc->qos.aal == ATM_AAL0) {
2053 if (skb->len != ATM_CELL_SIZE-1) {
2054 if (vcc->pop) vcc->pop(vcc,skb);
2055 else dev_kfree_skb(skb);
2056 return -EINVAL;
2057 }
2058 *(u32 *) skb->data = htonl(*(u32 *) skb->data);
2059 }
2060submitted++;
2061 ATM_SKB(skb)->vcc = vcc;
2062 tasklet_disable(&ENI_DEV(vcc->dev)->task);
2063 res = do_tx(skb);
2064 tasklet_enable(&ENI_DEV(vcc->dev)->task);
2065 if (res == enq_ok) return 0;
2066 skb_queue_tail(&ENI_VCC(vcc)->tx->backlog,skb);
2067backlogged++;
2068 tasklet_schedule(&ENI_DEV(vcc->dev)->task);
2069 return 0;
2070}
2071
2072static void eni_phy_put(struct atm_dev *dev,unsigned char value,
2073 unsigned long addr)
2074{
2075 writel(value,ENI_DEV(dev)->phy+addr*4);
2076}
2077
2078
2079
2080static unsigned char eni_phy_get(struct atm_dev *dev,unsigned long addr)
2081{
2082 return readl(ENI_DEV(dev)->phy+addr*4);
2083}
2084
2085
2086static int eni_proc_read(struct atm_dev *dev,loff_t *pos,char *page)
2087{
2088 struct hlist_node *node;
2089 struct sock *s;
2090 static const char *signal[] = { "LOST","unknown","okay" };
2091 struct eni_dev *eni_dev = ENI_DEV(dev);
2092 struct atm_vcc *vcc;
2093 int left,i;
2094
2095 left = *pos;
2096 if (!left)
2097 return sprintf(page,DEV_LABEL "(itf %d) signal %s, %dkB, "
2098 "%d cps remaining\n",dev->number,signal[(int) dev->signal],
2099 eni_dev->mem >> 10,eni_dev->tx_bw);
2100 if (!--left)
2101 return sprintf(page,"%4sBursts: TX"
2102#if !defined(CONFIG_ATM_ENI_BURST_TX_16W) && \
2103 !defined(CONFIG_ATM_ENI_BURST_TX_8W) && \
2104 !defined(CONFIG_ATM_ENI_BURST_TX_4W) && \
2105 !defined(CONFIG_ATM_ENI_BURST_TX_2W)
2106 " none"
2107#endif
2108#ifdef CONFIG_ATM_ENI_BURST_TX_16W
2109 " 16W"
2110#endif
2111#ifdef CONFIG_ATM_ENI_BURST_TX_8W
2112 " 8W"
2113#endif
2114#ifdef CONFIG_ATM_ENI_BURST_TX_4W
2115 " 4W"
2116#endif
2117#ifdef CONFIG_ATM_ENI_BURST_TX_2W
2118 " 2W"
2119#endif
2120 ", RX"
2121#if !defined(CONFIG_ATM_ENI_BURST_RX_16W) && \
2122 !defined(CONFIG_ATM_ENI_BURST_RX_8W) && \
2123 !defined(CONFIG_ATM_ENI_BURST_RX_4W) && \
2124 !defined(CONFIG_ATM_ENI_BURST_RX_2W)
2125 " none"
2126#endif
2127#ifdef CONFIG_ATM_ENI_BURST_RX_16W
2128 " 16W"
2129#endif
2130#ifdef CONFIG_ATM_ENI_BURST_RX_8W
2131 " 8W"
2132#endif
2133#ifdef CONFIG_ATM_ENI_BURST_RX_4W
2134 " 4W"
2135#endif
2136#ifdef CONFIG_ATM_ENI_BURST_RX_2W
2137 " 2W"
2138#endif
2139#ifndef CONFIG_ATM_ENI_TUNE_BURST
2140 " (default)"
2141#endif
2142 "\n","");
2143 if (!--left)
2144 return sprintf(page,"%4sBuffer multipliers: tx %d%%, rx %d%%\n",
2145 "",eni_dev->tx_mult,eni_dev->rx_mult);
2146 for (i = 0; i < NR_CHAN; i++) {
2147 struct eni_tx *tx = eni_dev->tx+i;
2148
2149 if (!tx->send) continue;
2150 if (!--left) {
2151 return sprintf(page,"tx[%d]: 0x%ld-0x%ld "
2152 "(%6ld bytes), rsv %d cps, shp %d cps%s\n",i,
2153 (unsigned long) (tx->send - eni_dev->ram),
2154 tx->send-eni_dev->ram+tx->words*4-1,tx->words*4,
2155 tx->reserved,tx->shaping,
2156 tx == eni_dev->ubr ? " (UBR)" : "");
2157 }
2158 if (--left) continue;
2159 return sprintf(page,"%10sbacklog %u packets\n","",
2160 skb_queue_len(&tx->backlog));
2161 }
2162 read_lock(&vcc_sklist_lock);
2163 for(i = 0; i < VCC_HTABLE_SIZE; ++i) {
2164 struct hlist_head *head = &vcc_hash[i];
2165
2166 sk_for_each(s, node, head) {
2167 struct eni_vcc *eni_vcc;
2168 int length;
2169
2170 vcc = atm_sk(s);
2171 if (vcc->dev != dev)
2172 continue;
2173 eni_vcc = ENI_VCC(vcc);
2174 if (--left) continue;
2175 length = sprintf(page,"vcc %4d: ",vcc->vci);
2176 if (eni_vcc->rx) {
2177 length += sprintf(page+length,"0x%ld-0x%ld "
2178 "(%6ld bytes)",
2179 (unsigned long) (eni_vcc->recv - eni_dev->ram),
2180 eni_vcc->recv-eni_dev->ram+eni_vcc->words*4-1,
2181 eni_vcc->words*4);
2182 if (eni_vcc->tx) length += sprintf(page+length,", ");
2183 }
2184 if (eni_vcc->tx)
2185 length += sprintf(page+length,"tx[%d], txing %d bytes",
2186 eni_vcc->tx->index,eni_vcc->txing);
2187 page[length] = '\n';
2188 read_unlock(&vcc_sklist_lock);
2189 return length+1;
2190 }
2191 }
2192 read_unlock(&vcc_sklist_lock);
2193 for (i = 0; i < eni_dev->free_len; i++) {
2194 struct eni_free *fe = eni_dev->free_list+i;
2195 unsigned long offset;
2196
2197 if (--left) continue;
2198 offset = (unsigned long) eni_dev->ram+eni_dev->base_diff;
2199 return sprintf(page,"free %p-%p (%6d bytes)\n",
2200 fe->start-offset,fe->start-offset+(1 << fe->order)-1,
2201 1 << fe->order);
2202 }
2203 return 0;
2204}
2205
2206
2207static const struct atmdev_ops ops = {
2208 .open = eni_open,
2209 .close = eni_close,
2210 .ioctl = eni_ioctl,
2211 .getsockopt = eni_getsockopt,
2212 .setsockopt = eni_setsockopt,
2213 .send = eni_send,
2214 .phy_put = eni_phy_put,
2215 .phy_get = eni_phy_get,
2216 .change_qos = eni_change_qos,
2217 .proc_read = eni_proc_read
2218};
2219
2220
2221static int __devinit eni_init_one(struct pci_dev *pci_dev,
2222 const struct pci_device_id *ent)
2223{
2224 struct atm_dev *dev;
2225 struct eni_dev *eni_dev;
2226 int error = -ENOMEM;
2227
2228 DPRINTK("eni_init_one\n");
2229
2230 if (pci_enable_device(pci_dev)) {
2231 error = -EIO;
2232 goto out0;
2233 }
2234
2235 eni_dev = kmalloc(sizeof(struct eni_dev),GFP_KERNEL);
2236 if (!eni_dev) goto out0;
2237 if (!cpu_zeroes) {
2238 cpu_zeroes = pci_alloc_consistent(pci_dev,ENI_ZEROES_SIZE,
2239 &zeroes);
2240 if (!cpu_zeroes) goto out1;
2241 }
2242 dev = atm_dev_register(DEV_LABEL, &pci_dev->dev, &ops, -1, NULL);
2243 if (!dev) goto out2;
2244 pci_set_drvdata(pci_dev, dev);
2245 eni_dev->pci_dev = pci_dev;
2246 dev->dev_data = eni_dev;
2247 eni_dev->asic = ent->driver_data;
2248 error = eni_do_init(dev);
2249 if (error) goto out3;
2250 error = eni_start(dev);
2251 if (error) goto out3;
2252 eni_dev->more = eni_boards;
2253 eni_boards = dev;
2254 return 0;
2255out3:
2256 atm_dev_deregister(dev);
2257out2:
2258 pci_free_consistent(eni_dev->pci_dev,ENI_ZEROES_SIZE,cpu_zeroes,zeroes);
2259 cpu_zeroes = NULL;
2260out1:
2261 kfree(eni_dev);
2262out0:
2263 return error;
2264}
2265
2266
2267static struct pci_device_id eni_pci_tbl[] = {
2268 { PCI_VDEVICE(EF, PCI_DEVICE_ID_EF_ATM_FPGA), 0 },
2269 { PCI_VDEVICE(EF, PCI_DEVICE_ID_EF_ATM_ASIC), 1 },
2270 { 0, }
2271};
2272MODULE_DEVICE_TABLE(pci,eni_pci_tbl);
2273
2274
2275static void __devexit eni_remove_one(struct pci_dev *pci_dev)
2276{
2277
2278}
2279
2280
2281static struct pci_driver eni_driver = {
2282 .name = DEV_LABEL,
2283 .id_table = eni_pci_tbl,
2284 .probe = eni_init_one,
2285 .remove = __devexit_p(eni_remove_one),
2286};
2287
2288
2289static int __init eni_init(void)
2290{
2291 struct sk_buff *skb;
2292
2293 if (sizeof(skb->cb) < sizeof(struct eni_skb_prv)) {
2294 printk(KERN_ERR "eni_detect: skb->cb is too small (%Zd < %Zd)\n",
2295 sizeof(skb->cb),sizeof(struct eni_skb_prv));
2296 return -EIO;
2297 }
2298 return pci_register_driver(&eni_driver);
2299}
2300
2301
2302module_init(eni_init);
2303
2304
2305MODULE_LICENSE("GPL");
2306
