1
2
3
4
5
6
7#include <linux/module.h>
8#include <linux/kernel.h>
9#include <linux/mm.h>
10#include <linux/pci.h>
11#include <linux/errno.h>
12#include <linux/atm.h>
13#include <linux/atmdev.h>
14#include <linux/sonet.h>
15#include <linux/skbuff.h>
16#include <linux/time.h>
17#include <linux/delay.h>
18#include <linux/uio.h>
19#include <linux/init.h>
20#include <linux/atm_eni.h>
21#include <linux/bitops.h>
22#include <linux/slab.h>
23#include <asm/io.h>
24#include <linux/atomic.h>
25#include <linux/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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59#if 0
60#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
61#else
62#define DPRINTK(format,args...)
63#endif
64
65
66#ifndef CONFIG_ATM_ENI_TUNE_BURST
67#define CONFIG_ATM_ENI_BURST_TX_8W
68#define CONFIG_ATM_ENI_BURST_RX_4W
69#endif
70
71
72#ifndef CONFIG_ATM_ENI_DEBUG
73
74
75#define NULLCHECK(x)
76
77#define EVENT(s,a,b)
78
79
80static void event_dump(void)
81{
82}
83
84
85#else
86
87
88
89
90
91
92#define NULLCHECK(x) \
93 if ((unsigned long) (x) < 0x30) \
94 printk(KERN_CRIT #x "==0x%lx\n",(unsigned long) (x))
95
96
97
98
99
100
101#define EV 64
102
103static const char *ev[EV];
104static unsigned long ev_a[EV],ev_b[EV];
105static int ec = 0;
106
107
108static void EVENT(const char *s,unsigned long a,unsigned long b)
109{
110 ev[ec] = s;
111 ev_a[ec] = a;
112 ev_b[ec] = b;
113 ec = (ec+1) % EV;
114}
115
116
117static void event_dump(void)
118{
119 int n,i;
120
121 for (n = 0; n < EV; n++) {
122 i = (ec+n) % EV;
123 printk(KERN_NOTICE);
124 printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]);
125 }
126}
127
128
129#endif
130
131
132
133
134
135
136
137
138
139#define NEPJOK(a0,a1,b) \
140 ((a0) < (a1) ? (b) <= (a0) || (b) > (a1) : (b) <= (a0) && (b) > (a1))
141#define EEPJOK(a0,a1,b) \
142 ((a0) < (a1) ? (b) < (a0) || (b) >= (a1) : (b) < (a0) && (b) >= (a1))
143#define NEPMOK(a0,d,b,c) NEPJOK(a0,(a0+d) & (c-1),b)
144#define EEPMOK(a0,d,b,c) EEPJOK(a0,(a0+d) & (c-1),b)
145
146
147static int tx_complete = 0,dma_complete = 0,queued = 0,requeued = 0,
148 backlogged = 0,rx_enqueued = 0,rx_dequeued = 0,pushed = 0,submitted = 0,
149 putting = 0;
150
151static struct atm_dev *eni_boards = NULL;
152
153
154#define eni_in(r) readl(eni_dev->reg+(r)*4)
155#define eni_out(v,r) writel((v),eni_dev->reg+(r)*4)
156
157
158
159
160
161static void dump_mem(struct eni_dev *eni_dev)
162{
163 int i;
164
165 for (i = 0; i < eni_dev->free_len; i++)
166 printk(KERN_DEBUG " %d: %p %d\n",i,
167 eni_dev->free_list[i].start,
168 1 << eni_dev->free_list[i].order);
169}
170
171
172static void dump(struct atm_dev *dev)
173{
174 struct eni_dev *eni_dev;
175
176 int i;
177
178 eni_dev = ENI_DEV(dev);
179 printk(KERN_NOTICE "Free memory\n");
180 dump_mem(eni_dev);
181 printk(KERN_NOTICE "TX buffers\n");
182 for (i = 0; i < NR_CHAN; i++)
183 if (eni_dev->tx[i].send)
184 printk(KERN_NOTICE " TX %d @ %p: %ld\n",i,
185 eni_dev->tx[i].send,eni_dev->tx[i].words*4);
186 printk(KERN_NOTICE "RX buffers\n");
187 for (i = 0; i < 1024; i++)
188 if (eni_dev->rx_map[i] && ENI_VCC(eni_dev->rx_map[i])->rx)
189 printk(KERN_NOTICE " RX %d @ %p: %ld\n",i,
190 ENI_VCC(eni_dev->rx_map[i])->recv,
191 ENI_VCC(eni_dev->rx_map[i])->words*4);
192 printk(KERN_NOTICE "----\n");
193}
194
195
196static void eni_put_free(struct eni_dev *eni_dev, void __iomem *start,
197 unsigned long size)
198{
199 struct eni_free *list;
200 int len,order;
201
202 DPRINTK("init 0x%lx+%ld(0x%lx)\n",start,size,size);
203 start += eni_dev->base_diff;
204 list = eni_dev->free_list;
205 len = eni_dev->free_len;
206 while (size) {
207 if (len >= eni_dev->free_list_size) {
208 printk(KERN_CRIT "eni_put_free overflow (%p,%ld)\n",
209 start,size);
210 break;
211 }
212 for (order = 0; !(((unsigned long)start | size) & (1 << order)); order++);
213 if (MID_MIN_BUF_SIZE > (1 << order)) {
214 printk(KERN_CRIT "eni_put_free: order %d too small\n",
215 order);
216 break;
217 }
218 list[len].start = (void __iomem *) start;
219 list[len].order = order;
220 len++;
221 start += 1 << order;
222 size -= 1 << order;
223 }
224 eni_dev->free_len = len;
225
226}
227
228
229static void __iomem *eni_alloc_mem(struct eni_dev *eni_dev, unsigned long *size)
230{
231 struct eni_free *list;
232 void __iomem *start;
233 int len,i,order,best_order,index;
234
235 list = eni_dev->free_list;
236 len = eni_dev->free_len;
237 if (*size < MID_MIN_BUF_SIZE) *size = MID_MIN_BUF_SIZE;
238 if (*size > MID_MAX_BUF_SIZE) return NULL;
239 for (order = 0; (1 << order) < *size; order++)
240 ;
241 DPRINTK("trying: %ld->%d\n",*size,order);
242 best_order = 65;
243 index = 0;
244 for (i = 0; i < len; i++)
245 if (list[i].order == order) {
246 best_order = order;
247 index = i;
248 break;
249 }
250 else if (best_order > list[i].order && list[i].order > order) {
251 best_order = list[i].order;
252 index = i;
253 }
254 if (best_order == 65) return NULL;
255 start = list[index].start-eni_dev->base_diff;
256 list[index] = list[--len];
257 eni_dev->free_len = len;
258 *size = 1 << order;
259 eni_put_free(eni_dev,start+*size,(1 << best_order)-*size);
260 DPRINTK("%ld bytes (order %d) at 0x%lx\n",*size,order,start);
261 memset_io(start,0,*size);
262
263 return start;
264}
265
266
267static void eni_free_mem(struct eni_dev *eni_dev, void __iomem *start,
268 unsigned long size)
269{
270 struct eni_free *list;
271 int len,i,order;
272
273 start += eni_dev->base_diff;
274 list = eni_dev->free_list;
275 len = eni_dev->free_len;
276 for (order = -1; size; order++) size >>= 1;
277 DPRINTK("eni_free_mem: %p+0x%lx (order %d)\n",start,size,order);
278 for (i = 0; i < len; i++)
279 if (((unsigned long) list[i].start) == ((unsigned long)start^(1 << order)) &&
280 list[i].order == order) {
281 DPRINTK("match[%d]: 0x%lx/0x%lx(0x%x), %d/%d\n",i,
282 list[i].start,start,1 << order,list[i].order,order);
283 list[i] = list[--len];
284 start = (void __iomem *) ((unsigned long) start & ~(unsigned long) (1 << order));
285 order++;
286 i = -1;
287 continue;
288 }
289 if (len >= eni_dev->free_list_size) {
290 printk(KERN_ALERT "eni_free_mem overflow (%p,%d)\n",start,
291 order);
292 return;
293 }
294 list[len].start = start;
295 list[len].order = order;
296 eni_dev->free_len = len+1;
297
298}
299
300
301
302
303
304#define ENI_VCC_NOS ((struct atm_vcc *) 1)
305
306
307static void rx_ident_err(struct atm_vcc *vcc)
308{
309 struct atm_dev *dev;
310 struct eni_dev *eni_dev;
311 struct eni_vcc *eni_vcc;
312
313 dev = vcc->dev;
314 eni_dev = ENI_DEV(dev);
315
316 eni_out(eni_in(MID_MC_S) &
317 ~(MID_DMA_ENABLE | MID_TX_ENABLE | MID_RX_ENABLE),MID_MC_S);
318
319 eni_vcc = ENI_VCC(vcc);
320 printk(KERN_ALERT DEV_LABEL "(itf %d): driver error - RX ident "
321 "mismatch\n",dev->number);
322 printk(KERN_ALERT " VCI %d, rxing %d, words %ld\n",vcc->vci,
323 eni_vcc->rxing,eni_vcc->words);
324 printk(KERN_ALERT " host descr 0x%lx, rx pos 0x%lx, descr value "
325 "0x%x\n",eni_vcc->descr,eni_vcc->rx_pos,
326 (unsigned) readl(eni_vcc->recv+eni_vcc->descr*4));
327 printk(KERN_ALERT " last %p, servicing %d\n",eni_vcc->last,
328 eni_vcc->servicing);
329 EVENT("---dump ends here---\n",0,0);
330 printk(KERN_NOTICE "---recent events---\n");
331 event_dump();
332 ENI_DEV(dev)->fast = NULL;
333 ENI_DEV(dev)->slow = NULL;
334 skb_queue_head_init(&ENI_DEV(dev)->rx_queue);
335}
336
337
338static int do_rx_dma(struct atm_vcc *vcc,struct sk_buff *skb,
339 unsigned long skip,unsigned long size,unsigned long eff)
340{
341 struct eni_dev *eni_dev;
342 struct eni_vcc *eni_vcc;
343 u32 dma_rd,dma_wr;
344 u32 dma[RX_DMA_BUF*2];
345 dma_addr_t paddr;
346 unsigned long here;
347 int i,j;
348
349 eni_dev = ENI_DEV(vcc->dev);
350 eni_vcc = ENI_VCC(vcc);
351 paddr = 0;
352 if (skb) {
353 paddr = dma_map_single(&eni_dev->pci_dev->dev,skb->data,skb->len,
354 DMA_FROM_DEVICE);
355 if (dma_mapping_error(&eni_dev->pci_dev->dev, paddr))
356 goto dma_map_error;
357 ENI_PRV_PADDR(skb) = paddr;
358 if (paddr & 3)
359 printk(KERN_CRIT DEV_LABEL "(itf %d): VCI %d has "
360 "mis-aligned RX data (0x%lx)\n",vcc->dev->number,
361 vcc->vci,(unsigned long) paddr);
362 ENI_PRV_SIZE(skb) = size+skip;
363
364 ATM_SKB(skb)->vcc = vcc;
365 }
366 j = 0;
367 if ((eff && skip) || 1) {
368 here = (eni_vcc->descr+skip) & (eni_vcc->words-1);
369 dma[j++] = (here << MID_DMA_COUNT_SHIFT) | (vcc->vci
370 << MID_DMA_VCI_SHIFT) | MID_DT_JK;
371 dma[j++] = 0;
372 }
373 here = (eni_vcc->descr+size+skip) & (eni_vcc->words-1);
374 if (!eff) size += skip;
375 else {
376 unsigned long words;
377
378 if (!size) {
379 DPRINTK("strange things happen ...\n");
380 EVENT("strange things happen ... (skip=%ld,eff=%ld)\n",
381 size,eff);
382 }
383 words = eff;
384 if (paddr & 15) {
385 unsigned long init;
386
387 init = 4-((paddr & 15) >> 2);
388 if (init > words) init = words;
389 dma[j++] = MID_DT_WORD | (init << MID_DMA_COUNT_SHIFT) |
390 (vcc->vci << MID_DMA_VCI_SHIFT);
391 dma[j++] = paddr;
392 paddr += init << 2;
393 words -= init;
394 }
395#ifdef CONFIG_ATM_ENI_BURST_RX_16W
396 if (words & ~15) {
397 dma[j++] = MID_DT_16W | ((words >> 4) <<
398 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
399 MID_DMA_VCI_SHIFT);
400 dma[j++] = paddr;
401 paddr += (words & ~15) << 2;
402 words &= 15;
403 }
404#endif
405#ifdef CONFIG_ATM_ENI_BURST_RX_8W
406 if (words & ~7) {
407 dma[j++] = MID_DT_8W | ((words >> 3) <<
408 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
409 MID_DMA_VCI_SHIFT);
410 dma[j++] = paddr;
411 paddr += (words & ~7) << 2;
412 words &= 7;
413 }
414#endif
415#ifdef CONFIG_ATM_ENI_BURST_RX_4W
416 if (words & ~3) {
417 dma[j++] = MID_DT_4W | ((words >> 2) <<
418 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
419 MID_DMA_VCI_SHIFT);
420 dma[j++] = paddr;
421 paddr += (words & ~3) << 2;
422 words &= 3;
423 }
424#endif
425#ifdef CONFIG_ATM_ENI_BURST_RX_2W
426 if (words & ~1) {
427 dma[j++] = MID_DT_2W | ((words >> 1) <<
428 MID_DMA_COUNT_SHIFT) | (vcc->vci <<
429 MID_DMA_VCI_SHIFT);
430 dma[j++] = paddr;
431 paddr += (words & ~1) << 2;
432 words &= 1;
433 }
434#endif
435 if (words) {
436 dma[j++] = MID_DT_WORD | (words << MID_DMA_COUNT_SHIFT)
437 | (vcc->vci << MID_DMA_VCI_SHIFT);
438 dma[j++] = paddr;
439 }
440 }
441 if (size != eff) {
442 dma[j++] = (here << MID_DMA_COUNT_SHIFT) |
443 (vcc->vci << MID_DMA_VCI_SHIFT) | MID_DT_JK;
444 dma[j++] = 0;
445 }
446 if (!j || j > 2*RX_DMA_BUF) {
447 printk(KERN_CRIT DEV_LABEL "!j or j too big!!!\n");
448 goto trouble;
449 }
450 dma[j-2] |= MID_DMA_END;
451 j = j >> 1;
452 dma_wr = eni_in(MID_DMA_WR_RX);
453 dma_rd = eni_in(MID_DMA_RD_RX);
454
455
456
457
458 if (!NEPMOK(dma_wr,j+j+1,dma_rd,NR_DMA_RX)) {
459 printk(KERN_WARNING DEV_LABEL "(itf %d): RX DMA full\n",
460 vcc->dev->number);
461 goto trouble;
462 }
463 for (i = 0; i < j; i++) {
464 writel(dma[i*2],eni_dev->rx_dma+dma_wr*8);
465 writel(dma[i*2+1],eni_dev->rx_dma+dma_wr*8+4);
466 dma_wr = (dma_wr+1) & (NR_DMA_RX-1);
467 }
468 if (skb) {
469 ENI_PRV_POS(skb) = eni_vcc->descr+size+1;
470 skb_queue_tail(&eni_dev->rx_queue,skb);
471 eni_vcc->last = skb;
472 rx_enqueued++;
473 }
474 eni_vcc->descr = here;
475 eni_out(dma_wr,MID_DMA_WR_RX);
476 return 0;
477
478trouble:
479 if (paddr)
480 dma_unmap_single(&eni_dev->pci_dev->dev,paddr,skb->len,
481 DMA_FROM_DEVICE);
482dma_map_error:
483 if (skb) dev_kfree_skb_irq(skb);
484 return -1;
485}
486
487
488static void discard(struct atm_vcc *vcc,unsigned long size)
489{
490 struct eni_vcc *eni_vcc;
491
492 eni_vcc = ENI_VCC(vcc);
493 EVENT("discard (size=%ld)\n",size,0);
494 while (do_rx_dma(vcc,NULL,1,size,0)) EVENT("BUSY LOOP",0,0);
495
496 if (eni_vcc->rxing) ENI_PRV_POS(eni_vcc->last) += size+1;
497 else eni_vcc->rx_pos = (eni_vcc->rx_pos+size+1) & (eni_vcc->words-1);
498}
499
500
501
502
503
504
505
506static int rx_aal0(struct atm_vcc *vcc)
507{
508 struct eni_vcc *eni_vcc;
509 unsigned long descr;
510 unsigned long length;
511 struct sk_buff *skb;
512
513 DPRINTK(">rx_aal0\n");
514 eni_vcc = ENI_VCC(vcc);
515 descr = readl(eni_vcc->recv+eni_vcc->descr*4);
516 if ((descr & MID_RED_IDEN) != (MID_RED_RX_ID << MID_RED_SHIFT)) {
517 rx_ident_err(vcc);
518 return 1;
519 }
520 if (descr & MID_RED_T) {
521 DPRINTK(DEV_LABEL "(itf %d): trashing empty cell\n",
522 vcc->dev->number);
523 length = 0;
524 atomic_inc(&vcc->stats->rx_err);
525 }
526 else {
527 length = ATM_CELL_SIZE-1;
528 }
529 skb = length ? atm_alloc_charge(vcc,length,GFP_ATOMIC) : NULL;
530 if (!skb) {
531 discard(vcc,length >> 2);
532 return 0;
533 }
534 skb_put(skb,length);
535 skb->tstamp = eni_vcc->timestamp;
536 DPRINTK("got len %ld\n",length);
537 if (do_rx_dma(vcc,skb,1,length >> 2,length >> 2)) return 1;
538 eni_vcc->rxing++;
539 return 0;
540}
541
542
543static int rx_aal5(struct atm_vcc *vcc)
544{
545 struct eni_vcc *eni_vcc;
546 unsigned long descr;
547 unsigned long size,eff,length;
548 struct sk_buff *skb;
549
550 EVENT("rx_aal5\n",0,0);
551 DPRINTK(">rx_aal5\n");
552 eni_vcc = ENI_VCC(vcc);
553 descr = readl(eni_vcc->recv+eni_vcc->descr*4);
554 if ((descr & MID_RED_IDEN) != (MID_RED_RX_ID << MID_RED_SHIFT)) {
555 rx_ident_err(vcc);
556 return 1;
557 }
558 if (descr & (MID_RED_T | MID_RED_CRC_ERR)) {
559 if (descr & MID_RED_T) {
560 EVENT("empty cell (descr=0x%lx)\n",descr,0);
561 DPRINTK(DEV_LABEL "(itf %d): trashing empty cell\n",
562 vcc->dev->number);
563 size = 0;
564 }
565 else {
566 static unsigned long silence = 0;
567
568 if (time_after(jiffies, silence) || silence == 0) {
569 printk(KERN_WARNING DEV_LABEL "(itf %d): "
570 "discarding PDU(s) with CRC error\n",
571 vcc->dev->number);
572 silence = (jiffies+2*HZ)|1;
573 }
574 size = (descr & MID_RED_COUNT)*(ATM_CELL_PAYLOAD >> 2);
575 EVENT("CRC error (descr=0x%lx,size=%ld)\n",descr,
576 size);
577 }
578 eff = length = 0;
579 atomic_inc(&vcc->stats->rx_err);
580 }
581 else {
582 size = (descr & MID_RED_COUNT)*(ATM_CELL_PAYLOAD >> 2);
583 DPRINTK("size=%ld\n",size);
584 length = readl(eni_vcc->recv+(((eni_vcc->descr+size-1) &
585 (eni_vcc->words-1)))*4) & 0xffff;
586
587 if (length && length <= (size << 2)-8 && length <=
588 ATM_MAX_AAL5_PDU) eff = (length+3) >> 2;
589 else {
590 EVENT("bad PDU (descr=0x08%lx,length=%ld)\n",descr,
591 length);
592 printk(KERN_ERR DEV_LABEL "(itf %d): bad AAL5 PDU "
593 "(VCI=%d,length=%ld,size=%ld (descr 0x%lx))\n",
594 vcc->dev->number,vcc->vci,length,size << 2,descr);
595 length = eff = 0;
596 atomic_inc(&vcc->stats->rx_err);
597 }
598 }
599 skb = eff ? atm_alloc_charge(vcc,eff << 2,GFP_ATOMIC) : NULL;
600 if (!skb) {
601 discard(vcc,size);
602 return 0;
603 }
604 skb_put(skb,length);
605 DPRINTK("got len %ld\n",length);
606 if (do_rx_dma(vcc,skb,1,size,eff)) return 1;
607 eni_vcc->rxing++;
608 return 0;
609}
610
611
612static inline int rx_vcc(struct atm_vcc *vcc)
613{
614 void __iomem *vci_dsc;
615 unsigned long tmp;
616 struct eni_vcc *eni_vcc;
617
618 eni_vcc = ENI_VCC(vcc);
619 vci_dsc = ENI_DEV(vcc->dev)->vci+vcc->vci*16;
620 EVENT("rx_vcc(1)\n",0,0);
621 while (eni_vcc->descr != (tmp = (readl(vci_dsc+4) & MID_VCI_DESCR) >>
622 MID_VCI_DESCR_SHIFT)) {
623 EVENT("rx_vcc(2: host dsc=0x%lx, nic dsc=0x%lx)\n",
624 eni_vcc->descr,tmp);
625 DPRINTK("CB_DESCR %ld REG_DESCR %d\n",ENI_VCC(vcc)->descr,
626 (((unsigned) readl(vci_dsc+4) & MID_VCI_DESCR) >>
627 MID_VCI_DESCR_SHIFT));
628 if (ENI_VCC(vcc)->rx(vcc)) return 1;
629 }
630
631 writel(readl(vci_dsc) & ~MID_VCI_IN_SERVICE,vci_dsc);
632
633
634
635
636
637 EVENT("rx_vcc(3)\n",0,0);
638 while (ENI_VCC(vcc)->descr != (tmp = (readl(vci_dsc+4) & MID_VCI_DESCR)
639 >> MID_VCI_DESCR_SHIFT)) {
640 EVENT("rx_vcc(4: host dsc=0x%lx, nic dsc=0x%lx)\n",
641 eni_vcc->descr,tmp);
642 DPRINTK("CB_DESCR %ld REG_DESCR %d\n",ENI_VCC(vcc)->descr,
643 (((unsigned) readl(vci_dsc+4) & MID_VCI_DESCR) >>
644 MID_VCI_DESCR_SHIFT));
645 if (ENI_VCC(vcc)->rx(vcc)) return 1;
646 }
647 return 0;
648}
649
650
651static void poll_rx(struct atm_dev *dev)
652{
653 struct eni_dev *eni_dev;
654 struct atm_vcc *curr;
655
656 eni_dev = ENI_DEV(dev);
657 while ((curr = eni_dev->fast)) {
658 EVENT("poll_rx.fast\n",0,0);
659 if (rx_vcc(curr)) return;
660 eni_dev->fast = ENI_VCC(curr)->next;
661 ENI_VCC(curr)->next = ENI_VCC_NOS;
662 barrier();
663 ENI_VCC(curr)->servicing--;
664 }
665 while ((curr = eni_dev->slow)) {
666 EVENT("poll_rx.slow\n",0,0);
667 if (rx_vcc(curr)) return;
668 eni_dev->slow = ENI_VCC(curr)->next;
669 ENI_VCC(curr)->next = ENI_VCC_NOS;
670 barrier();
671 ENI_VCC(curr)->servicing--;
672 }
673}
674
675
676static void get_service(struct atm_dev *dev)
677{
678 struct eni_dev *eni_dev;
679 struct atm_vcc *vcc;
680 unsigned long vci;
681
682 DPRINTK(">get_service\n");
683 eni_dev = ENI_DEV(dev);
684 while (eni_in(MID_SERV_WRITE) != eni_dev->serv_read) {
685 vci = readl(eni_dev->service+eni_dev->serv_read*4);
686 eni_dev->serv_read = (eni_dev->serv_read+1) & (NR_SERVICE-1);
687 vcc = eni_dev->rx_map[vci & 1023];
688 if (!vcc) {
689 printk(KERN_CRIT DEV_LABEL "(itf %d): VCI %ld not "
690 "found\n",dev->number,vci);
691 continue;
692
693 }
694 EVENT("getting from service\n",0,0);
695 if (ENI_VCC(vcc)->next != ENI_VCC_NOS) {
696 EVENT("double service\n",0,0);
697 DPRINTK("Grr, servicing VCC %ld twice\n",vci);
698 continue;
699 }
700 ENI_VCC(vcc)->timestamp = ktime_get_real();
701 ENI_VCC(vcc)->next = NULL;
702 if (vcc->qos.rxtp.traffic_class == ATM_CBR) {
703 if (eni_dev->fast)
704 ENI_VCC(eni_dev->last_fast)->next = vcc;
705 else eni_dev->fast = vcc;
706 eni_dev->last_fast = vcc;
707 }
708 else {
709 if (eni_dev->slow)
710 ENI_VCC(eni_dev->last_slow)->next = vcc;
711 else eni_dev->slow = vcc;
712 eni_dev->last_slow = vcc;
713 }
714 putting++;
715 ENI_VCC(vcc)->servicing++;
716 }
717}
718
719
720static void dequeue_rx(struct atm_dev *dev)
721{
722 struct eni_dev *eni_dev;
723 struct eni_vcc *eni_vcc;
724 struct atm_vcc *vcc;
725 struct sk_buff *skb;
726 void __iomem *vci_dsc;
727 int first;
728
729 eni_dev = ENI_DEV(dev);
730 first = 1;
731 while (1) {
732 skb = skb_dequeue(&eni_dev->rx_queue);
733 if (!skb) {
734 if (first) {
735 DPRINTK(DEV_LABEL "(itf %d): RX but not "
736 "rxing\n",dev->number);
737 EVENT("nothing to dequeue\n",0,0);
738 }
739 break;
740 }
741 EVENT("dequeued (size=%ld,pos=0x%lx)\n",ENI_PRV_SIZE(skb),
742 ENI_PRV_POS(skb));
743 rx_dequeued++;
744 vcc = ATM_SKB(skb)->vcc;
745 eni_vcc = ENI_VCC(vcc);
746 first = 0;
747 vci_dsc = eni_dev->vci+vcc->vci*16;
748 if (!EEPMOK(eni_vcc->rx_pos,ENI_PRV_SIZE(skb),
749 (readl(vci_dsc+4) & MID_VCI_READ) >> MID_VCI_READ_SHIFT,
750 eni_vcc->words)) {
751 EVENT("requeuing\n",0,0);
752 skb_queue_head(&eni_dev->rx_queue,skb);
753 break;
754 }
755 eni_vcc->rxing--;
756 eni_vcc->rx_pos = ENI_PRV_POS(skb) & (eni_vcc->words-1);
757 dma_unmap_single(&eni_dev->pci_dev->dev,ENI_PRV_PADDR(skb),skb->len,
758 DMA_TO_DEVICE);
759 if (!skb->len) dev_kfree_skb_irq(skb);
760 else {
761 EVENT("pushing (len=%ld)\n",skb->len,0);
762 if (vcc->qos.aal == ATM_AAL0)
763 *(unsigned long *) skb->data =
764 ntohl(*(unsigned long *) skb->data);
765 memset(skb->cb,0,sizeof(struct eni_skb_prv));
766 vcc->push(vcc,skb);
767 pushed++;
768 }
769 atomic_inc(&vcc->stats->rx);
770 }
771 wake_up(&eni_dev->rx_wait);
772}
773
774
775static int open_rx_first(struct atm_vcc *vcc)
776{
777 struct eni_dev *eni_dev;
778 struct eni_vcc *eni_vcc;
779 unsigned long size;
780
781 DPRINTK("open_rx_first\n");
782 eni_dev = ENI_DEV(vcc->dev);
783 eni_vcc = ENI_VCC(vcc);
784 eni_vcc->rx = NULL;
785 if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0;
786 size = vcc->qos.rxtp.max_sdu*eni_dev->rx_mult/100;
787 if (size > MID_MAX_BUF_SIZE && vcc->qos.rxtp.max_sdu <=
788 MID_MAX_BUF_SIZE)
789 size = MID_MAX_BUF_SIZE;
790 eni_vcc->recv = eni_alloc_mem(eni_dev,&size);
791 DPRINTK("rx at 0x%lx\n",eni_vcc->recv);
792 eni_vcc->words = size >> 2;
793 if (!eni_vcc->recv) return -ENOBUFS;
794 eni_vcc->rx = vcc->qos.aal == ATM_AAL5 ? rx_aal5 : rx_aal0;
795 eni_vcc->descr = 0;
796 eni_vcc->rx_pos = 0;
797 eni_vcc->rxing = 0;
798 eni_vcc->servicing = 0;
799 eni_vcc->next = ENI_VCC_NOS;
800 return 0;
801}
802
803
804static int open_rx_second(struct atm_vcc *vcc)
805{
806 void __iomem *here;
807 struct eni_dev *eni_dev;
808 struct eni_vcc *eni_vcc;
809 unsigned long size;
810 int order;
811
812 DPRINTK("open_rx_second\n");
813 eni_dev = ENI_DEV(vcc->dev);
814 eni_vcc = ENI_VCC(vcc);
815 if (!eni_vcc->rx) return 0;
816
817 here = eni_dev->vci+vcc->vci*16;
818 DPRINTK("loc 0x%x\n",(unsigned) (eni_vcc->recv-eni_dev->ram)/4);
819 size = eni_vcc->words >> 8;
820 for (order = -1; size; order++) size >>= 1;
821 writel(0,here+4);
822 writel(0,here+8);
823 if (eni_dev->rx_map[vcc->vci])
824 printk(KERN_CRIT DEV_LABEL "(itf %d): BUG - VCI %d already "
825 "in use\n",vcc->dev->number,vcc->vci);
826 eni_dev->rx_map[vcc->vci] = vcc;
827 writel(((vcc->qos.aal != ATM_AAL5 ? MID_MODE_RAW : MID_MODE_AAL5) <<
828 MID_VCI_MODE_SHIFT) | MID_VCI_PTI_MODE |
829 (((eni_vcc->recv-eni_dev->ram) >> (MID_LOC_SKIP+2)) <<
830 MID_VCI_LOCATION_SHIFT) | (order << MID_VCI_SIZE_SHIFT),here);
831 return 0;
832}
833
834
835static void close_rx(struct atm_vcc *vcc)
836{
837 DECLARE_WAITQUEUE(wait,current);
838 void __iomem *here;
839 struct eni_dev *eni_dev;
840 struct eni_vcc *eni_vcc;
841
842 eni_vcc = ENI_VCC(vcc);
843 if (!eni_vcc->rx) return;
844 eni_dev = ENI_DEV(vcc->dev);
845 if (vcc->vpi != ATM_VPI_UNSPEC && vcc->vci != ATM_VCI_UNSPEC) {
846 here = eni_dev->vci+vcc->vci*16;
847
848 writel((readl(here) & ~MID_VCI_MODE) | (MID_MODE_TRASH <<
849 MID_VCI_MODE_SHIFT),here);
850
851 udelay(27);
852
853 writel(readl(here) & ~MID_VCI_IN_SERVICE,here);
854
855 eni_dev->rx_map[vcc->vci] = NULL;
856
857 DPRINTK("eni_close: waiting for RX ...\n");
858 EVENT("RX closing\n",0,0);
859 add_wait_queue(&eni_dev->rx_wait,&wait);
860 set_current_state(TASK_UNINTERRUPTIBLE);
861 barrier();
862 for (;;) {
863
864 if (!eni_vcc->servicing) {
865 barrier();
866 if (!eni_vcc->rxing) break;
867 }
868 EVENT("drain PDUs (rx %ld, serv %ld)\n",eni_vcc->rxing,
869 eni_vcc->servicing);
870 printk(KERN_INFO "%d+%d RX left\n",eni_vcc->servicing,
871 eni_vcc->rxing);
872 schedule();
873 set_current_state(TASK_UNINTERRUPTIBLE);
874 }
875 for (;;) {
876 int at_end;
877 u32 tmp;
878
879 tasklet_disable(&eni_dev->task);
880 tmp = readl(eni_dev->vci+vcc->vci*16+4) & MID_VCI_READ;
881 at_end = eni_vcc->rx_pos == tmp >> MID_VCI_READ_SHIFT;
882 tasklet_enable(&eni_dev->task);
883 if (at_end) break;
884 EVENT("drain discard (host 0x%lx, nic 0x%lx)\n",
885 eni_vcc->rx_pos,tmp);
886 printk(KERN_INFO "draining RX: host 0x%lx, nic 0x%x\n",
887 eni_vcc->rx_pos,tmp);
888 schedule();
889 set_current_state(TASK_UNINTERRUPTIBLE);
890 }
891 set_current_state(TASK_RUNNING);
892 remove_wait_queue(&eni_dev->rx_wait,&wait);
893 }
894 eni_free_mem(eni_dev,eni_vcc->recv,eni_vcc->words << 2);
895 eni_vcc->rx = NULL;
896}
897
898
899static int start_rx(struct atm_dev *dev)
900{
901 struct eni_dev *eni_dev;
902
903 eni_dev = ENI_DEV(dev);
904 eni_dev->rx_map = (struct atm_vcc **) get_zeroed_page(GFP_KERNEL);
905 if (!eni_dev->rx_map) {
906 printk(KERN_ERR DEV_LABEL "(itf %d): couldn't get free page\n",
907 dev->number);
908 free_page((unsigned long) eni_dev->free_list);
909 return -ENOMEM;
910 }
911 eni_dev->rx_mult = DEFAULT_RX_MULT;
912 eni_dev->fast = eni_dev->last_fast = NULL;
913 eni_dev->slow = eni_dev->last_slow = NULL;
914 init_waitqueue_head(&eni_dev->rx_wait);
915 skb_queue_head_init(&eni_dev->rx_queue);
916 eni_dev->serv_read = eni_in(MID_SERV_WRITE);
917 eni_out(0,MID_DMA_WR_RX);
918 return 0;
919}
920
921
922
923
924
925enum enq_res { enq_ok,enq_next,enq_jam };
926
927
928static inline void put_dma(int chan,u32 *dma,int *j,dma_addr_t paddr,
929 u32 size)
930{
931 u32 init,words;
932
933 DPRINTK("put_dma: 0x%lx+0x%x\n",(unsigned long) paddr,size);
934 EVENT("put_dma: 0x%lx+0x%lx\n",(unsigned long) paddr,size);
935#if 0
936 if (paddr & 3)
937 printk(KERN_ERR "put_dma: unaligned addr (0x%lx)\n",paddr);
938 if (size & 3)
939 printk(KERN_ERR "put_dma: unaligned size (0x%lx)\n",size);
940#endif
941 if (paddr & 3) {
942 init = 4-(paddr & 3);
943 if (init > size || size < 7) init = size;
944 DPRINTK("put_dma: %lx DMA: %d/%d bytes\n",
945 (unsigned long) paddr,init,size);
946 dma[(*j)++] = MID_DT_BYTE | (init << MID_DMA_COUNT_SHIFT) |
947 (chan << MID_DMA_CHAN_SHIFT);
948 dma[(*j)++] = paddr;
949 paddr += init;
950 size -= init;
951 }
952 words = size >> 2;
953 size &= 3;
954 if (words && (paddr & 31)) {
955 init = 8-((paddr & 31) >> 2);
956 if (init > words) init = words;
957 DPRINTK("put_dma: %lx DMA: %d/%d words\n",
958 (unsigned long) paddr,init,words);
959 dma[(*j)++] = MID_DT_WORD | (init << MID_DMA_COUNT_SHIFT) |
960 (chan << MID_DMA_CHAN_SHIFT);
961 dma[(*j)++] = paddr;
962 paddr += init << 2;
963 words -= init;
964 }
965#ifdef CONFIG_ATM_ENI_BURST_TX_16W
966 if (words & ~15) {
967 DPRINTK("put_dma: %lx DMA: %d*16/%d words\n",
968 (unsigned long) paddr,words >> 4,words);
969 dma[(*j)++] = MID_DT_16W | ((words >> 4) << MID_DMA_COUNT_SHIFT)
970 | (chan << MID_DMA_CHAN_SHIFT);
971 dma[(*j)++] = paddr;
972 paddr += (words & ~15) << 2;
973 words &= 15;
974 }
975#endif
976#ifdef CONFIG_ATM_ENI_BURST_TX_8W
977 if (words & ~7) {
978 DPRINTK("put_dma: %lx DMA: %d*8/%d words\n",
979 (unsigned long) paddr,words >> 3,words);
980 dma[(*j)++] = MID_DT_8W | ((words >> 3) << MID_DMA_COUNT_SHIFT)
981 | (chan << MID_DMA_CHAN_SHIFT);
982 dma[(*j)++] = paddr;
983 paddr += (words & ~7) << 2;
984 words &= 7;
985 }
986#endif
987#ifdef CONFIG_ATM_ENI_BURST_TX_4W
988 if (words & ~3) {
989 DPRINTK("put_dma: %lx DMA: %d*4/%d words\n",
990 (unsigned long) paddr,words >> 2,words);
991 dma[(*j)++] = MID_DT_4W | ((words >> 2) << MID_DMA_COUNT_SHIFT)
992 | (chan << MID_DMA_CHAN_SHIFT);
993 dma[(*j)++] = paddr;
994 paddr += (words & ~3) << 2;
995 words &= 3;
996 }
997#endif
998#ifdef CONFIG_ATM_ENI_BURST_TX_2W
999 if (words & ~1) {
1000 DPRINTK("put_dma: %lx DMA: %d*2/%d words\n",
1001 (unsigned long) paddr,words >> 1,words);
1002 dma[(*j)++] = MID_DT_2W | ((words >> 1) << MID_DMA_COUNT_SHIFT)
1003 | (chan << MID_DMA_CHAN_SHIFT);
1004 dma[(*j)++] = paddr;
1005 paddr += (words & ~1) << 2;
1006 words &= 1;
1007 }
1008#endif
1009 if (words) {
1010 DPRINTK("put_dma: %lx DMA: %d words\n",(unsigned long) paddr,
1011 words);
1012 dma[(*j)++] = MID_DT_WORD | (words << MID_DMA_COUNT_SHIFT) |
1013 (chan << MID_DMA_CHAN_SHIFT);
1014 dma[(*j)++] = paddr;
1015 paddr += words << 2;
1016 }
1017 if (size) {
1018 DPRINTK("put_dma: %lx DMA: %d bytes\n",(unsigned long) paddr,
1019 size);
1020 dma[(*j)++] = MID_DT_BYTE | (size << MID_DMA_COUNT_SHIFT) |
1021 (chan << MID_DMA_CHAN_SHIFT);
1022 dma[(*j)++] = paddr;
1023 }
1024}
1025
1026
1027static enum enq_res do_tx(struct sk_buff *skb)
1028{
1029 struct atm_vcc *vcc;
1030 struct eni_dev *eni_dev;
1031 struct eni_vcc *eni_vcc;
1032 struct eni_tx *tx;
1033 dma_addr_t paddr;
1034 u32 dma_rd,dma_wr;
1035 u32 size;
1036 int aal5,dma_size,i,j;
1037 unsigned char skb_data3;
1038
1039 DPRINTK(">do_tx\n");
1040 NULLCHECK(skb);
1041 EVENT("do_tx: skb=0x%lx, %ld bytes\n",(unsigned long) skb,skb->len);
1042 vcc = ATM_SKB(skb)->vcc;
1043 NULLCHECK(vcc);
1044 eni_dev = ENI_DEV(vcc->dev);
1045 NULLCHECK(eni_dev);
1046 eni_vcc = ENI_VCC(vcc);
1047 tx = eni_vcc->tx;
1048 NULLCHECK(tx);
1049#if 0
1050 {
1051 unsigned int hack = *((char *) skb->data)-'0';
1052
1053 if (hack < 8) {
1054 skb->data += hack;
1055 skb->len -= hack;
1056 }
1057 }
1058#endif
1059#if 0
1060 if ((unsigned long) skb->data & 3)
1061 printk(KERN_ERR DEV_LABEL "(itf %d): VCI %d has mis-aligned "
1062 "TX data\n",vcc->dev->number,vcc->vci);
1063#endif
1064
1065
1066
1067
1068
1069
1070 aal5 = vcc->qos.aal == ATM_AAL5;
1071
1072 if (!aal5)
1073 size = (ATM_CELL_PAYLOAD >> 2)+TX_DESCR_SIZE;
1074
1075
1076 else {
1077 size = skb->len+4*AAL5_TRAILER+ATM_CELL_PAYLOAD-1;
1078
1079 size = ((size-(size % ATM_CELL_PAYLOAD)) >> 2)+TX_DESCR_SIZE;
1080
1081 }
1082
1083
1084
1085
1086
1087 if (!NEPMOK(tx->tx_pos,size+TX_GAP,
1088 eni_in(MID_TX_RDPTR(tx->index)),tx->words)) {
1089 DPRINTK(DEV_LABEL "(itf %d): TX full (size %d)\n",
1090 vcc->dev->number,size);
1091 return enq_next;
1092 }
1093
1094 dma_wr = eni_in(MID_DMA_WR_TX);
1095 dma_rd = eni_in(MID_DMA_RD_TX);
1096 dma_size = 3;
1097
1098DPRINTK("iovcnt = %d\n",skb_shinfo(skb)->nr_frags);
1099 if (!skb_shinfo(skb)->nr_frags) dma_size += 5;
1100 else dma_size += 5*(skb_shinfo(skb)->nr_frags+1);
1101 if (dma_size > TX_DMA_BUF) {
1102 printk(KERN_CRIT DEV_LABEL "(itf %d): needs %d DMA entries "
1103 "(got only %d)\n",vcc->dev->number,dma_size,TX_DMA_BUF);
1104 }
1105 DPRINTK("dma_wr is %d, tx_pos is %ld\n",dma_wr,tx->tx_pos);
1106 if (dma_wr != dma_rd && ((dma_rd+NR_DMA_TX-dma_wr) & (NR_DMA_TX-1)) <
1107 dma_size) {
1108 printk(KERN_WARNING DEV_LABEL "(itf %d): TX DMA full\n",
1109 vcc->dev->number);
1110 return enq_jam;
1111 }
1112 skb_data3 = skb->data[3];
1113 paddr = dma_map_single(&eni_dev->pci_dev->dev,skb->data,skb->len,
1114 DMA_TO_DEVICE);
1115 ENI_PRV_PADDR(skb) = paddr;
1116
1117 j = 0;
1118 eni_dev->dma[j++] = (((tx->tx_pos+TX_DESCR_SIZE) & (tx->words-1)) <<
1119 MID_DMA_COUNT_SHIFT) | (tx->index << MID_DMA_CHAN_SHIFT) |
1120 MID_DT_JK;
1121 j++;
1122 if (!skb_shinfo(skb)->nr_frags)
1123 if (aal5) put_dma(tx->index,eni_dev->dma,&j,paddr,skb->len);
1124 else put_dma(tx->index,eni_dev->dma,&j,paddr+4,skb->len-4);
1125 else {
1126DPRINTK("doing direct send\n");
1127 for (i = -1; i < skb_shinfo(skb)->nr_frags; i++)
1128 if (i == -1)
1129 put_dma(tx->index,eni_dev->dma,&j,(unsigned long)
1130 skb->data,
1131 skb_headlen(skb));
1132 else
1133 put_dma(tx->index,eni_dev->dma,&j,(unsigned long)
1134 skb_frag_page(&skb_shinfo(skb)->frags[i]) +
1135 skb_frag_off(&skb_shinfo(skb)->frags[i]),
1136 skb_frag_size(&skb_shinfo(skb)->frags[i]));
1137 }
1138 if (skb->len & 3) {
1139 put_dma(tx->index, eni_dev->dma, &j, eni_dev->zero.dma,
1140 4 - (skb->len & 3));
1141 }
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_data3 & 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);
1175 queued++;
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);
1196 requeued++;
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 dma_unmap_single(&eni_dev->pci_dev->dev,ENI_PRV_PADDR(skb),skb->len,
1228 DMA_TO_DEVICE);
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);
1233 dma_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);
1556 tx_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 char * const media_name[] = {
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 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 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 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(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 -ENOMEM;
1729 }
1730 eni_dev->ioaddr = base;
1731 eni_dev->base_diff = real_base - (unsigned long) base;
1732
1733 if (!eni_dev->asic) {
1734 eprom = (base+EPROM_SIZE-sizeof(struct midway_eprom));
1735 if (readl(&eprom->magic) != ENI155_MAGIC) {
1736 printk("\n");
1737 printk(KERN_ERR DEV_LABEL
1738 "(itf %d): bad magic - expected 0x%x, got 0x%x\n",
1739 dev->number, ENI155_MAGIC,
1740 (unsigned)readl(&eprom->magic));
1741 error = -EINVAL;
1742 goto unmap;
1743 }
1744 }
1745 eni_dev->phy = base+PHY_BASE;
1746 eni_dev->reg = base+REG_BASE;
1747 eni_dev->ram = base+RAM_BASE;
1748 last = MAP_MAX_SIZE-RAM_BASE;
1749 for (i = last-RAM_INCREMENT; i >= 0; i -= RAM_INCREMENT) {
1750 writel(0x55555555,eni_dev->ram+i);
1751 if (readl(eni_dev->ram+i) != 0x55555555) last = i;
1752 else {
1753 writel(0xAAAAAAAA,eni_dev->ram+i);
1754 if (readl(eni_dev->ram+i) != 0xAAAAAAAA) last = i;
1755 else writel(i,eni_dev->ram+i);
1756 }
1757 }
1758 for (i = 0; i < last; i += RAM_INCREMENT)
1759 if (readl(eni_dev->ram+i) != i) break;
1760 eni_dev->mem = i;
1761 memset_io(eni_dev->ram,0,eni_dev->mem);
1762
1763 printk("mem=%dkB (",eni_dev->mem >> 10);
1764
1765 if (!(eni_in(MID_RES_ID_MCON) & 0x200) != !eni_dev->asic) {
1766 printk(")\n");
1767 printk(KERN_ERR DEV_LABEL "(itf %d): ERROR - wrong id 0x%x\n",
1768 dev->number,(unsigned) eni_in(MID_RES_ID_MCON));
1769 error = -EINVAL;
1770 goto unmap;
1771 }
1772 error = eni_dev->asic ? get_esi_asic(dev) : get_esi_fpga(dev,base);
1773 if (error)
1774 goto unmap;
1775 for (i = 0; i < ESI_LEN; i++)
1776 printk("%s%02X",i ? "-" : "",dev->esi[i]);
1777 printk(")\n");
1778 printk(KERN_NOTICE DEV_LABEL "(itf %d): %s,%s\n",dev->number,
1779 eni_in(MID_RES_ID_MCON) & 0x200 ? "ASIC" : "FPGA",
1780 media_name[eni_in(MID_RES_ID_MCON) & DAUGHTER_ID]);
1781
1782 error = suni_init(dev);
1783 if (error)
1784 goto unmap;
1785out:
1786 return error;
1787unmap:
1788 iounmap(base);
1789 goto out;
1790}
1791
1792static void eni_do_release(struct atm_dev *dev)
1793{
1794 struct eni_dev *ed = ENI_DEV(dev);
1795
1796 dev->phy->stop(dev);
1797 dev->phy = NULL;
1798 iounmap(ed->ioaddr);
1799}
1800
1801static int eni_start(struct atm_dev *dev)
1802{
1803 struct eni_dev *eni_dev;
1804
1805 void __iomem *buf;
1806 unsigned long buffer_mem;
1807 int error;
1808
1809 DPRINTK(">eni_start\n");
1810 eni_dev = ENI_DEV(dev);
1811 if (request_irq(eni_dev->irq,&eni_int,IRQF_SHARED,DEV_LABEL,dev)) {
1812 printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
1813 dev->number,eni_dev->irq);
1814 error = -EAGAIN;
1815 goto out;
1816 }
1817 pci_set_master(eni_dev->pci_dev);
1818 if ((error = pci_write_config_word(eni_dev->pci_dev,PCI_COMMAND,
1819 PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
1820 (eni_dev->asic ? PCI_COMMAND_PARITY | PCI_COMMAND_SERR : 0)))) {
1821 printk(KERN_ERR DEV_LABEL "(itf %d): can't enable memory+"
1822 "master (0x%02x)\n",dev->number,error);
1823 goto free_irq;
1824 }
1825 if ((error = pci_write_config_byte(eni_dev->pci_dev,PCI_TONGA_CTRL,
1826 END_SWAP_DMA))) {
1827 printk(KERN_ERR DEV_LABEL "(itf %d): can't set endian swap "
1828 "(0x%02x)\n",dev->number,error);
1829 goto free_irq;
1830 }
1831
1832 eni_dev->vci = eni_dev->ram;
1833 eni_dev->rx_dma = eni_dev->ram+NR_VCI*16;
1834 eni_dev->tx_dma = eni_dev->rx_dma+NR_DMA_RX*8;
1835 eni_dev->service = eni_dev->tx_dma+NR_DMA_TX*8;
1836 buf = eni_dev->service+NR_SERVICE*4;
1837 DPRINTK("vci 0x%lx,rx 0x%lx, tx 0x%lx,srv 0x%lx,buf 0x%lx\n",
1838 eni_dev->vci,eni_dev->rx_dma,eni_dev->tx_dma,
1839 eni_dev->service,buf);
1840 spin_lock_init(&eni_dev->lock);
1841 tasklet_init(&eni_dev->task,eni_tasklet,(unsigned long) dev);
1842 eni_dev->events = 0;
1843
1844 buffer_mem = eni_dev->mem - (buf - eni_dev->ram);
1845 eni_dev->free_list_size = buffer_mem/MID_MIN_BUF_SIZE/2;
1846 eni_dev->free_list = kmalloc_array(eni_dev->free_list_size + 1,
1847 sizeof(*eni_dev->free_list),
1848 GFP_KERNEL);
1849 if (!eni_dev->free_list) {
1850 printk(KERN_ERR DEV_LABEL "(itf %d): couldn't get free page\n",
1851 dev->number);
1852 error = -ENOMEM;
1853 goto free_irq;
1854 }
1855 eni_dev->free_len = 0;
1856 eni_put_free(eni_dev,buf,buffer_mem);
1857 memset_io(eni_dev->vci,0,16*NR_VCI);
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867 eni_out(0xffffffff,MID_IE);
1868 error = start_tx(dev);
1869 if (error) goto free_list;
1870 error = start_rx(dev);
1871 if (error) goto free_list;
1872 error = dev->phy->start(dev);
1873 if (error) goto free_list;
1874 eni_out(eni_in(MID_MC_S) | (1 << MID_INT_SEL_SHIFT) |
1875 MID_TX_LOCK_MODE | MID_DMA_ENABLE | MID_TX_ENABLE | MID_RX_ENABLE,
1876 MID_MC_S);
1877
1878 (void) eni_in(MID_ISA);
1879 return 0;
1880
1881free_list:
1882 kfree(eni_dev->free_list);
1883
1884free_irq:
1885 free_irq(eni_dev->irq, dev);
1886
1887out:
1888 return error;
1889}
1890
1891
1892static void eni_close(struct atm_vcc *vcc)
1893{
1894 DPRINTK(">eni_close\n");
1895 if (!ENI_VCC(vcc)) return;
1896 clear_bit(ATM_VF_READY,&vcc->flags);
1897 close_rx(vcc);
1898 close_tx(vcc);
1899 DPRINTK("eni_close: done waiting\n");
1900
1901 kfree(ENI_VCC(vcc));
1902 vcc->dev_data = NULL;
1903 clear_bit(ATM_VF_ADDR,&vcc->flags);
1904
1905}
1906
1907
1908static int eni_open(struct atm_vcc *vcc)
1909{
1910 struct eni_vcc *eni_vcc;
1911 int error;
1912 short vpi = vcc->vpi;
1913 int vci = vcc->vci;
1914
1915 DPRINTK(">eni_open\n");
1916 EVENT("eni_open\n",0,0);
1917 if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1918 vcc->dev_data = NULL;
1919 if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1920 set_bit(ATM_VF_ADDR,&vcc->flags);
1921 if (vcc->qos.aal != ATM_AAL0 && vcc->qos.aal != ATM_AAL5)
1922 return -EINVAL;
1923 DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1924 vcc->vci);
1925 if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) {
1926 eni_vcc = kmalloc(sizeof(struct eni_vcc),GFP_KERNEL);
1927 if (!eni_vcc) return -ENOMEM;
1928 vcc->dev_data = eni_vcc;
1929 eni_vcc->tx = NULL;
1930 if ((error = open_rx_first(vcc))) {
1931 eni_close(vcc);
1932 return error;
1933 }
1934 if ((error = open_tx_first(vcc))) {
1935 eni_close(vcc);
1936 return error;
1937 }
1938 }
1939 if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1940 if ((error = open_rx_second(vcc))) {
1941 eni_close(vcc);
1942 return error;
1943 }
1944 if ((error = open_tx_second(vcc))) {
1945 eni_close(vcc);
1946 return error;
1947 }
1948 set_bit(ATM_VF_READY,&vcc->flags);
1949
1950 return 0;
1951}
1952
1953
1954static int eni_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flgs)
1955{
1956 struct eni_dev *eni_dev = ENI_DEV(vcc->dev);
1957 struct eni_tx *tx = ENI_VCC(vcc)->tx;
1958 struct sk_buff *skb;
1959 int error,rate,rsv,shp;
1960
1961 if (qos->txtp.traffic_class == ATM_NONE) return 0;
1962 if (tx == eni_dev->ubr) return -EBADFD;
1963 rate = atm_pcr_goal(&qos->txtp);
1964 if (rate < 0) rate = -rate;
1965 rsv = shp = 0;
1966 if ((flgs & ATM_MF_DEC_RSV) && rate && rate < tx->reserved) rsv = 1;
1967 if ((flgs & ATM_MF_INC_RSV) && (!rate || rate > tx->reserved)) rsv = 1;
1968 if ((flgs & ATM_MF_DEC_SHP) && rate && rate < tx->shaping) shp = 1;
1969 if ((flgs & ATM_MF_INC_SHP) && (!rate || rate > tx->shaping)) shp = 1;
1970 if (!rsv && !shp) return 0;
1971 error = reserve_or_set_tx(vcc,&qos->txtp,rsv,shp);
1972 if (error) return error;
1973 if (shp && !(flgs & ATM_MF_IMMED)) return 0;
1974
1975
1976
1977
1978 tasklet_disable(&eni_dev->task);
1979 skb_queue_walk(&eni_dev->tx_queue, skb) {
1980 void __iomem *dsc;
1981
1982 if (ATM_SKB(skb)->vcc != vcc) continue;
1983 dsc = tx->send+ENI_PRV_POS(skb)*4;
1984 writel((readl(dsc) & ~(MID_SEG_RATE | MID_SEG_PR)) |
1985 (tx->prescaler << MID_SEG_PR_SHIFT) |
1986 (tx->resolution << MID_SEG_RATE_SHIFT), dsc);
1987 }
1988 tasklet_enable(&eni_dev->task);
1989 return 0;
1990}
1991
1992
1993static int eni_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
1994{
1995 struct eni_dev *eni_dev = ENI_DEV(dev);
1996
1997 if (cmd == ENI_MEMDUMP) {
1998 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1999 printk(KERN_WARNING "Please use /proc/atm/" DEV_LABEL ":%d "
2000 "instead of obsolete ioctl ENI_MEMDUMP\n",dev->number);
2001 dump(dev);
2002 return 0;
2003 }
2004 if (cmd == ENI_SETMULT) {
2005 struct eni_multipliers mult;
2006
2007 if (!capable(CAP_NET_ADMIN)) return -EPERM;
2008 if (copy_from_user(&mult, arg,
2009 sizeof(struct eni_multipliers)))
2010 return -EFAULT;
2011 if ((mult.tx && mult.tx <= 100) || (mult.rx &&mult.rx <= 100) ||
2012 mult.tx > 65536 || mult.rx > 65536)
2013 return -EINVAL;
2014 if (mult.tx) eni_dev->tx_mult = mult.tx;
2015 if (mult.rx) eni_dev->rx_mult = mult.rx;
2016 return 0;
2017 }
2018 if (cmd == ATM_SETCIRANGE) {
2019 struct atm_cirange ci;
2020
2021 if (copy_from_user(&ci, arg,sizeof(struct atm_cirange)))
2022 return -EFAULT;
2023 if ((ci.vpi_bits == 0 || ci.vpi_bits == ATM_CI_MAX) &&
2024 (ci.vci_bits == NR_VCI_LD || ci.vpi_bits == ATM_CI_MAX))
2025 return 0;
2026 return -EINVAL;
2027 }
2028 if (!dev->phy->ioctl) return -ENOIOCTLCMD;
2029 return dev->phy->ioctl(dev,cmd,arg);
2030}
2031
2032static int eni_send(struct atm_vcc *vcc,struct sk_buff *skb)
2033{
2034 enum enq_res res;
2035
2036 DPRINTK(">eni_send\n");
2037 if (!ENI_VCC(vcc)->tx) {
2038 if (vcc->pop) vcc->pop(vcc,skb);
2039 else dev_kfree_skb(skb);
2040 return -EINVAL;
2041 }
2042 if (!skb) {
2043 printk(KERN_CRIT "!skb in eni_send ?\n");
2044 if (vcc->pop) vcc->pop(vcc,skb);
2045 return -EINVAL;
2046 }
2047 if (vcc->qos.aal == ATM_AAL0) {
2048 if (skb->len != ATM_CELL_SIZE-1) {
2049 if (vcc->pop) vcc->pop(vcc,skb);
2050 else dev_kfree_skb(skb);
2051 return -EINVAL;
2052 }
2053 *(u32 *) skb->data = htonl(*(u32 *) skb->data);
2054 }
2055 submitted++;
2056 ATM_SKB(skb)->vcc = vcc;
2057 tasklet_disable(&ENI_DEV(vcc->dev)->task);
2058 res = do_tx(skb);
2059 tasklet_enable(&ENI_DEV(vcc->dev)->task);
2060 if (res == enq_ok) return 0;
2061 skb_queue_tail(&ENI_VCC(vcc)->tx->backlog,skb);
2062 backlogged++;
2063 tasklet_schedule(&ENI_DEV(vcc->dev)->task);
2064 return 0;
2065}
2066
2067static void eni_phy_put(struct atm_dev *dev,unsigned char value,
2068 unsigned long addr)
2069{
2070 writel(value,ENI_DEV(dev)->phy+addr*4);
2071}
2072
2073
2074
2075static unsigned char eni_phy_get(struct atm_dev *dev,unsigned long addr)
2076{
2077 return readl(ENI_DEV(dev)->phy+addr*4);
2078}
2079
2080
2081static int eni_proc_read(struct atm_dev *dev,loff_t *pos,char *page)
2082{
2083 struct sock *s;
2084 static const char *signal[] = { "LOST","unknown","okay" };
2085 struct eni_dev *eni_dev = ENI_DEV(dev);
2086 struct atm_vcc *vcc;
2087 int left,i;
2088
2089 left = *pos;
2090 if (!left)
2091 return sprintf(page,DEV_LABEL "(itf %d) signal %s, %dkB, "
2092 "%d cps remaining\n",dev->number,signal[(int) dev->signal],
2093 eni_dev->mem >> 10,eni_dev->tx_bw);
2094 if (!--left)
2095 return sprintf(page,"%4sBursts: TX"
2096#if !defined(CONFIG_ATM_ENI_BURST_TX_16W) && \
2097 !defined(CONFIG_ATM_ENI_BURST_TX_8W) && \
2098 !defined(CONFIG_ATM_ENI_BURST_TX_4W) && \
2099 !defined(CONFIG_ATM_ENI_BURST_TX_2W)
2100 " none"
2101#endif
2102#ifdef CONFIG_ATM_ENI_BURST_TX_16W
2103 " 16W"
2104#endif
2105#ifdef CONFIG_ATM_ENI_BURST_TX_8W
2106 " 8W"
2107#endif
2108#ifdef CONFIG_ATM_ENI_BURST_TX_4W
2109 " 4W"
2110#endif
2111#ifdef CONFIG_ATM_ENI_BURST_TX_2W
2112 " 2W"
2113#endif
2114 ", RX"
2115#if !defined(CONFIG_ATM_ENI_BURST_RX_16W) && \
2116 !defined(CONFIG_ATM_ENI_BURST_RX_8W) && \
2117 !defined(CONFIG_ATM_ENI_BURST_RX_4W) && \
2118 !defined(CONFIG_ATM_ENI_BURST_RX_2W)
2119 " none"
2120#endif
2121#ifdef CONFIG_ATM_ENI_BURST_RX_16W
2122 " 16W"
2123#endif
2124#ifdef CONFIG_ATM_ENI_BURST_RX_8W
2125 " 8W"
2126#endif
2127#ifdef CONFIG_ATM_ENI_BURST_RX_4W
2128 " 4W"
2129#endif
2130#ifdef CONFIG_ATM_ENI_BURST_RX_2W
2131 " 2W"
2132#endif
2133#ifndef CONFIG_ATM_ENI_TUNE_BURST
2134 " (default)"
2135#endif
2136 "\n","");
2137 if (!--left)
2138 return sprintf(page,"%4sBuffer multipliers: tx %d%%, rx %d%%\n",
2139 "",eni_dev->tx_mult,eni_dev->rx_mult);
2140 for (i = 0; i < NR_CHAN; i++) {
2141 struct eni_tx *tx = eni_dev->tx+i;
2142
2143 if (!tx->send) continue;
2144 if (!--left) {
2145 return sprintf(page, "tx[%d]: 0x%lx-0x%lx "
2146 "(%6ld bytes), rsv %d cps, shp %d cps%s\n",i,
2147 (unsigned long) (tx->send - eni_dev->ram),
2148 tx->send-eni_dev->ram+tx->words*4-1,tx->words*4,
2149 tx->reserved,tx->shaping,
2150 tx == eni_dev->ubr ? " (UBR)" : "");
2151 }
2152 if (--left) continue;
2153 return sprintf(page,"%10sbacklog %u packets\n","",
2154 skb_queue_len(&tx->backlog));
2155 }
2156 read_lock(&vcc_sklist_lock);
2157 for(i = 0; i < VCC_HTABLE_SIZE; ++i) {
2158 struct hlist_head *head = &vcc_hash[i];
2159
2160 sk_for_each(s, head) {
2161 struct eni_vcc *eni_vcc;
2162 int length;
2163
2164 vcc = atm_sk(s);
2165 if (vcc->dev != dev)
2166 continue;
2167 eni_vcc = ENI_VCC(vcc);
2168 if (--left) continue;
2169 length = sprintf(page,"vcc %4d: ",vcc->vci);
2170 if (eni_vcc->rx) {
2171 length += sprintf(page+length, "0x%lx-0x%lx "
2172 "(%6ld bytes)",
2173 (unsigned long) (eni_vcc->recv - eni_dev->ram),
2174 eni_vcc->recv-eni_dev->ram+eni_vcc->words*4-1,
2175 eni_vcc->words*4);
2176 if (eni_vcc->tx) length += sprintf(page+length,", ");
2177 }
2178 if (eni_vcc->tx)
2179 length += sprintf(page+length,"tx[%d], txing %d bytes",
2180 eni_vcc->tx->index,eni_vcc->txing);
2181 page[length] = '\n';
2182 read_unlock(&vcc_sklist_lock);
2183 return length+1;
2184 }
2185 }
2186 read_unlock(&vcc_sklist_lock);
2187 for (i = 0; i < eni_dev->free_len; i++) {
2188 struct eni_free *fe = eni_dev->free_list+i;
2189 unsigned long offset;
2190
2191 if (--left) continue;
2192 offset = (unsigned long) eni_dev->ram+eni_dev->base_diff;
2193 return sprintf(page,"free %p-%p (%6d bytes)\n",
2194 fe->start-offset,fe->start-offset+(1 << fe->order)-1,
2195 1 << fe->order);
2196 }
2197 return 0;
2198}
2199
2200
2201static const struct atmdev_ops ops = {
2202 .open = eni_open,
2203 .close = eni_close,
2204 .ioctl = eni_ioctl,
2205 .send = eni_send,
2206 .phy_put = eni_phy_put,
2207 .phy_get = eni_phy_get,
2208 .change_qos = eni_change_qos,
2209 .proc_read = eni_proc_read
2210};
2211
2212
2213static int eni_init_one(struct pci_dev *pci_dev,
2214 const struct pci_device_id *ent)
2215{
2216 struct atm_dev *dev;
2217 struct eni_dev *eni_dev;
2218 struct eni_zero *zero;
2219 int rc;
2220
2221 rc = pci_enable_device(pci_dev);
2222 if (rc < 0)
2223 goto out;
2224
2225 rc = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32));
2226 if (rc < 0)
2227 goto err_disable;
2228
2229 rc = -ENOMEM;
2230 eni_dev = kmalloc(sizeof(struct eni_dev), GFP_KERNEL);
2231 if (!eni_dev)
2232 goto err_disable;
2233
2234 zero = &eni_dev->zero;
2235 zero->addr = dma_alloc_coherent(&pci_dev->dev,
2236 ENI_ZEROES_SIZE, &zero->dma, GFP_KERNEL);
2237 if (!zero->addr)
2238 goto err_kfree;
2239
2240 dev = atm_dev_register(DEV_LABEL, &pci_dev->dev, &ops, -1, NULL);
2241 if (!dev)
2242 goto err_free_consistent;
2243
2244 dev->dev_data = eni_dev;
2245 pci_set_drvdata(pci_dev, dev);
2246 eni_dev->pci_dev = pci_dev;
2247 eni_dev->asic = ent->driver_data;
2248
2249 rc = eni_do_init(dev);
2250 if (rc < 0)
2251 goto err_unregister;
2252
2253 rc = eni_start(dev);
2254 if (rc < 0)
2255 goto err_eni_release;
2256
2257 eni_dev->more = eni_boards;
2258 eni_boards = dev;
2259out:
2260 return rc;
2261
2262err_eni_release:
2263 eni_do_release(dev);
2264err_unregister:
2265 atm_dev_deregister(dev);
2266err_free_consistent:
2267 dma_free_coherent(&pci_dev->dev, ENI_ZEROES_SIZE, zero->addr, zero->dma);
2268err_kfree:
2269 kfree(eni_dev);
2270err_disable:
2271 pci_disable_device(pci_dev);
2272 goto out;
2273}
2274
2275
2276static const struct pci_device_id eni_pci_tbl[] = {
2277 { PCI_VDEVICE(EF, PCI_DEVICE_ID_EF_ATM_FPGA), 0 },
2278 { PCI_VDEVICE(EF, PCI_DEVICE_ID_EF_ATM_ASIC), 1 },
2279 { 0, }
2280};
2281MODULE_DEVICE_TABLE(pci,eni_pci_tbl);
2282
2283
2284static void eni_remove_one(struct pci_dev *pdev)
2285{
2286 struct atm_dev *dev = pci_get_drvdata(pdev);
2287 struct eni_dev *ed = ENI_DEV(dev);
2288 struct eni_zero *zero = &ed->zero;
2289
2290 eni_do_release(dev);
2291 atm_dev_deregister(dev);
2292 dma_free_coherent(&pdev->dev, ENI_ZEROES_SIZE, zero->addr, zero->dma);
2293 kfree(ed);
2294 pci_disable_device(pdev);
2295}
2296
2297
2298static struct pci_driver eni_driver = {
2299 .name = DEV_LABEL,
2300 .id_table = eni_pci_tbl,
2301 .probe = eni_init_one,
2302 .remove = eni_remove_one,
2303};
2304
2305
2306static int __init eni_init(void)
2307{
2308 struct sk_buff *skb;
2309
2310 BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct eni_skb_prv));
2311 return pci_register_driver(&eni_driver);
2312}
2313
2314
2315module_init(eni_init);
2316
2317
2318MODULE_LICENSE("GPL");
2319
