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