Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / drivers / atm / fore200e.c
1 /*
2   A FORE Systems 200E-series driver for ATM on Linux.
3   Christophe Lizzi (lizzi@cnam.fr), October 1999-March 2003.
4
5   Based on the PCA-200E driver from Uwe Dannowski (Uwe.Dannowski@inf.tu-dresden.de).
6
7   This driver simultaneously supports PCA-200E and SBA-200E adapters
8   on i386, alpha (untested), powerpc, sparc and sparc64 architectures.
9
10   This program is free software; you can redistribute it and/or modify
11   it under the terms of the GNU General Public License as published by
12   the Free Software Foundation; either version 2 of the License, or
13   (at your option) any later version.
14
15   This program is distributed in the hope that it will be useful,
16   but WITHOUT ANY WARRANTY; without even the implied warranty of
17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18   GNU General Public License for more details.
19
20   You should have received a copy of the GNU General Public License
21   along with this program; if not, write to the Free Software
22   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 */
24
25
26 #include <linux/kernel.h>
27 #include <linux/slab.h>
28 #include <linux/init.h>
29 #include <linux/capability.h>
30 #include <linux/interrupt.h>
31 #include <linux/bitops.h>
32 #include <linux/pci.h>
33 #include <linux/module.h>
34 #include <linux/atmdev.h>
35 #include <linux/sonet.h>
36 #include <linux/atm_suni.h>
37 #include <linux/dma-mapping.h>
38 #include <linux/delay.h>
39 #include <linux/firmware.h>
40 #include <asm/io.h>
41 #include <asm/string.h>
42 #include <asm/page.h>
43 #include <asm/irq.h>
44 #include <asm/dma.h>
45 #include <asm/byteorder.h>
46 #include <asm/uaccess.h>
47 #include <asm/atomic.h>
48
49 #ifdef CONFIG_SBUS
50 #include <asm/idprom.h>
51 #include <asm/sbus.h>
52 #include <asm/openprom.h>
53 #include <asm/oplib.h>
54 #include <asm/pgtable.h>
55 #endif
56
57 #if defined(CONFIG_ATM_FORE200E_USE_TASKLET) /* defer interrupt work to a tasklet */
58 #define FORE200E_USE_TASKLET
59 #endif
60
61 #if 0 /* enable the debugging code of the buffer supply queues */
62 #define FORE200E_BSQ_DEBUG
63 #endif
64
65 #if 1 /* ensure correct handling of 52-byte AAL0 SDUs expected by atmdump-like apps */
66 #define FORE200E_52BYTE_AAL0_SDU
67 #endif
68
69 #include "fore200e.h"
70 #include "suni.h"
71
72 #define FORE200E_VERSION "0.3e"
73
74 #define FORE200E         "fore200e: "
75
76 #if 0 /* override .config */
77 #define CONFIG_ATM_FORE200E_DEBUG 1
78 #endif
79 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
80 #define DPRINTK(level, format, args...)  do { if (CONFIG_ATM_FORE200E_DEBUG >= (level)) \
81                                                   printk(FORE200E format, ##args); } while (0)
82 #else
83 #define DPRINTK(level, format, args...)  do {} while (0)
84 #endif
85
86
87 #define FORE200E_ALIGN(addr, alignment) \
88         ((((unsigned long)(addr) + (alignment - 1)) & ~(alignment - 1)) - (unsigned long)(addr))
89
90 #define FORE200E_DMA_INDEX(dma_addr, type, index)  ((dma_addr) + (index) * sizeof(type))
91
92 #define FORE200E_INDEX(virt_addr, type, index)     (&((type *)(virt_addr))[ index ])
93
94 #define FORE200E_NEXT_ENTRY(index, modulo)         (index = ++(index) % (modulo))
95
96 #if 1
97 #define ASSERT(expr)     if (!(expr)) { \
98                              printk(FORE200E "assertion failed! %s[%d]: %s\n", \
99                                     __func__, __LINE__, #expr); \
100                              panic(FORE200E "%s", __func__); \
101                          }
102 #else
103 #define ASSERT(expr)     do {} while (0)
104 #endif
105
106
107 static const struct atmdev_ops   fore200e_ops;
108 static const struct fore200e_bus fore200e_bus[];
109
110 static LIST_HEAD(fore200e_boards);
111
112
113 MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");
114 MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);
115 MODULE_SUPPORTED_DEVICE("PCA-200E, SBA-200E");
116
117
118 static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
119     { BUFFER_S1_NBR, BUFFER_L1_NBR },
120     { BUFFER_S2_NBR, BUFFER_L2_NBR }
121 };
122
123 static const int fore200e_rx_buf_size[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
124     { BUFFER_S1_SIZE, BUFFER_L1_SIZE },
125     { BUFFER_S2_SIZE, BUFFER_L2_SIZE }
126 };
127
128
129 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
130 static const char* fore200e_traffic_class[] = { "NONE", "UBR", "CBR", "VBR", "ABR", "ANY" };
131 #endif
132
133
134 #if 0 /* currently unused */
135 static int 
136 fore200e_fore2atm_aal(enum fore200e_aal aal)
137 {
138     switch(aal) {
139     case FORE200E_AAL0:  return ATM_AAL0;
140     case FORE200E_AAL34: return ATM_AAL34;
141     case FORE200E_AAL5:  return ATM_AAL5;
142     }
143
144     return -EINVAL;
145 }
146 #endif
147
148
149 static enum fore200e_aal
150 fore200e_atm2fore_aal(int aal)
151 {
152     switch(aal) {
153     case ATM_AAL0:  return FORE200E_AAL0;
154     case ATM_AAL34: return FORE200E_AAL34;
155     case ATM_AAL1:
156     case ATM_AAL2:
157     case ATM_AAL5:  return FORE200E_AAL5;
158     }
159
160     return -EINVAL;
161 }
162
163
164 static char*
165 fore200e_irq_itoa(int irq)
166 {
167     static char str[8];
168     sprintf(str, "%d", irq);
169     return str;
170 }
171
172
173 /* allocate and align a chunk of memory intended to hold the data behing exchanged
174    between the driver and the adapter (using streaming DVMA) */
175
176 static int
177 fore200e_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, int size, int alignment, int direction)
178 {
179     unsigned long offset = 0;
180
181     if (alignment <= sizeof(int))
182         alignment = 0;
183
184     chunk->alloc_size = size + alignment;
185     chunk->align_size = size;
186     chunk->direction  = direction;
187
188     chunk->alloc_addr = kzalloc(chunk->alloc_size, GFP_KERNEL | GFP_DMA);
189     if (chunk->alloc_addr == NULL)
190         return -ENOMEM;
191
192     if (alignment > 0)
193         offset = FORE200E_ALIGN(chunk->alloc_addr, alignment); 
194     
195     chunk->align_addr = chunk->alloc_addr + offset;
196
197     chunk->dma_addr = fore200e->bus->dma_map(fore200e, chunk->align_addr, chunk->align_size, direction);
198     
199     return 0;
200 }
201
202
203 /* free a chunk of memory */
204
205 static void
206 fore200e_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
207 {
208     fore200e->bus->dma_unmap(fore200e, chunk->dma_addr, chunk->dma_size, chunk->direction);
209
210     kfree(chunk->alloc_addr);
211 }
212
213
214 static void
215 fore200e_spin(int msecs)
216 {
217     unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
218     while (time_before(jiffies, timeout));
219 }
220
221
222 static int
223 fore200e_poll(struct fore200e* fore200e, volatile u32* addr, u32 val, int msecs)
224 {
225     unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
226     int           ok;
227
228     mb();
229     do {
230         if ((ok = (*addr == val)) || (*addr & STATUS_ERROR))
231             break;
232
233     } while (time_before(jiffies, timeout));
234
235 #if 1
236     if (!ok) {
237         printk(FORE200E "cmd polling failed, got status 0x%08x, expected 0x%08x\n",
238                *addr, val);
239     }
240 #endif
241
242     return ok;
243 }
244
245
246 static int
247 fore200e_io_poll(struct fore200e* fore200e, volatile u32 __iomem *addr, u32 val, int msecs)
248 {
249     unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
250     int           ok;
251
252     do {
253         if ((ok = (fore200e->bus->read(addr) == val)))
254             break;
255
256     } while (time_before(jiffies, timeout));
257
258 #if 1
259     if (!ok) {
260         printk(FORE200E "I/O polling failed, got status 0x%08x, expected 0x%08x\n",
261                fore200e->bus->read(addr), val);
262     }
263 #endif
264
265     return ok;
266 }
267
268
269 static void
270 fore200e_free_rx_buf(struct fore200e* fore200e)
271 {
272     int scheme, magn, nbr;
273     struct buffer* buffer;
274
275     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
276         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
277
278             if ((buffer = fore200e->host_bsq[ scheme ][ magn ].buffer) != NULL) {
279
280                 for (nbr = 0; nbr < fore200e_rx_buf_nbr[ scheme ][ magn ]; nbr++) {
281
282                     struct chunk* data = &buffer[ nbr ].data;
283
284                     if (data->alloc_addr != NULL)
285                         fore200e_chunk_free(fore200e, data);
286                 }
287             }
288         }
289     }
290 }
291
292
293 static void
294 fore200e_uninit_bs_queue(struct fore200e* fore200e)
295 {
296     int scheme, magn;
297     
298     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
299         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
300
301             struct chunk* status    = &fore200e->host_bsq[ scheme ][ magn ].status;
302             struct chunk* rbd_block = &fore200e->host_bsq[ scheme ][ magn ].rbd_block;
303             
304             if (status->alloc_addr)
305                 fore200e->bus->dma_chunk_free(fore200e, status);
306             
307             if (rbd_block->alloc_addr)
308                 fore200e->bus->dma_chunk_free(fore200e, rbd_block);
309         }
310     }
311 }
312
313
314 static int
315 fore200e_reset(struct fore200e* fore200e, int diag)
316 {
317     int ok;
318
319     fore200e->cp_monitor = fore200e->virt_base + FORE200E_CP_MONITOR_OFFSET;
320     
321     fore200e->bus->write(BSTAT_COLD_START, &fore200e->cp_monitor->bstat);
322
323     fore200e->bus->reset(fore200e);
324
325     if (diag) {
326         ok = fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_SELFTEST_OK, 1000);
327         if (ok == 0) {
328             
329             printk(FORE200E "device %s self-test failed\n", fore200e->name);
330             return -ENODEV;
331         }
332
333         printk(FORE200E "device %s self-test passed\n", fore200e->name);
334         
335         fore200e->state = FORE200E_STATE_RESET;
336     }
337
338     return 0;
339 }
340
341
342 static void
343 fore200e_shutdown(struct fore200e* fore200e)
344 {
345     printk(FORE200E "removing device %s at 0x%lx, IRQ %s\n",
346            fore200e->name, fore200e->phys_base, 
347            fore200e_irq_itoa(fore200e->irq));
348     
349     if (fore200e->state > FORE200E_STATE_RESET) {
350         /* first, reset the board to prevent further interrupts or data transfers */
351         fore200e_reset(fore200e, 0);
352     }
353     
354     /* then, release all allocated resources */
355     switch(fore200e->state) {
356
357     case FORE200E_STATE_COMPLETE:
358         kfree(fore200e->stats);
359
360     case FORE200E_STATE_IRQ:
361         free_irq(fore200e->irq, fore200e->atm_dev);
362
363     case FORE200E_STATE_ALLOC_BUF:
364         fore200e_free_rx_buf(fore200e);
365
366     case FORE200E_STATE_INIT_BSQ:
367         fore200e_uninit_bs_queue(fore200e);
368
369     case FORE200E_STATE_INIT_RXQ:
370         fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_rxq.status);
371         fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_rxq.rpd);
372
373     case FORE200E_STATE_INIT_TXQ:
374         fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_txq.status);
375         fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_txq.tpd);
376
377     case FORE200E_STATE_INIT_CMDQ:
378         fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_cmdq.status);
379
380     case FORE200E_STATE_INITIALIZE:
381         /* nothing to do for that state */
382
383     case FORE200E_STATE_START_FW:
384         /* nothing to do for that state */
385
386     case FORE200E_STATE_RESET:
387         /* nothing to do for that state */
388
389     case FORE200E_STATE_MAP:
390         fore200e->bus->unmap(fore200e);
391
392     case FORE200E_STATE_CONFIGURE:
393         /* nothing to do for that state */
394
395     case FORE200E_STATE_REGISTER:
396         /* XXX shouldn't we *start* by deregistering the device? */
397         atm_dev_deregister(fore200e->atm_dev);
398
399     case FORE200E_STATE_BLANK:
400         /* nothing to do for that state */
401         break;
402     }
403 }
404
405
406 #ifdef CONFIG_PCI
407
408 static u32 fore200e_pca_read(volatile u32 __iomem *addr)
409 {
410     /* on big-endian hosts, the board is configured to convert
411        the endianess of slave RAM accesses  */
412     return le32_to_cpu(readl(addr));
413 }
414
415
416 static void fore200e_pca_write(u32 val, volatile u32 __iomem *addr)
417 {
418     /* on big-endian hosts, the board is configured to convert
419        the endianess of slave RAM accesses  */
420     writel(cpu_to_le32(val), addr);
421 }
422
423
424 static u32
425 fore200e_pca_dma_map(struct fore200e* fore200e, void* virt_addr, int size, int direction)
426 {
427     u32 dma_addr = pci_map_single((struct pci_dev*)fore200e->bus_dev, virt_addr, size, direction);
428
429     DPRINTK(3, "PCI DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d,  --> dma_addr = 0x%08x\n",
430             virt_addr, size, direction, dma_addr);
431     
432     return dma_addr;
433 }
434
435
436 static void
437 fore200e_pca_dma_unmap(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
438 {
439     DPRINTK(3, "PCI DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d\n",
440             dma_addr, size, direction);
441
442     pci_unmap_single((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction);
443 }
444
445
446 static void
447 fore200e_pca_dma_sync_for_cpu(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
448 {
449     DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
450
451     pci_dma_sync_single_for_cpu((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction);
452 }
453
454 static void
455 fore200e_pca_dma_sync_for_device(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
456 {
457     DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
458
459     pci_dma_sync_single_for_device((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction);
460 }
461
462
463 /* allocate a DMA consistent chunk of memory intended to act as a communication mechanism
464    (to hold descriptors, status, queues, etc.) shared by the driver and the adapter */
465
466 static int
467 fore200e_pca_dma_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk,
468                              int size, int nbr, int alignment)
469 {
470     /* returned chunks are page-aligned */
471     chunk->alloc_size = size * nbr;
472     chunk->alloc_addr = pci_alloc_consistent((struct pci_dev*)fore200e->bus_dev,
473                                              chunk->alloc_size,
474                                              &chunk->dma_addr);
475     
476     if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0))
477         return -ENOMEM;
478
479     chunk->align_addr = chunk->alloc_addr;
480     
481     return 0;
482 }
483
484
485 /* free a DMA consistent chunk of memory */
486
487 static void
488 fore200e_pca_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
489 {
490     pci_free_consistent((struct pci_dev*)fore200e->bus_dev,
491                         chunk->alloc_size,
492                         chunk->alloc_addr,
493                         chunk->dma_addr);
494 }
495
496
497 static int
498 fore200e_pca_irq_check(struct fore200e* fore200e)
499 {
500     /* this is a 1 bit register */
501     int irq_posted = readl(fore200e->regs.pca.psr);
502
503 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG == 2)
504     if (irq_posted && (readl(fore200e->regs.pca.hcr) & PCA200E_HCR_OUTFULL)) {
505         DPRINTK(2,"FIFO OUT full, device %d\n", fore200e->atm_dev->number);
506     }
507 #endif
508
509     return irq_posted;
510 }
511
512
513 static void
514 fore200e_pca_irq_ack(struct fore200e* fore200e)
515 {
516     writel(PCA200E_HCR_CLRINTR, fore200e->regs.pca.hcr);
517 }
518
519
520 static void
521 fore200e_pca_reset(struct fore200e* fore200e)
522 {
523     writel(PCA200E_HCR_RESET, fore200e->regs.pca.hcr);
524     fore200e_spin(10);
525     writel(0, fore200e->regs.pca.hcr);
526 }
527
528
529 static int __devinit
530 fore200e_pca_map(struct fore200e* fore200e)
531 {
532     DPRINTK(2, "device %s being mapped in memory\n", fore200e->name);
533
534     fore200e->virt_base = ioremap(fore200e->phys_base, PCA200E_IOSPACE_LENGTH);
535     
536     if (fore200e->virt_base == NULL) {
537         printk(FORE200E "can't map device %s\n", fore200e->name);
538         return -EFAULT;
539     }
540
541     DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
542
543     /* gain access to the PCA specific registers  */
544     fore200e->regs.pca.hcr = fore200e->virt_base + PCA200E_HCR_OFFSET;
545     fore200e->regs.pca.imr = fore200e->virt_base + PCA200E_IMR_OFFSET;
546     fore200e->regs.pca.psr = fore200e->virt_base + PCA200E_PSR_OFFSET;
547
548     fore200e->state = FORE200E_STATE_MAP;
549     return 0;
550 }
551
552
553 static void
554 fore200e_pca_unmap(struct fore200e* fore200e)
555 {
556     DPRINTK(2, "device %s being unmapped from memory\n", fore200e->name);
557
558     if (fore200e->virt_base != NULL)
559         iounmap(fore200e->virt_base);
560 }
561
562
563 static int __devinit
564 fore200e_pca_configure(struct fore200e* fore200e)
565 {
566     struct pci_dev* pci_dev = (struct pci_dev*)fore200e->bus_dev;
567     u8              master_ctrl, latency;
568
569     DPRINTK(2, "device %s being configured\n", fore200e->name);
570
571     if ((pci_dev->irq == 0) || (pci_dev->irq == 0xFF)) {
572         printk(FORE200E "incorrect IRQ setting - misconfigured PCI-PCI bridge?\n");
573         return -EIO;
574     }
575
576     pci_read_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, &master_ctrl);
577
578     master_ctrl = master_ctrl
579 #if defined(__BIG_ENDIAN)
580         /* request the PCA board to convert the endianess of slave RAM accesses */
581         | PCA200E_CTRL_CONVERT_ENDIAN
582 #endif
583 #if 0
584         | PCA200E_CTRL_DIS_CACHE_RD
585         | PCA200E_CTRL_DIS_WRT_INVAL
586         | PCA200E_CTRL_ENA_CONT_REQ_MODE
587         | PCA200E_CTRL_2_CACHE_WRT_INVAL
588 #endif
589         | PCA200E_CTRL_LARGE_PCI_BURSTS;
590     
591     pci_write_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, master_ctrl);
592
593     /* raise latency from 32 (default) to 192, as this seems to prevent NIC
594        lockups (under heavy rx loads) due to continuous 'FIFO OUT full' condition.
595        this may impact the performances of other PCI devices on the same bus, though */
596     latency = 192;
597     pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
598
599     fore200e->state = FORE200E_STATE_CONFIGURE;
600     return 0;
601 }
602
603
604 static int __init
605 fore200e_pca_prom_read(struct fore200e* fore200e, struct prom_data* prom)
606 {
607     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
608     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
609     struct prom_opcode      opcode;
610     int                     ok;
611     u32                     prom_dma;
612
613     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
614
615     opcode.opcode = OPCODE_GET_PROM;
616     opcode.pad    = 0;
617
618     prom_dma = fore200e->bus->dma_map(fore200e, prom, sizeof(struct prom_data), DMA_FROM_DEVICE);
619
620     fore200e->bus->write(prom_dma, &entry->cp_entry->cmd.prom_block.prom_haddr);
621     
622     *entry->status = STATUS_PENDING;
623
624     fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.prom_block.opcode);
625
626     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
627
628     *entry->status = STATUS_FREE;
629
630     fore200e->bus->dma_unmap(fore200e, prom_dma, sizeof(struct prom_data), DMA_FROM_DEVICE);
631
632     if (ok == 0) {
633         printk(FORE200E "unable to get PROM data from device %s\n", fore200e->name);
634         return -EIO;
635     }
636
637 #if defined(__BIG_ENDIAN)
638     
639 #define swap_here(addr) (*((u32*)(addr)) = swab32( *((u32*)(addr)) ))
640
641     /* MAC address is stored as little-endian */
642     swap_here(&prom->mac_addr[0]);
643     swap_here(&prom->mac_addr[4]);
644 #endif
645     
646     return 0;
647 }
648
649
650 static int
651 fore200e_pca_proc_read(struct fore200e* fore200e, char *page)
652 {
653     struct pci_dev* pci_dev = (struct pci_dev*)fore200e->bus_dev;
654
655     return sprintf(page, "   PCI bus/slot/function:\t%d/%d/%d\n",
656                    pci_dev->bus->number, PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
657 }
658
659 #endif /* CONFIG_PCI */
660
661
662 #ifdef CONFIG_SBUS
663
664 static u32
665 fore200e_sba_read(volatile u32 __iomem *addr)
666 {
667     return sbus_readl(addr);
668 }
669
670
671 static void
672 fore200e_sba_write(u32 val, volatile u32 __iomem *addr)
673 {
674     sbus_writel(val, addr);
675 }
676
677
678 static u32
679 fore200e_sba_dma_map(struct fore200e* fore200e, void* virt_addr, int size, int direction)
680 {
681     u32 dma_addr = sbus_map_single((struct sbus_dev*)fore200e->bus_dev, virt_addr, size, direction);
682
683     DPRINTK(3, "SBUS DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d --> dma_addr = 0x%08x\n",
684             virt_addr, size, direction, dma_addr);
685     
686     return dma_addr;
687 }
688
689
690 static void
691 fore200e_sba_dma_unmap(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
692 {
693     DPRINTK(3, "SBUS DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d,\n",
694             dma_addr, size, direction);
695
696     sbus_unmap_single((struct sbus_dev*)fore200e->bus_dev, dma_addr, size, direction);
697 }
698
699
700 static void
701 fore200e_sba_dma_sync_for_cpu(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
702 {
703     DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
704     
705     sbus_dma_sync_single_for_cpu((struct sbus_dev*)fore200e->bus_dev, dma_addr, size, direction);
706 }
707
708 static void
709 fore200e_sba_dma_sync_for_device(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
710 {
711     DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
712
713     sbus_dma_sync_single_for_device((struct sbus_dev*)fore200e->bus_dev, dma_addr, size, direction);
714 }
715
716
717 /* allocate a DVMA consistent chunk of memory intended to act as a communication mechanism
718    (to hold descriptors, status, queues, etc.) shared by the driver and the adapter */
719
720 static int
721 fore200e_sba_dma_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk,
722                              int size, int nbr, int alignment)
723 {
724     chunk->alloc_size = chunk->align_size = size * nbr;
725
726     /* returned chunks are page-aligned */
727     chunk->alloc_addr = sbus_alloc_consistent((struct sbus_dev*)fore200e->bus_dev,
728                                               chunk->alloc_size,
729                                               &chunk->dma_addr);
730
731     if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0))
732         return -ENOMEM;
733
734     chunk->align_addr = chunk->alloc_addr;
735     
736     return 0;
737 }
738
739
740 /* free a DVMA consistent chunk of memory */
741
742 static void
743 fore200e_sba_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
744 {
745     sbus_free_consistent((struct sbus_dev*)fore200e->bus_dev,
746                          chunk->alloc_size,
747                          chunk->alloc_addr,
748                          chunk->dma_addr);
749 }
750
751
752 static void
753 fore200e_sba_irq_enable(struct fore200e* fore200e)
754 {
755     u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
756     fore200e->bus->write(hcr | SBA200E_HCR_INTR_ENA, fore200e->regs.sba.hcr);
757 }
758
759
760 static int
761 fore200e_sba_irq_check(struct fore200e* fore200e)
762 {
763     return fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_INTR_REQ;
764 }
765
766
767 static void
768 fore200e_sba_irq_ack(struct fore200e* fore200e)
769 {
770     u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
771     fore200e->bus->write(hcr | SBA200E_HCR_INTR_CLR, fore200e->regs.sba.hcr);
772 }
773
774
775 static void
776 fore200e_sba_reset(struct fore200e* fore200e)
777 {
778     fore200e->bus->write(SBA200E_HCR_RESET, fore200e->regs.sba.hcr);
779     fore200e_spin(10);
780     fore200e->bus->write(0, fore200e->regs.sba.hcr);
781 }
782
783
784 static int __init
785 fore200e_sba_map(struct fore200e* fore200e)
786 {
787     struct sbus_dev* sbus_dev = (struct sbus_dev*)fore200e->bus_dev;
788     unsigned int bursts;
789
790     /* gain access to the SBA specific registers  */
791     fore200e->regs.sba.hcr = sbus_ioremap(&sbus_dev->resource[0], 0, SBA200E_HCR_LENGTH, "SBA HCR");
792     fore200e->regs.sba.bsr = sbus_ioremap(&sbus_dev->resource[1], 0, SBA200E_BSR_LENGTH, "SBA BSR");
793     fore200e->regs.sba.isr = sbus_ioremap(&sbus_dev->resource[2], 0, SBA200E_ISR_LENGTH, "SBA ISR");
794     fore200e->virt_base    = sbus_ioremap(&sbus_dev->resource[3], 0, SBA200E_RAM_LENGTH, "SBA RAM");
795
796     if (fore200e->virt_base == NULL) {
797         printk(FORE200E "unable to map RAM of device %s\n", fore200e->name);
798         return -EFAULT;
799     }
800
801     DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
802     
803     fore200e->bus->write(0x02, fore200e->regs.sba.isr); /* XXX hardwired interrupt level */
804
805     /* get the supported DVMA burst sizes */
806     bursts = prom_getintdefault(sbus_dev->bus->prom_node, "burst-sizes", 0x00);
807
808     if (sbus_can_dma_64bit(sbus_dev))
809         sbus_set_sbus64(sbus_dev, bursts);
810
811     fore200e->state = FORE200E_STATE_MAP;
812     return 0;
813 }
814
815
816 static void
817 fore200e_sba_unmap(struct fore200e* fore200e)
818 {
819     sbus_iounmap(fore200e->regs.sba.hcr, SBA200E_HCR_LENGTH);
820     sbus_iounmap(fore200e->regs.sba.bsr, SBA200E_BSR_LENGTH);
821     sbus_iounmap(fore200e->regs.sba.isr, SBA200E_ISR_LENGTH);
822     sbus_iounmap(fore200e->virt_base,    SBA200E_RAM_LENGTH);
823 }
824
825
826 static int __init
827 fore200e_sba_configure(struct fore200e* fore200e)
828 {
829     fore200e->state = FORE200E_STATE_CONFIGURE;
830     return 0;
831 }
832
833
834 static struct fore200e* __init
835 fore200e_sba_detect(const struct fore200e_bus* bus, int index)
836 {
837     struct fore200e*          fore200e;
838     struct sbus_bus* sbus_bus;
839     struct sbus_dev* sbus_dev = NULL;
840     
841     unsigned int     count = 0;
842     
843     for_each_sbus (sbus_bus) {
844         for_each_sbusdev (sbus_dev, sbus_bus) {
845             if (strcmp(sbus_dev->prom_name, SBA200E_PROM_NAME) == 0) {
846                 if (count >= index)
847                     goto found;
848                 count++;
849             }
850         }
851     }
852     return NULL;
853     
854   found:
855     if (sbus_dev->num_registers != 4) {
856         printk(FORE200E "this %s device has %d instead of 4 registers\n",
857                bus->model_name, sbus_dev->num_registers);
858         return NULL;
859     }
860
861     fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
862     if (fore200e == NULL)
863         return NULL;
864
865     fore200e->bus     = bus;
866     fore200e->bus_dev = sbus_dev;
867     fore200e->irq     = sbus_dev->irqs[ 0 ];
868
869     fore200e->phys_base = (unsigned long)sbus_dev;
870
871     sprintf(fore200e->name, "%s-%d", bus->model_name, index - 1);
872     
873     return fore200e;
874 }
875
876
877 static int __init
878 fore200e_sba_prom_read(struct fore200e* fore200e, struct prom_data* prom)
879 {
880     struct sbus_dev* sbus_dev = (struct sbus_dev*) fore200e->bus_dev;
881     int                       len;
882
883     len = prom_getproperty(sbus_dev->prom_node, "macaddrlo2", &prom->mac_addr[ 4 ], 4);
884     if (len < 0)
885         return -EBUSY;
886
887     len = prom_getproperty(sbus_dev->prom_node, "macaddrhi4", &prom->mac_addr[ 2 ], 4);
888     if (len < 0)
889         return -EBUSY;
890     
891     prom_getproperty(sbus_dev->prom_node, "serialnumber",
892                      (char*)&prom->serial_number, sizeof(prom->serial_number));
893     
894     prom_getproperty(sbus_dev->prom_node, "promversion",
895                      (char*)&prom->hw_revision, sizeof(prom->hw_revision));
896     
897     return 0;
898 }
899
900
901 static int
902 fore200e_sba_proc_read(struct fore200e* fore200e, char *page)
903 {
904     struct sbus_dev* sbus_dev = (struct sbus_dev*)fore200e->bus_dev;
905
906     return sprintf(page, "   SBUS slot/device:\t\t%d/'%s'\n", sbus_dev->slot, sbus_dev->prom_name);
907 }
908 #endif /* CONFIG_SBUS */
909
910
911 static void
912 fore200e_tx_irq(struct fore200e* fore200e)
913 {
914     struct host_txq*        txq = &fore200e->host_txq;
915     struct host_txq_entry*  entry;
916     struct atm_vcc*         vcc;
917     struct fore200e_vc_map* vc_map;
918
919     if (fore200e->host_txq.txing == 0)
920         return;
921
922     for (;;) {
923         
924         entry = &txq->host_entry[ txq->tail ];
925
926         if ((*entry->status & STATUS_COMPLETE) == 0) {
927             break;
928         }
929
930         DPRINTK(3, "TX COMPLETED: entry = %p [tail = %d], vc_map = %p, skb = %p\n", 
931                 entry, txq->tail, entry->vc_map, entry->skb);
932
933         /* free copy of misaligned data */
934         kfree(entry->data);
935         
936         /* remove DMA mapping */
937         fore200e->bus->dma_unmap(fore200e, entry->tpd->tsd[ 0 ].buffer, entry->tpd->tsd[ 0 ].length,
938                                  DMA_TO_DEVICE);
939
940         vc_map = entry->vc_map;
941
942         /* vcc closed since the time the entry was submitted for tx? */
943         if ((vc_map->vcc == NULL) ||
944             (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
945
946             DPRINTK(1, "no ready vcc found for PDU sent on device %d\n",
947                     fore200e->atm_dev->number);
948
949             dev_kfree_skb_any(entry->skb);
950         }
951         else {
952             ASSERT(vc_map->vcc);
953
954             /* vcc closed then immediately re-opened? */
955             if (vc_map->incarn != entry->incarn) {
956
957                 /* when a vcc is closed, some PDUs may be still pending in the tx queue.
958                    if the same vcc is immediately re-opened, those pending PDUs must
959                    not be popped after the completion of their emission, as they refer
960                    to the prior incarnation of that vcc. otherwise, sk_atm(vcc)->sk_wmem_alloc
961                    would be decremented by the size of the (unrelated) skb, possibly
962                    leading to a negative sk->sk_wmem_alloc count, ultimately freezing the vcc.
963                    we thus bind the tx entry to the current incarnation of the vcc
964                    when the entry is submitted for tx. When the tx later completes,
965                    if the incarnation number of the tx entry does not match the one
966                    of the vcc, then this implies that the vcc has been closed then re-opened.
967                    we thus just drop the skb here. */
968
969                 DPRINTK(1, "vcc closed-then-re-opened; dropping PDU sent on device %d\n",
970                         fore200e->atm_dev->number);
971
972                 dev_kfree_skb_any(entry->skb);
973             }
974             else {
975                 vcc = vc_map->vcc;
976                 ASSERT(vcc);
977
978                 /* notify tx completion */
979                 if (vcc->pop) {
980                     vcc->pop(vcc, entry->skb);
981                 }
982                 else {
983                     dev_kfree_skb_any(entry->skb);
984                 }
985 #if 1
986                 /* race fixed by the above incarnation mechanism, but... */
987                 if (atomic_read(&sk_atm(vcc)->sk_wmem_alloc) < 0) {
988                     atomic_set(&sk_atm(vcc)->sk_wmem_alloc, 0);
989                 }
990 #endif
991                 /* check error condition */
992                 if (*entry->status & STATUS_ERROR)
993                     atomic_inc(&vcc->stats->tx_err);
994                 else
995                     atomic_inc(&vcc->stats->tx);
996             }
997         }
998
999         *entry->status = STATUS_FREE;
1000
1001         fore200e->host_txq.txing--;
1002
1003         FORE200E_NEXT_ENTRY(txq->tail, QUEUE_SIZE_TX);
1004     }
1005 }
1006
1007
1008 #ifdef FORE200E_BSQ_DEBUG
1009 int bsq_audit(int where, struct host_bsq* bsq, int scheme, int magn)
1010 {
1011     struct buffer* buffer;
1012     int count = 0;
1013
1014     buffer = bsq->freebuf;
1015     while (buffer) {
1016
1017         if (buffer->supplied) {
1018             printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld supplied but in free list!\n",
1019                    where, scheme, magn, buffer->index);
1020         }
1021
1022         if (buffer->magn != magn) {
1023             printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected magn = %d\n",
1024                    where, scheme, magn, buffer->index, buffer->magn);
1025         }
1026
1027         if (buffer->scheme != scheme) {
1028             printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected scheme = %d\n",
1029                    where, scheme, magn, buffer->index, buffer->scheme);
1030         }
1031
1032         if ((buffer->index < 0) || (buffer->index >= fore200e_rx_buf_nbr[ scheme ][ magn ])) {
1033             printk(FORE200E "bsq_audit(%d): queue %d.%d, out of range buffer index = %ld !\n",
1034                    where, scheme, magn, buffer->index);
1035         }
1036
1037         count++;
1038         buffer = buffer->next;
1039     }
1040
1041     if (count != bsq->freebuf_count) {
1042         printk(FORE200E "bsq_audit(%d): queue %d.%d, %d bufs in free list, but freebuf_count = %d\n",
1043                where, scheme, magn, count, bsq->freebuf_count);
1044     }
1045     return 0;
1046 }
1047 #endif
1048
1049
1050 static void
1051 fore200e_supply(struct fore200e* fore200e)
1052 {
1053     int  scheme, magn, i;
1054
1055     struct host_bsq*       bsq;
1056     struct host_bsq_entry* entry;
1057     struct buffer*         buffer;
1058
1059     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
1060         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
1061
1062             bsq = &fore200e->host_bsq[ scheme ][ magn ];
1063
1064 #ifdef FORE200E_BSQ_DEBUG
1065             bsq_audit(1, bsq, scheme, magn);
1066 #endif
1067             while (bsq->freebuf_count >= RBD_BLK_SIZE) {
1068
1069                 DPRINTK(2, "supplying %d rx buffers to queue %d / %d, freebuf_count = %d\n",
1070                         RBD_BLK_SIZE, scheme, magn, bsq->freebuf_count);
1071
1072                 entry = &bsq->host_entry[ bsq->head ];
1073
1074                 for (i = 0; i < RBD_BLK_SIZE; i++) {
1075
1076                     /* take the first buffer in the free buffer list */
1077                     buffer = bsq->freebuf;
1078                     if (!buffer) {
1079                         printk(FORE200E "no more free bufs in queue %d.%d, but freebuf_count = %d\n",
1080                                scheme, magn, bsq->freebuf_count);
1081                         return;
1082                     }
1083                     bsq->freebuf = buffer->next;
1084                     
1085 #ifdef FORE200E_BSQ_DEBUG
1086                     if (buffer->supplied)
1087                         printk(FORE200E "queue %d.%d, buffer %lu already supplied\n",
1088                                scheme, magn, buffer->index);
1089                     buffer->supplied = 1;
1090 #endif
1091                     entry->rbd_block->rbd[ i ].buffer_haddr = buffer->data.dma_addr;
1092                     entry->rbd_block->rbd[ i ].handle       = FORE200E_BUF2HDL(buffer);
1093                 }
1094
1095                 FORE200E_NEXT_ENTRY(bsq->head, QUEUE_SIZE_BS);
1096
1097                 /* decrease accordingly the number of free rx buffers */
1098                 bsq->freebuf_count -= RBD_BLK_SIZE;
1099
1100                 *entry->status = STATUS_PENDING;
1101                 fore200e->bus->write(entry->rbd_block_dma, &entry->cp_entry->rbd_block_haddr);
1102             }
1103         }
1104     }
1105 }
1106
1107
1108 static int
1109 fore200e_push_rpd(struct fore200e* fore200e, struct atm_vcc* vcc, struct rpd* rpd)
1110 {
1111     struct sk_buff*      skb;
1112     struct buffer*       buffer;
1113     struct fore200e_vcc* fore200e_vcc;
1114     int                  i, pdu_len = 0;
1115 #ifdef FORE200E_52BYTE_AAL0_SDU
1116     u32                  cell_header = 0;
1117 #endif
1118
1119     ASSERT(vcc);
1120     
1121     fore200e_vcc = FORE200E_VCC(vcc);
1122     ASSERT(fore200e_vcc);
1123
1124 #ifdef FORE200E_52BYTE_AAL0_SDU
1125     if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.rxtp.max_sdu == ATM_AAL0_SDU)) {
1126
1127         cell_header = (rpd->atm_header.gfc << ATM_HDR_GFC_SHIFT) |
1128                       (rpd->atm_header.vpi << ATM_HDR_VPI_SHIFT) |
1129                       (rpd->atm_header.vci << ATM_HDR_VCI_SHIFT) |
1130                       (rpd->atm_header.plt << ATM_HDR_PTI_SHIFT) | 
1131                        rpd->atm_header.clp;
1132         pdu_len = 4;
1133     }
1134 #endif
1135     
1136     /* compute total PDU length */
1137     for (i = 0; i < rpd->nseg; i++)
1138         pdu_len += rpd->rsd[ i ].length;
1139     
1140     skb = alloc_skb(pdu_len, GFP_ATOMIC);
1141     if (skb == NULL) {
1142         DPRINTK(2, "unable to alloc new skb, rx PDU length = %d\n", pdu_len);
1143
1144         atomic_inc(&vcc->stats->rx_drop);
1145         return -ENOMEM;
1146     } 
1147
1148     __net_timestamp(skb);
1149     
1150 #ifdef FORE200E_52BYTE_AAL0_SDU
1151     if (cell_header) {
1152         *((u32*)skb_put(skb, 4)) = cell_header;
1153     }
1154 #endif
1155
1156     /* reassemble segments */
1157     for (i = 0; i < rpd->nseg; i++) {
1158         
1159         /* rebuild rx buffer address from rsd handle */
1160         buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1161         
1162         /* Make device DMA transfer visible to CPU.  */
1163         fore200e->bus->dma_sync_for_cpu(fore200e, buffer->data.dma_addr, rpd->rsd[ i ].length, DMA_FROM_DEVICE);
1164         
1165         memcpy(skb_put(skb, rpd->rsd[ i ].length), buffer->data.align_addr, rpd->rsd[ i ].length);
1166
1167         /* Now let the device get at it again.  */
1168         fore200e->bus->dma_sync_for_device(fore200e, buffer->data.dma_addr, rpd->rsd[ i ].length, DMA_FROM_DEVICE);
1169     }
1170
1171     DPRINTK(3, "rx skb: len = %d, truesize = %d\n", skb->len, skb->truesize);
1172     
1173     if (pdu_len < fore200e_vcc->rx_min_pdu)
1174         fore200e_vcc->rx_min_pdu = pdu_len;
1175     if (pdu_len > fore200e_vcc->rx_max_pdu)
1176         fore200e_vcc->rx_max_pdu = pdu_len;
1177     fore200e_vcc->rx_pdu++;
1178
1179     /* push PDU */
1180     if (atm_charge(vcc, skb->truesize) == 0) {
1181
1182         DPRINTK(2, "receive buffers saturated for %d.%d.%d - PDU dropped\n",
1183                 vcc->itf, vcc->vpi, vcc->vci);
1184
1185         dev_kfree_skb_any(skb);
1186
1187         atomic_inc(&vcc->stats->rx_drop);
1188         return -ENOMEM;
1189     }
1190
1191     ASSERT(atomic_read(&sk_atm(vcc)->sk_wmem_alloc) >= 0);
1192
1193     vcc->push(vcc, skb);
1194     atomic_inc(&vcc->stats->rx);
1195
1196     ASSERT(atomic_read(&sk_atm(vcc)->sk_wmem_alloc) >= 0);
1197
1198     return 0;
1199 }
1200
1201
1202 static void
1203 fore200e_collect_rpd(struct fore200e* fore200e, struct rpd* rpd)
1204 {
1205     struct host_bsq* bsq;
1206     struct buffer*   buffer;
1207     int              i;
1208     
1209     for (i = 0; i < rpd->nseg; i++) {
1210
1211         /* rebuild rx buffer address from rsd handle */
1212         buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1213
1214         bsq = &fore200e->host_bsq[ buffer->scheme ][ buffer->magn ];
1215
1216 #ifdef FORE200E_BSQ_DEBUG
1217         bsq_audit(2, bsq, buffer->scheme, buffer->magn);
1218
1219         if (buffer->supplied == 0)
1220             printk(FORE200E "queue %d.%d, buffer %ld was not supplied\n",
1221                    buffer->scheme, buffer->magn, buffer->index);
1222         buffer->supplied = 0;
1223 #endif
1224
1225         /* re-insert the buffer into the free buffer list */
1226         buffer->next = bsq->freebuf;
1227         bsq->freebuf = buffer;
1228
1229         /* then increment the number of free rx buffers */
1230         bsq->freebuf_count++;
1231     }
1232 }
1233
1234
1235 static void
1236 fore200e_rx_irq(struct fore200e* fore200e)
1237 {
1238     struct host_rxq*        rxq = &fore200e->host_rxq;
1239     struct host_rxq_entry*  entry;
1240     struct atm_vcc*         vcc;
1241     struct fore200e_vc_map* vc_map;
1242
1243     for (;;) {
1244         
1245         entry = &rxq->host_entry[ rxq->head ];
1246
1247         /* no more received PDUs */
1248         if ((*entry->status & STATUS_COMPLETE) == 0)
1249             break;
1250
1251         vc_map = FORE200E_VC_MAP(fore200e, entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1252
1253         if ((vc_map->vcc == NULL) ||
1254             (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
1255
1256             DPRINTK(1, "no ready VC found for PDU received on %d.%d.%d\n",
1257                     fore200e->atm_dev->number,
1258                     entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1259         }
1260         else {
1261             vcc = vc_map->vcc;
1262             ASSERT(vcc);
1263
1264             if ((*entry->status & STATUS_ERROR) == 0) {
1265
1266                 fore200e_push_rpd(fore200e, vcc, entry->rpd);
1267             }
1268             else {
1269                 DPRINTK(2, "damaged PDU on %d.%d.%d\n",
1270                         fore200e->atm_dev->number,
1271                         entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1272                 atomic_inc(&vcc->stats->rx_err);
1273             }
1274         }
1275
1276         FORE200E_NEXT_ENTRY(rxq->head, QUEUE_SIZE_RX);
1277
1278         fore200e_collect_rpd(fore200e, entry->rpd);
1279
1280         /* rewrite the rpd address to ack the received PDU */
1281         fore200e->bus->write(entry->rpd_dma, &entry->cp_entry->rpd_haddr);
1282         *entry->status = STATUS_FREE;
1283
1284         fore200e_supply(fore200e);
1285     }
1286 }
1287
1288
1289 #ifndef FORE200E_USE_TASKLET
1290 static void
1291 fore200e_irq(struct fore200e* fore200e)
1292 {
1293     unsigned long flags;
1294
1295     spin_lock_irqsave(&fore200e->q_lock, flags);
1296     fore200e_rx_irq(fore200e);
1297     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1298
1299     spin_lock_irqsave(&fore200e->q_lock, flags);
1300     fore200e_tx_irq(fore200e);
1301     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1302 }
1303 #endif
1304
1305
1306 static irqreturn_t
1307 fore200e_interrupt(int irq, void* dev)
1308 {
1309     struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev);
1310
1311     if (fore200e->bus->irq_check(fore200e) == 0) {
1312         
1313         DPRINTK(3, "interrupt NOT triggered by device %d\n", fore200e->atm_dev->number);
1314         return IRQ_NONE;
1315     }
1316     DPRINTK(3, "interrupt triggered by device %d\n", fore200e->atm_dev->number);
1317
1318 #ifdef FORE200E_USE_TASKLET
1319     tasklet_schedule(&fore200e->tx_tasklet);
1320     tasklet_schedule(&fore200e->rx_tasklet);
1321 #else
1322     fore200e_irq(fore200e);
1323 #endif
1324     
1325     fore200e->bus->irq_ack(fore200e);
1326     return IRQ_HANDLED;
1327 }
1328
1329
1330 #ifdef FORE200E_USE_TASKLET
1331 static void
1332 fore200e_tx_tasklet(unsigned long data)
1333 {
1334     struct fore200e* fore200e = (struct fore200e*) data;
1335     unsigned long flags;
1336
1337     DPRINTK(3, "tx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1338
1339     spin_lock_irqsave(&fore200e->q_lock, flags);
1340     fore200e_tx_irq(fore200e);
1341     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1342 }
1343
1344
1345 static void
1346 fore200e_rx_tasklet(unsigned long data)
1347 {
1348     struct fore200e* fore200e = (struct fore200e*) data;
1349     unsigned long    flags;
1350
1351     DPRINTK(3, "rx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1352
1353     spin_lock_irqsave(&fore200e->q_lock, flags);
1354     fore200e_rx_irq((struct fore200e*) data);
1355     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1356 }
1357 #endif
1358
1359
1360 static int
1361 fore200e_select_scheme(struct atm_vcc* vcc)
1362 {
1363     /* fairly balance the VCs over (identical) buffer schemes */
1364     int scheme = vcc->vci % 2 ? BUFFER_SCHEME_ONE : BUFFER_SCHEME_TWO;
1365
1366     DPRINTK(1, "VC %d.%d.%d uses buffer scheme %d\n",
1367             vcc->itf, vcc->vpi, vcc->vci, scheme);
1368
1369     return scheme;
1370 }
1371
1372
1373 static int 
1374 fore200e_activate_vcin(struct fore200e* fore200e, int activate, struct atm_vcc* vcc, int mtu)
1375 {
1376     struct host_cmdq*        cmdq  = &fore200e->host_cmdq;
1377     struct host_cmdq_entry*  entry = &cmdq->host_entry[ cmdq->head ];
1378     struct activate_opcode   activ_opcode;
1379     struct deactivate_opcode deactiv_opcode;
1380     struct vpvc              vpvc;
1381     int                      ok;
1382     enum fore200e_aal        aal = fore200e_atm2fore_aal(vcc->qos.aal);
1383
1384     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1385     
1386     if (activate) {
1387         FORE200E_VCC(vcc)->scheme = fore200e_select_scheme(vcc);
1388         
1389         activ_opcode.opcode = OPCODE_ACTIVATE_VCIN;
1390         activ_opcode.aal    = aal;
1391         activ_opcode.scheme = FORE200E_VCC(vcc)->scheme;
1392         activ_opcode.pad    = 0;
1393     }
1394     else {
1395         deactiv_opcode.opcode = OPCODE_DEACTIVATE_VCIN;
1396         deactiv_opcode.pad    = 0;
1397     }
1398
1399     vpvc.vci = vcc->vci;
1400     vpvc.vpi = vcc->vpi;
1401
1402     *entry->status = STATUS_PENDING;
1403
1404     if (activate) {
1405
1406 #ifdef FORE200E_52BYTE_AAL0_SDU
1407         mtu = 48;
1408 #endif
1409         /* the MTU is not used by the cp, except in the case of AAL0 */
1410         fore200e->bus->write(mtu,                        &entry->cp_entry->cmd.activate_block.mtu);
1411         fore200e->bus->write(*(u32*)&vpvc,         (u32 __iomem *)&entry->cp_entry->cmd.activate_block.vpvc);
1412         fore200e->bus->write(*(u32*)&activ_opcode, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.opcode);
1413     }
1414     else {
1415         fore200e->bus->write(*(u32*)&vpvc,         (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.vpvc);
1416         fore200e->bus->write(*(u32*)&deactiv_opcode, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.opcode);
1417     }
1418
1419     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1420
1421     *entry->status = STATUS_FREE;
1422
1423     if (ok == 0) {
1424         printk(FORE200E "unable to %s VC %d.%d.%d\n",
1425                activate ? "open" : "close", vcc->itf, vcc->vpi, vcc->vci);
1426         return -EIO;
1427     }
1428
1429     DPRINTK(1, "VC %d.%d.%d %sed\n", vcc->itf, vcc->vpi, vcc->vci, 
1430             activate ? "open" : "clos");
1431
1432     return 0;
1433 }
1434
1435
1436 #define FORE200E_MAX_BACK2BACK_CELLS 255    /* XXX depends on CDVT */
1437
1438 static void
1439 fore200e_rate_ctrl(struct atm_qos* qos, struct tpd_rate* rate)
1440 {
1441     if (qos->txtp.max_pcr < ATM_OC3_PCR) {
1442     
1443         /* compute the data cells to idle cells ratio from the tx PCR */
1444         rate->data_cells = qos->txtp.max_pcr * FORE200E_MAX_BACK2BACK_CELLS / ATM_OC3_PCR;
1445         rate->idle_cells = FORE200E_MAX_BACK2BACK_CELLS - rate->data_cells;
1446     }
1447     else {
1448         /* disable rate control */
1449         rate->data_cells = rate->idle_cells = 0;
1450     }
1451 }
1452
1453
1454 static int
1455 fore200e_open(struct atm_vcc *vcc)
1456 {
1457     struct fore200e*        fore200e = FORE200E_DEV(vcc->dev);
1458     struct fore200e_vcc*    fore200e_vcc;
1459     struct fore200e_vc_map* vc_map;
1460     unsigned long           flags;
1461     int                     vci = vcc->vci;
1462     short                   vpi = vcc->vpi;
1463
1464     ASSERT((vpi >= 0) && (vpi < 1<<FORE200E_VPI_BITS));
1465     ASSERT((vci >= 0) && (vci < 1<<FORE200E_VCI_BITS));
1466
1467     spin_lock_irqsave(&fore200e->q_lock, flags);
1468
1469     vc_map = FORE200E_VC_MAP(fore200e, vpi, vci);
1470     if (vc_map->vcc) {
1471
1472         spin_unlock_irqrestore(&fore200e->q_lock, flags);
1473
1474         printk(FORE200E "VC %d.%d.%d already in use\n",
1475                fore200e->atm_dev->number, vpi, vci);
1476
1477         return -EINVAL;
1478     }
1479
1480     vc_map->vcc = vcc;
1481
1482     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1483
1484     fore200e_vcc = kzalloc(sizeof(struct fore200e_vcc), GFP_ATOMIC);
1485     if (fore200e_vcc == NULL) {
1486         vc_map->vcc = NULL;
1487         return -ENOMEM;
1488     }
1489
1490     DPRINTK(2, "opening %d.%d.%d:%d QoS = (tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1491             "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d)\n",
1492             vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1493             fore200e_traffic_class[ vcc->qos.txtp.traffic_class ],
1494             vcc->qos.txtp.min_pcr, vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_cdv, vcc->qos.txtp.max_sdu,
1495             fore200e_traffic_class[ vcc->qos.rxtp.traffic_class ],
1496             vcc->qos.rxtp.min_pcr, vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_cdv, vcc->qos.rxtp.max_sdu);
1497     
1498     /* pseudo-CBR bandwidth requested? */
1499     if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1500         
1501         mutex_lock(&fore200e->rate_mtx);
1502         if (fore200e->available_cell_rate < vcc->qos.txtp.max_pcr) {
1503             mutex_unlock(&fore200e->rate_mtx);
1504
1505             kfree(fore200e_vcc);
1506             vc_map->vcc = NULL;
1507             return -EAGAIN;
1508         }
1509
1510         /* reserve bandwidth */
1511         fore200e->available_cell_rate -= vcc->qos.txtp.max_pcr;
1512         mutex_unlock(&fore200e->rate_mtx);
1513     }
1514     
1515     vcc->itf = vcc->dev->number;
1516
1517     set_bit(ATM_VF_PARTIAL,&vcc->flags);
1518     set_bit(ATM_VF_ADDR, &vcc->flags);
1519
1520     vcc->dev_data = fore200e_vcc;
1521     
1522     if (fore200e_activate_vcin(fore200e, 1, vcc, vcc->qos.rxtp.max_sdu) < 0) {
1523
1524         vc_map->vcc = NULL;
1525
1526         clear_bit(ATM_VF_ADDR, &vcc->flags);
1527         clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1528
1529         vcc->dev_data = NULL;
1530
1531         fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1532
1533         kfree(fore200e_vcc);
1534         return -EINVAL;
1535     }
1536     
1537     /* compute rate control parameters */
1538     if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1539         
1540         fore200e_rate_ctrl(&vcc->qos, &fore200e_vcc->rate);
1541         set_bit(ATM_VF_HASQOS, &vcc->flags);
1542
1543         DPRINTK(3, "tx on %d.%d.%d:%d, tx PCR = %d, rx PCR = %d, data_cells = %u, idle_cells = %u\n",
1544                 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1545                 vcc->qos.txtp.max_pcr, vcc->qos.rxtp.max_pcr, 
1546                 fore200e_vcc->rate.data_cells, fore200e_vcc->rate.idle_cells);
1547     }
1548     
1549     fore200e_vcc->tx_min_pdu = fore200e_vcc->rx_min_pdu = MAX_PDU_SIZE + 1;
1550     fore200e_vcc->tx_max_pdu = fore200e_vcc->rx_max_pdu = 0;
1551     fore200e_vcc->tx_pdu     = fore200e_vcc->rx_pdu     = 0;
1552
1553     /* new incarnation of the vcc */
1554     vc_map->incarn = ++fore200e->incarn_count;
1555
1556     /* VC unusable before this flag is set */
1557     set_bit(ATM_VF_READY, &vcc->flags);
1558
1559     return 0;
1560 }
1561
1562
1563 static void
1564 fore200e_close(struct atm_vcc* vcc)
1565 {
1566     struct fore200e*        fore200e = FORE200E_DEV(vcc->dev);
1567     struct fore200e_vcc*    fore200e_vcc;
1568     struct fore200e_vc_map* vc_map;
1569     unsigned long           flags;
1570
1571     ASSERT(vcc);
1572     ASSERT((vcc->vpi >= 0) && (vcc->vpi < 1<<FORE200E_VPI_BITS));
1573     ASSERT((vcc->vci >= 0) && (vcc->vci < 1<<FORE200E_VCI_BITS));
1574
1575     DPRINTK(2, "closing %d.%d.%d:%d\n", vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal));
1576
1577     clear_bit(ATM_VF_READY, &vcc->flags);
1578
1579     fore200e_activate_vcin(fore200e, 0, vcc, 0);
1580
1581     spin_lock_irqsave(&fore200e->q_lock, flags);
1582
1583     vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1584
1585     /* the vc is no longer considered as "in use" by fore200e_open() */
1586     vc_map->vcc = NULL;
1587
1588     vcc->itf = vcc->vci = vcc->vpi = 0;
1589
1590     fore200e_vcc = FORE200E_VCC(vcc);
1591     vcc->dev_data = NULL;
1592
1593     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1594
1595     /* release reserved bandwidth, if any */
1596     if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1597
1598         mutex_lock(&fore200e->rate_mtx);
1599         fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1600         mutex_unlock(&fore200e->rate_mtx);
1601
1602         clear_bit(ATM_VF_HASQOS, &vcc->flags);
1603     }
1604
1605     clear_bit(ATM_VF_ADDR, &vcc->flags);
1606     clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1607
1608     ASSERT(fore200e_vcc);
1609     kfree(fore200e_vcc);
1610 }
1611
1612
1613 static int
1614 fore200e_send(struct atm_vcc *vcc, struct sk_buff *skb)
1615 {
1616     struct fore200e*        fore200e     = FORE200E_DEV(vcc->dev);
1617     struct fore200e_vcc*    fore200e_vcc = FORE200E_VCC(vcc);
1618     struct fore200e_vc_map* vc_map;
1619     struct host_txq*        txq          = &fore200e->host_txq;
1620     struct host_txq_entry*  entry;
1621     struct tpd*             tpd;
1622     struct tpd_haddr        tpd_haddr;
1623     int                     retry        = CONFIG_ATM_FORE200E_TX_RETRY;
1624     int                     tx_copy      = 0;
1625     int                     tx_len       = skb->len;
1626     u32*                    cell_header  = NULL;
1627     unsigned char*          skb_data;
1628     int                     skb_len;
1629     unsigned char*          data;
1630     unsigned long           flags;
1631
1632     ASSERT(vcc);
1633     ASSERT(atomic_read(&sk_atm(vcc)->sk_wmem_alloc) >= 0);
1634     ASSERT(fore200e);
1635     ASSERT(fore200e_vcc);
1636
1637     if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1638         DPRINTK(1, "VC %d.%d.%d not ready for tx\n", vcc->itf, vcc->vpi, vcc->vpi);
1639         dev_kfree_skb_any(skb);
1640         return -EINVAL;
1641     }
1642
1643 #ifdef FORE200E_52BYTE_AAL0_SDU
1644     if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.txtp.max_sdu == ATM_AAL0_SDU)) {
1645         cell_header = (u32*) skb->data;
1646         skb_data    = skb->data + 4;    /* skip 4-byte cell header */
1647         skb_len     = tx_len = skb->len  - 4;
1648
1649         DPRINTK(3, "user-supplied cell header = 0x%08x\n", *cell_header);
1650     }
1651     else 
1652 #endif
1653     {
1654         skb_data = skb->data;
1655         skb_len  = skb->len;
1656     }
1657     
1658     if (((unsigned long)skb_data) & 0x3) {
1659
1660         DPRINTK(2, "misaligned tx PDU on device %s\n", fore200e->name);
1661         tx_copy = 1;
1662         tx_len  = skb_len;
1663     }
1664
1665     if ((vcc->qos.aal == ATM_AAL0) && (skb_len % ATM_CELL_PAYLOAD)) {
1666
1667         /* this simply NUKES the PCA board */
1668         DPRINTK(2, "incomplete tx AAL0 PDU on device %s\n", fore200e->name);
1669         tx_copy = 1;
1670         tx_len  = ((skb_len / ATM_CELL_PAYLOAD) + 1) * ATM_CELL_PAYLOAD;
1671     }
1672     
1673     if (tx_copy) {
1674         data = kmalloc(tx_len, GFP_ATOMIC | GFP_DMA);
1675         if (data == NULL) {
1676             if (vcc->pop) {
1677                 vcc->pop(vcc, skb);
1678             }
1679             else {
1680                 dev_kfree_skb_any(skb);
1681             }
1682             return -ENOMEM;
1683         }
1684
1685         memcpy(data, skb_data, skb_len);
1686         if (skb_len < tx_len)
1687             memset(data + skb_len, 0x00, tx_len - skb_len);
1688     }
1689     else {
1690         data = skb_data;
1691     }
1692
1693     vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1694     ASSERT(vc_map->vcc == vcc);
1695
1696   retry_here:
1697
1698     spin_lock_irqsave(&fore200e->q_lock, flags);
1699
1700     entry = &txq->host_entry[ txq->head ];
1701
1702     if ((*entry->status != STATUS_FREE) || (txq->txing >= QUEUE_SIZE_TX - 2)) {
1703
1704         /* try to free completed tx queue entries */
1705         fore200e_tx_irq(fore200e);
1706
1707         if (*entry->status != STATUS_FREE) {
1708
1709             spin_unlock_irqrestore(&fore200e->q_lock, flags);
1710
1711             /* retry once again? */
1712             if (--retry > 0) {
1713                 udelay(50);
1714                 goto retry_here;
1715             }
1716
1717             atomic_inc(&vcc->stats->tx_err);
1718
1719             fore200e->tx_sat++;
1720             DPRINTK(2, "tx queue of device %s is saturated, PDU dropped - heartbeat is %08x\n",
1721                     fore200e->name, fore200e->cp_queues->heartbeat);
1722             if (vcc->pop) {
1723                 vcc->pop(vcc, skb);
1724             }
1725             else {
1726                 dev_kfree_skb_any(skb);
1727             }
1728
1729             if (tx_copy)
1730                 kfree(data);
1731
1732             return -ENOBUFS;
1733         }
1734     }
1735
1736     entry->incarn = vc_map->incarn;
1737     entry->vc_map = vc_map;
1738     entry->skb    = skb;
1739     entry->data   = tx_copy ? data : NULL;
1740
1741     tpd = entry->tpd;
1742     tpd->tsd[ 0 ].buffer = fore200e->bus->dma_map(fore200e, data, tx_len, DMA_TO_DEVICE);
1743     tpd->tsd[ 0 ].length = tx_len;
1744
1745     FORE200E_NEXT_ENTRY(txq->head, QUEUE_SIZE_TX);
1746     txq->txing++;
1747
1748     /* The dma_map call above implies a dma_sync so the device can use it,
1749      * thus no explicit dma_sync call is necessary here.
1750      */
1751     
1752     DPRINTK(3, "tx on %d.%d.%d:%d, len = %u (%u)\n", 
1753             vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1754             tpd->tsd[0].length, skb_len);
1755
1756     if (skb_len < fore200e_vcc->tx_min_pdu)
1757         fore200e_vcc->tx_min_pdu = skb_len;
1758     if (skb_len > fore200e_vcc->tx_max_pdu)
1759         fore200e_vcc->tx_max_pdu = skb_len;
1760     fore200e_vcc->tx_pdu++;
1761
1762     /* set tx rate control information */
1763     tpd->rate.data_cells = fore200e_vcc->rate.data_cells;
1764     tpd->rate.idle_cells = fore200e_vcc->rate.idle_cells;
1765
1766     if (cell_header) {
1767         tpd->atm_header.clp = (*cell_header & ATM_HDR_CLP);
1768         tpd->atm_header.plt = (*cell_header & ATM_HDR_PTI_MASK) >> ATM_HDR_PTI_SHIFT;
1769         tpd->atm_header.vci = (*cell_header & ATM_HDR_VCI_MASK) >> ATM_HDR_VCI_SHIFT;
1770         tpd->atm_header.vpi = (*cell_header & ATM_HDR_VPI_MASK) >> ATM_HDR_VPI_SHIFT;
1771         tpd->atm_header.gfc = (*cell_header & ATM_HDR_GFC_MASK) >> ATM_HDR_GFC_SHIFT;
1772     }
1773     else {
1774         /* set the ATM header, common to all cells conveying the PDU */
1775         tpd->atm_header.clp = 0;
1776         tpd->atm_header.plt = 0;
1777         tpd->atm_header.vci = vcc->vci;
1778         tpd->atm_header.vpi = vcc->vpi;
1779         tpd->atm_header.gfc = 0;
1780     }
1781
1782     tpd->spec.length = tx_len;
1783     tpd->spec.nseg   = 1;
1784     tpd->spec.aal    = fore200e_atm2fore_aal(vcc->qos.aal);
1785     tpd->spec.intr   = 1;
1786
1787     tpd_haddr.size  = sizeof(struct tpd) / (1<<TPD_HADDR_SHIFT);  /* size is expressed in 32 byte blocks */
1788     tpd_haddr.pad   = 0;
1789     tpd_haddr.haddr = entry->tpd_dma >> TPD_HADDR_SHIFT;          /* shift the address, as we are in a bitfield */
1790
1791     *entry->status = STATUS_PENDING;
1792     fore200e->bus->write(*(u32*)&tpd_haddr, (u32 __iomem *)&entry->cp_entry->tpd_haddr);
1793
1794     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1795
1796     return 0;
1797 }
1798
1799
1800 static int
1801 fore200e_getstats(struct fore200e* fore200e)
1802 {
1803     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
1804     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1805     struct stats_opcode     opcode;
1806     int                     ok;
1807     u32                     stats_dma_addr;
1808
1809     if (fore200e->stats == NULL) {
1810         fore200e->stats = kzalloc(sizeof(struct stats), GFP_KERNEL | GFP_DMA);
1811         if (fore200e->stats == NULL)
1812             return -ENOMEM;
1813     }
1814     
1815     stats_dma_addr = fore200e->bus->dma_map(fore200e, fore200e->stats,
1816                                             sizeof(struct stats), DMA_FROM_DEVICE);
1817     
1818     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1819
1820     opcode.opcode = OPCODE_GET_STATS;
1821     opcode.pad    = 0;
1822
1823     fore200e->bus->write(stats_dma_addr, &entry->cp_entry->cmd.stats_block.stats_haddr);
1824     
1825     *entry->status = STATUS_PENDING;
1826
1827     fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.stats_block.opcode);
1828
1829     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1830
1831     *entry->status = STATUS_FREE;
1832
1833     fore200e->bus->dma_unmap(fore200e, stats_dma_addr, sizeof(struct stats), DMA_FROM_DEVICE);
1834     
1835     if (ok == 0) {
1836         printk(FORE200E "unable to get statistics from device %s\n", fore200e->name);
1837         return -EIO;
1838     }
1839
1840     return 0;
1841 }
1842
1843
1844 static int
1845 fore200e_getsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, int optlen)
1846 {
1847     /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1848
1849     DPRINTK(2, "getsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1850             vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1851
1852     return -EINVAL;
1853 }
1854
1855
1856 static int
1857 fore200e_setsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, int optlen)
1858 {
1859     /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1860     
1861     DPRINTK(2, "setsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1862             vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1863     
1864     return -EINVAL;
1865 }
1866
1867
1868 #if 0 /* currently unused */
1869 static int
1870 fore200e_get_oc3(struct fore200e* fore200e, struct oc3_regs* regs)
1871 {
1872     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
1873     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1874     struct oc3_opcode       opcode;
1875     int                     ok;
1876     u32                     oc3_regs_dma_addr;
1877
1878     oc3_regs_dma_addr = fore200e->bus->dma_map(fore200e, regs, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1879
1880     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1881
1882     opcode.opcode = OPCODE_GET_OC3;
1883     opcode.reg    = 0;
1884     opcode.value  = 0;
1885     opcode.mask   = 0;
1886
1887     fore200e->bus->write(oc3_regs_dma_addr, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1888     
1889     *entry->status = STATUS_PENDING;
1890
1891     fore200e->bus->write(*(u32*)&opcode, (u32*)&entry->cp_entry->cmd.oc3_block.opcode);
1892
1893     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1894
1895     *entry->status = STATUS_FREE;
1896
1897     fore200e->bus->dma_unmap(fore200e, oc3_regs_dma_addr, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1898     
1899     if (ok == 0) {
1900         printk(FORE200E "unable to get OC-3 regs of device %s\n", fore200e->name);
1901         return -EIO;
1902     }
1903
1904     return 0;
1905 }
1906 #endif
1907
1908
1909 static int
1910 fore200e_set_oc3(struct fore200e* fore200e, u32 reg, u32 value, u32 mask)
1911 {
1912     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
1913     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1914     struct oc3_opcode       opcode;
1915     int                     ok;
1916
1917     DPRINTK(2, "set OC-3 reg = 0x%02x, value = 0x%02x, mask = 0x%02x\n", reg, value, mask);
1918
1919     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1920
1921     opcode.opcode = OPCODE_SET_OC3;
1922     opcode.reg    = reg;
1923     opcode.value  = value;
1924     opcode.mask   = mask;
1925
1926     fore200e->bus->write(0, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1927     
1928     *entry->status = STATUS_PENDING;
1929
1930     fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.oc3_block.opcode);
1931
1932     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1933
1934     *entry->status = STATUS_FREE;
1935
1936     if (ok == 0) {
1937         printk(FORE200E "unable to set OC-3 reg 0x%02x of device %s\n", reg, fore200e->name);
1938         return -EIO;
1939     }
1940
1941     return 0;
1942 }
1943
1944
1945 static int
1946 fore200e_setloop(struct fore200e* fore200e, int loop_mode)
1947 {
1948     u32 mct_value, mct_mask;
1949     int error;
1950
1951     if (!capable(CAP_NET_ADMIN))
1952         return -EPERM;
1953     
1954     switch (loop_mode) {
1955
1956     case ATM_LM_NONE:
1957         mct_value = 0; 
1958         mct_mask  = SUNI_MCT_DLE | SUNI_MCT_LLE;
1959         break;
1960         
1961     case ATM_LM_LOC_PHY:
1962         mct_value = mct_mask = SUNI_MCT_DLE;
1963         break;
1964
1965     case ATM_LM_RMT_PHY:
1966         mct_value = mct_mask = SUNI_MCT_LLE;
1967         break;
1968
1969     default:
1970         return -EINVAL;
1971     }
1972
1973     error = fore200e_set_oc3(fore200e, SUNI_MCT, mct_value, mct_mask);
1974     if (error == 0)
1975         fore200e->loop_mode = loop_mode;
1976
1977     return error;
1978 }
1979
1980
1981 static int
1982 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
1983 {
1984     struct sonet_stats tmp;
1985
1986     if (fore200e_getstats(fore200e) < 0)
1987         return -EIO;
1988
1989     tmp.section_bip = be32_to_cpu(fore200e->stats->oc3.section_bip8_errors);
1990     tmp.line_bip    = be32_to_cpu(fore200e->stats->oc3.line_bip24_errors);
1991     tmp.path_bip    = be32_to_cpu(fore200e->stats->oc3.path_bip8_errors);
1992     tmp.line_febe   = be32_to_cpu(fore200e->stats->oc3.line_febe_errors);
1993     tmp.path_febe   = be32_to_cpu(fore200e->stats->oc3.path_febe_errors);
1994     tmp.corr_hcs    = be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors);
1995     tmp.uncorr_hcs  = be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors);
1996     tmp.tx_cells    = be32_to_cpu(fore200e->stats->aal0.cells_transmitted)  +
1997                       be32_to_cpu(fore200e->stats->aal34.cells_transmitted) +
1998                       be32_to_cpu(fore200e->stats->aal5.cells_transmitted);
1999     tmp.rx_cells    = be32_to_cpu(fore200e->stats->aal0.cells_received)     +
2000                       be32_to_cpu(fore200e->stats->aal34.cells_received)    +
2001                       be32_to_cpu(fore200e->stats->aal5.cells_received);
2002
2003     if (arg)
2004         return copy_to_user(arg, &tmp, sizeof(struct sonet_stats)) ? -EFAULT : 0;       
2005     
2006     return 0;
2007 }
2008
2009
2010 static int
2011 fore200e_ioctl(struct atm_dev* dev, unsigned int cmd, void __user * arg)
2012 {
2013     struct fore200e* fore200e = FORE200E_DEV(dev);
2014     
2015     DPRINTK(2, "ioctl cmd = 0x%x (%u), arg = 0x%p (%lu)\n", cmd, cmd, arg, (unsigned long)arg);
2016
2017     switch (cmd) {
2018
2019     case SONET_GETSTAT:
2020         return fore200e_fetch_stats(fore200e, (struct sonet_stats __user *)arg);
2021
2022     case SONET_GETDIAG:
2023         return put_user(0, (int __user *)arg) ? -EFAULT : 0;
2024
2025     case ATM_SETLOOP:
2026         return fore200e_setloop(fore200e, (int)(unsigned long)arg);
2027
2028     case ATM_GETLOOP:
2029         return put_user(fore200e->loop_mode, (int __user *)arg) ? -EFAULT : 0;
2030
2031     case ATM_QUERYLOOP:
2032         return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY, (int __user *)arg) ? -EFAULT : 0;
2033     }
2034
2035     return -ENOSYS; /* not implemented */
2036 }
2037
2038
2039 static int
2040 fore200e_change_qos(struct atm_vcc* vcc,struct atm_qos* qos, int flags)
2041 {
2042     struct fore200e_vcc* fore200e_vcc = FORE200E_VCC(vcc);
2043     struct fore200e*     fore200e     = FORE200E_DEV(vcc->dev);
2044
2045     if (!test_bit(ATM_VF_READY, &vcc->flags)) {
2046         DPRINTK(1, "VC %d.%d.%d not ready for QoS change\n", vcc->itf, vcc->vpi, vcc->vpi);
2047         return -EINVAL;
2048     }
2049
2050     DPRINTK(2, "change_qos %d.%d.%d, "
2051             "(tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
2052             "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d), flags = 0x%x\n"
2053             "available_cell_rate = %u",
2054             vcc->itf, vcc->vpi, vcc->vci,
2055             fore200e_traffic_class[ qos->txtp.traffic_class ],
2056             qos->txtp.min_pcr, qos->txtp.max_pcr, qos->txtp.max_cdv, qos->txtp.max_sdu,
2057             fore200e_traffic_class[ qos->rxtp.traffic_class ],
2058             qos->rxtp.min_pcr, qos->rxtp.max_pcr, qos->rxtp.max_cdv, qos->rxtp.max_sdu,
2059             flags, fore200e->available_cell_rate);
2060
2061     if ((qos->txtp.traffic_class == ATM_CBR) && (qos->txtp.max_pcr > 0)) {
2062
2063         mutex_lock(&fore200e->rate_mtx);
2064         if (fore200e->available_cell_rate + vcc->qos.txtp.max_pcr < qos->txtp.max_pcr) {
2065             mutex_unlock(&fore200e->rate_mtx);
2066             return -EAGAIN;
2067         }
2068
2069         fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
2070         fore200e->available_cell_rate -= qos->txtp.max_pcr;
2071
2072         mutex_unlock(&fore200e->rate_mtx);
2073         
2074         memcpy(&vcc->qos, qos, sizeof(struct atm_qos));
2075         
2076         /* update rate control parameters */
2077         fore200e_rate_ctrl(qos, &fore200e_vcc->rate);
2078
2079         set_bit(ATM_VF_HASQOS, &vcc->flags);
2080
2081         return 0;
2082     }
2083     
2084     return -EINVAL;
2085 }
2086     
2087
2088 static int __devinit
2089 fore200e_irq_request(struct fore200e* fore200e)
2090 {
2091     if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
2092
2093         printk(FORE200E "unable to reserve IRQ %s for device %s\n",
2094                fore200e_irq_itoa(fore200e->irq), fore200e->name);
2095         return -EBUSY;
2096     }
2097
2098     printk(FORE200E "IRQ %s reserved for device %s\n",
2099            fore200e_irq_itoa(fore200e->irq), fore200e->name);
2100
2101 #ifdef FORE200E_USE_TASKLET
2102     tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
2103     tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
2104 #endif
2105
2106     fore200e->state = FORE200E_STATE_IRQ;
2107     return 0;
2108 }
2109
2110
2111 static int __devinit
2112 fore200e_get_esi(struct fore200e* fore200e)
2113 {
2114     struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL | GFP_DMA);
2115     int ok, i;
2116
2117     if (!prom)
2118         return -ENOMEM;
2119
2120     ok = fore200e->bus->prom_read(fore200e, prom);
2121     if (ok < 0) {
2122         kfree(prom);
2123         return -EBUSY;
2124     }
2125         
2126     printk(FORE200E "device %s, rev. %c, S/N: %d, ESI: %02x:%02x:%02x:%02x:%02x:%02x\n", 
2127            fore200e->name, 
2128            (prom->hw_revision & 0xFF) + '@',    /* probably meaningless with SBA boards */
2129            prom->serial_number & 0xFFFF,
2130            prom->mac_addr[ 2 ], prom->mac_addr[ 3 ], prom->mac_addr[ 4 ],
2131            prom->mac_addr[ 5 ], prom->mac_addr[ 6 ], prom->mac_addr[ 7 ]);
2132         
2133     for (i = 0; i < ESI_LEN; i++) {
2134         fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
2135     }
2136     
2137     kfree(prom);
2138
2139     return 0;
2140 }
2141
2142
2143 static int __devinit
2144 fore200e_alloc_rx_buf(struct fore200e* fore200e)
2145 {
2146     int scheme, magn, nbr, size, i;
2147
2148     struct host_bsq* bsq;
2149     struct buffer*   buffer;
2150
2151     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2152         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2153
2154             bsq = &fore200e->host_bsq[ scheme ][ magn ];
2155
2156             nbr  = fore200e_rx_buf_nbr[ scheme ][ magn ];
2157             size = fore200e_rx_buf_size[ scheme ][ magn ];
2158
2159             DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
2160
2161             /* allocate the array of receive buffers */
2162             buffer = bsq->buffer = kzalloc(nbr * sizeof(struct buffer), GFP_KERNEL);
2163
2164             if (buffer == NULL)
2165                 return -ENOMEM;
2166
2167             bsq->freebuf = NULL;
2168
2169             for (i = 0; i < nbr; i++) {
2170
2171                 buffer[ i ].scheme = scheme;
2172                 buffer[ i ].magn   = magn;
2173 #ifdef FORE200E_BSQ_DEBUG
2174                 buffer[ i ].index  = i;
2175                 buffer[ i ].supplied = 0;
2176 #endif
2177
2178                 /* allocate the receive buffer body */
2179                 if (fore200e_chunk_alloc(fore200e,
2180                                          &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2181                                          DMA_FROM_DEVICE) < 0) {
2182                     
2183                     while (i > 0)
2184                         fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2185                     kfree(buffer);
2186                     
2187                     return -ENOMEM;
2188                 }
2189
2190                 /* insert the buffer into the free buffer list */
2191                 buffer[ i ].next = bsq->freebuf;
2192                 bsq->freebuf = &buffer[ i ];
2193             }
2194             /* all the buffers are free, initially */
2195             bsq->freebuf_count = nbr;
2196
2197 #ifdef FORE200E_BSQ_DEBUG
2198             bsq_audit(3, bsq, scheme, magn);
2199 #endif
2200         }
2201     }
2202
2203     fore200e->state = FORE200E_STATE_ALLOC_BUF;
2204     return 0;
2205 }
2206
2207
2208 static int __devinit
2209 fore200e_init_bs_queue(struct fore200e* fore200e)
2210 {
2211     int scheme, magn, i;
2212
2213     struct host_bsq*     bsq;
2214     struct cp_bsq_entry __iomem * cp_entry;
2215
2216     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2217         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2218
2219             DPRINTK(2, "buffer supply queue %d / %d is being initialized\n", scheme, magn);
2220
2221             bsq = &fore200e->host_bsq[ scheme ][ magn ];
2222
2223             /* allocate and align the array of status words */
2224             if (fore200e->bus->dma_chunk_alloc(fore200e,
2225                                                &bsq->status,
2226                                                sizeof(enum status), 
2227                                                QUEUE_SIZE_BS,
2228                                                fore200e->bus->status_alignment) < 0) {
2229                 return -ENOMEM;
2230             }
2231
2232             /* allocate and align the array of receive buffer descriptors */
2233             if (fore200e->bus->dma_chunk_alloc(fore200e,
2234                                                &bsq->rbd_block,
2235                                                sizeof(struct rbd_block),
2236                                                QUEUE_SIZE_BS,
2237                                                fore200e->bus->descr_alignment) < 0) {
2238                 
2239                 fore200e->bus->dma_chunk_free(fore200e, &bsq->status);
2240                 return -ENOMEM;
2241             }
2242             
2243             /* get the base address of the cp resident buffer supply queue entries */
2244             cp_entry = fore200e->virt_base + 
2245                        fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2246             
2247             /* fill the host resident and cp resident buffer supply queue entries */
2248             for (i = 0; i < QUEUE_SIZE_BS; i++) {
2249                 
2250                 bsq->host_entry[ i ].status = 
2251                                      FORE200E_INDEX(bsq->status.align_addr, enum status, i);
2252                 bsq->host_entry[ i ].rbd_block =
2253                                      FORE200E_INDEX(bsq->rbd_block.align_addr, struct rbd_block, i);
2254                 bsq->host_entry[ i ].rbd_block_dma =
2255                                      FORE200E_DMA_INDEX(bsq->rbd_block.dma_addr, struct rbd_block, i);
2256                 bsq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2257                 
2258                 *bsq->host_entry[ i ].status = STATUS_FREE;
2259                 
2260                 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i), 
2261                                      &cp_entry[ i ].status_haddr);
2262             }
2263         }
2264     }
2265
2266     fore200e->state = FORE200E_STATE_INIT_BSQ;
2267     return 0;
2268 }
2269
2270
2271 static int __devinit
2272 fore200e_init_rx_queue(struct fore200e* fore200e)
2273 {
2274     struct host_rxq*     rxq =  &fore200e->host_rxq;
2275     struct cp_rxq_entry __iomem * cp_entry;
2276     int i;
2277
2278     DPRINTK(2, "receive queue is being initialized\n");
2279
2280     /* allocate and align the array of status words */
2281     if (fore200e->bus->dma_chunk_alloc(fore200e,
2282                                        &rxq->status,
2283                                        sizeof(enum status), 
2284                                        QUEUE_SIZE_RX,
2285                                        fore200e->bus->status_alignment) < 0) {
2286         return -ENOMEM;
2287     }
2288
2289     /* allocate and align the array of receive PDU descriptors */
2290     if (fore200e->bus->dma_chunk_alloc(fore200e,
2291                                        &rxq->rpd,
2292                                        sizeof(struct rpd), 
2293                                        QUEUE_SIZE_RX,
2294                                        fore200e->bus->descr_alignment) < 0) {
2295         
2296         fore200e->bus->dma_chunk_free(fore200e, &rxq->status);
2297         return -ENOMEM;
2298     }
2299
2300     /* get the base address of the cp resident rx queue entries */
2301     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2302
2303     /* fill the host resident and cp resident rx entries */
2304     for (i=0; i < QUEUE_SIZE_RX; i++) {
2305         
2306         rxq->host_entry[ i ].status = 
2307                              FORE200E_INDEX(rxq->status.align_addr, enum status, i);
2308         rxq->host_entry[ i ].rpd = 
2309                              FORE200E_INDEX(rxq->rpd.align_addr, struct rpd, i);
2310         rxq->host_entry[ i ].rpd_dma = 
2311                              FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i);
2312         rxq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2313
2314         *rxq->host_entry[ i ].status = STATUS_FREE;
2315
2316         fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i), 
2317                              &cp_entry[ i ].status_haddr);
2318
2319         fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2320                              &cp_entry[ i ].rpd_haddr);
2321     }
2322
2323     /* set the head entry of the queue */
2324     rxq->head = 0;
2325
2326     fore200e->state = FORE200E_STATE_INIT_RXQ;
2327     return 0;
2328 }
2329
2330
2331 static int __devinit
2332 fore200e_init_tx_queue(struct fore200e* fore200e)
2333 {
2334     struct host_txq*     txq =  &fore200e->host_txq;
2335     struct cp_txq_entry __iomem * cp_entry;
2336     int i;
2337
2338     DPRINTK(2, "transmit queue is being initialized\n");
2339
2340     /* allocate and align the array of status words */
2341     if (fore200e->bus->dma_chunk_alloc(fore200e,
2342                                        &txq->status,
2343                                        sizeof(enum status), 
2344                                        QUEUE_SIZE_TX,
2345                                        fore200e->bus->status_alignment) < 0) {
2346         return -ENOMEM;
2347     }
2348
2349     /* allocate and align the array of transmit PDU descriptors */
2350     if (fore200e->bus->dma_chunk_alloc(fore200e,
2351                                        &txq->tpd,
2352                                        sizeof(struct tpd), 
2353                                        QUEUE_SIZE_TX,
2354                                        fore200e->bus->descr_alignment) < 0) {
2355         
2356         fore200e->bus->dma_chunk_free(fore200e, &txq->status);
2357         return -ENOMEM;
2358     }
2359
2360     /* get the base address of the cp resident tx queue entries */
2361     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2362
2363     /* fill the host resident and cp resident tx entries */
2364     for (i=0; i < QUEUE_SIZE_TX; i++) {
2365         
2366         txq->host_entry[ i ].status = 
2367                              FORE200E_INDEX(txq->status.align_addr, enum status, i);
2368         txq->host_entry[ i ].tpd = 
2369                              FORE200E_INDEX(txq->tpd.align_addr, struct tpd, i);
2370         txq->host_entry[ i ].tpd_dma  = 
2371                              FORE200E_DMA_INDEX(txq->tpd.dma_addr, struct tpd, i);
2372         txq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2373
2374         *txq->host_entry[ i ].status = STATUS_FREE;
2375         
2376         fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i), 
2377                              &cp_entry[ i ].status_haddr);
2378         
2379         /* although there is a one-to-one mapping of tx queue entries and tpds,
2380            we do not write here the DMA (physical) base address of each tpd into
2381            the related cp resident entry, because the cp relies on this write
2382            operation to detect that a new pdu has been submitted for tx */
2383     }
2384
2385     /* set the head and tail entries of the queue */
2386     txq->head = 0;
2387     txq->tail = 0;
2388
2389     fore200e->state = FORE200E_STATE_INIT_TXQ;
2390     return 0;
2391 }
2392
2393
2394 static int __devinit
2395 fore200e_init_cmd_queue(struct fore200e* fore200e)
2396 {
2397     struct host_cmdq*     cmdq =  &fore200e->host_cmdq;
2398     struct cp_cmdq_entry __iomem * cp_entry;
2399     int i;
2400
2401     DPRINTK(2, "command queue is being initialized\n");
2402
2403     /* allocate and align the array of status words */
2404     if (fore200e->bus->dma_chunk_alloc(fore200e,
2405                                        &cmdq->status,
2406                                        sizeof(enum status), 
2407                                        QUEUE_SIZE_CMD,
2408                                        fore200e->bus->status_alignment) < 0) {
2409         return -ENOMEM;
2410     }
2411     
2412     /* get the base address of the cp resident cmd queue entries */
2413     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2414
2415     /* fill the host resident and cp resident cmd entries */
2416     for (i=0; i < QUEUE_SIZE_CMD; i++) {
2417         
2418         cmdq->host_entry[ i ].status   = 
2419                               FORE200E_INDEX(cmdq->status.align_addr, enum status, i);
2420         cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2421
2422         *cmdq->host_entry[ i ].status = STATUS_FREE;
2423
2424         fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i), 
2425                              &cp_entry[ i ].status_haddr);
2426     }
2427
2428     /* set the head entry of the queue */
2429     cmdq->head = 0;
2430
2431     fore200e->state = FORE200E_STATE_INIT_CMDQ;
2432     return 0;
2433 }
2434
2435
2436 static void __devinit
2437 fore200e_param_bs_queue(struct fore200e* fore200e,
2438                         enum buffer_scheme scheme, enum buffer_magn magn,
2439                         int queue_length, int pool_size, int supply_blksize)
2440 {
2441     struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2442
2443     fore200e->bus->write(queue_length,                           &bs_spec->queue_length);
2444     fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2445     fore200e->bus->write(pool_size,                              &bs_spec->pool_size);
2446     fore200e->bus->write(supply_blksize,                         &bs_spec->supply_blksize);
2447 }
2448
2449
2450 static int __devinit
2451 fore200e_initialize(struct fore200e* fore200e)
2452 {
2453     struct cp_queues __iomem * cpq;
2454     int               ok, scheme, magn;
2455
2456     DPRINTK(2, "device %s being initialized\n", fore200e->name);
2457
2458     mutex_init(&fore200e->rate_mtx);
2459     spin_lock_init(&fore200e->q_lock);
2460
2461     cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2462
2463     /* enable cp to host interrupts */
2464     fore200e->bus->write(1, &cpq->imask);
2465
2466     if (fore200e->bus->irq_enable)
2467         fore200e->bus->irq_enable(fore200e);
2468     
2469     fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2470
2471     fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2472     fore200e->bus->write(QUEUE_SIZE_RX,  &cpq->init.rx_queue_len);
2473     fore200e->bus->write(QUEUE_SIZE_TX,  &cpq->init.tx_queue_len);
2474
2475     fore200e->bus->write(RSD_EXTENSION,  &cpq->init.rsd_extension);
2476     fore200e->bus->write(TSD_EXTENSION,  &cpq->init.tsd_extension);
2477
2478     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++)
2479         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++)
2480             fore200e_param_bs_queue(fore200e, scheme, magn,
2481                                     QUEUE_SIZE_BS, 
2482                                     fore200e_rx_buf_nbr[ scheme ][ magn ],
2483                                     RBD_BLK_SIZE);
2484
2485     /* issue the initialize command */
2486     fore200e->bus->write(STATUS_PENDING,    &cpq->init.status);
2487     fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2488
2489     ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2490     if (ok == 0) {
2491         printk(FORE200E "device %s initialization failed\n", fore200e->name);
2492         return -ENODEV;
2493     }
2494
2495     printk(FORE200E "device %s initialized\n", fore200e->name);
2496
2497     fore200e->state = FORE200E_STATE_INITIALIZE;
2498     return 0;
2499 }
2500
2501
2502 static void __devinit
2503 fore200e_monitor_putc(struct fore200e* fore200e, char c)
2504 {
2505     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2506
2507 #if 0
2508     printk("%c", c);
2509 #endif
2510     fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2511 }
2512
2513
2514 static int __devinit
2515 fore200e_monitor_getc(struct fore200e* fore200e)
2516 {
2517     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2518     unsigned long      timeout = jiffies + msecs_to_jiffies(50);
2519     int                c;
2520
2521     while (time_before(jiffies, timeout)) {
2522
2523         c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2524
2525         if (c & FORE200E_CP_MONITOR_UART_AVAIL) {
2526
2527             fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2528 #if 0
2529             printk("%c", c & 0xFF);
2530 #endif
2531             return c & 0xFF;
2532         }
2533     }
2534
2535     return -1;
2536 }
2537
2538
2539 static void __devinit
2540 fore200e_monitor_puts(struct fore200e* fore200e, char* str)
2541 {
2542     while (*str) {
2543
2544         /* the i960 monitor doesn't accept any new character if it has something to say */
2545         while (fore200e_monitor_getc(fore200e) >= 0);
2546         
2547         fore200e_monitor_putc(fore200e, *str++);
2548     }
2549
2550     while (fore200e_monitor_getc(fore200e) >= 0);
2551 }
2552
2553 #ifdef __LITTLE_ENDIAN
2554 #define FW_EXT ".bin"
2555 #else
2556 #define FW_EXT "_ecd.bin2"
2557 #endif
2558
2559 static int __devinit
2560 fore200e_load_and_start_fw(struct fore200e* fore200e)
2561 {
2562     const struct firmware *firmware;
2563     struct device *device;
2564     struct fw_header *fw_header;
2565     const __le32 *fw_data;
2566     u32 fw_size;
2567     u32 __iomem *load_addr;
2568     char buf[48];
2569     int err = -ENODEV;
2570
2571     if (strcmp(fore200e->bus->model_name, "PCA-200E") == 0)
2572         device = &((struct pci_dev *) fore200e->bus_dev)->dev;
2573 #ifdef CONFIG_SBUS
2574     else if (strcmp(fore200e->bus->model_name, "SBA-200E") == 0)
2575         device = &((struct sbus_dev *) fore200e->bus_dev)->ofdev.dev;
2576 #endif
2577     else
2578         return err;
2579
2580     sprintf(buf, "%s%s", fore200e->bus->proc_name, FW_EXT);
2581     if (request_firmware(&firmware, buf, device) == 1) {
2582         printk(FORE200E "missing %s firmware image\n", fore200e->bus->model_name);
2583         return err;
2584     }
2585
2586     fw_data = (__le32 *) firmware->data;
2587     fw_size = firmware->size / sizeof(u32);
2588     fw_header = (struct fw_header *) firmware->data;
2589     load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2590
2591     DPRINTK(2, "device %s firmware being loaded at 0x%p (%d words)\n",
2592             fore200e->name, load_addr, fw_size);
2593
2594     if (le32_to_cpu(fw_header->magic) != FW_HEADER_MAGIC) {
2595         printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2596         goto release;
2597     }
2598
2599     for (; fw_size--; fw_data++, load_addr++)
2600         fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2601
2602     DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2603
2604 #if defined(__sparc_v9__)
2605     /* reported to be required by SBA cards on some sparc64 hosts */
2606     fore200e_spin(100);
2607 #endif
2608
2609     sprintf(buf, "\rgo %x\r", le32_to_cpu(fw_header->start_offset));
2610     fore200e_monitor_puts(fore200e, buf);
2611
2612     if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2613         printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2614         goto release;
2615     }
2616
2617     printk(FORE200E "device %s firmware started\n", fore200e->name);
2618
2619     fore200e->state = FORE200E_STATE_START_FW;
2620     err = 0;
2621
2622 release:
2623     release_firmware(firmware);
2624     return err;
2625 }
2626
2627
2628 static int __devinit
2629 fore200e_register(struct fore200e* fore200e)
2630 {
2631     struct atm_dev* atm_dev;
2632
2633     DPRINTK(2, "device %s being registered\n", fore200e->name);
2634
2635     atm_dev = atm_dev_register(fore200e->bus->proc_name, &fore200e_ops, -1,
2636       NULL); 
2637     if (atm_dev == NULL) {
2638         printk(FORE200E "unable to register device %s\n", fore200e->name);
2639         return -ENODEV;
2640     }
2641
2642     atm_dev->dev_data = fore200e;
2643     fore200e->atm_dev = atm_dev;
2644
2645     atm_dev->ci_range.vpi_bits = FORE200E_VPI_BITS;
2646     atm_dev->ci_range.vci_bits = FORE200E_VCI_BITS;
2647
2648     fore200e->available_cell_rate = ATM_OC3_PCR;
2649
2650     fore200e->state = FORE200E_STATE_REGISTER;
2651     return 0;
2652 }
2653
2654
2655 static int __devinit
2656 fore200e_init(struct fore200e* fore200e)
2657 {
2658     if (fore200e_register(fore200e) < 0)
2659         return -ENODEV;
2660     
2661     if (fore200e->bus->configure(fore200e) < 0)
2662         return -ENODEV;
2663
2664     if (fore200e->bus->map(fore200e) < 0)
2665         return -ENODEV;
2666
2667     if (fore200e_reset(fore200e, 1) < 0)
2668         return -ENODEV;
2669
2670     if (fore200e_load_and_start_fw(fore200e) < 0)
2671         return -ENODEV;
2672
2673     if (fore200e_initialize(fore200e) < 0)
2674         return -ENODEV;
2675
2676     if (fore200e_init_cmd_queue(fore200e) < 0)
2677         return -ENOMEM;
2678
2679     if (fore200e_init_tx_queue(fore200e) < 0)
2680         return -ENOMEM;
2681
2682     if (fore200e_init_rx_queue(fore200e) < 0)
2683         return -ENOMEM;
2684
2685     if (fore200e_init_bs_queue(fore200e) < 0)
2686         return -ENOMEM;
2687
2688     if (fore200e_alloc_rx_buf(fore200e) < 0)
2689         return -ENOMEM;
2690
2691     if (fore200e_get_esi(fore200e) < 0)
2692         return -EIO;
2693
2694     if (fore200e_irq_request(fore200e) < 0)
2695         return -EBUSY;
2696
2697     fore200e_supply(fore200e);
2698
2699     /* all done, board initialization is now complete */
2700     fore200e->state = FORE200E_STATE_COMPLETE;
2701     return 0;
2702 }
2703
2704 #ifdef CONFIG_PCI
2705 static int __devinit
2706 fore200e_pca_detect(struct pci_dev *pci_dev, const struct pci_device_id *pci_ent)
2707 {
2708     const struct fore200e_bus* bus = (struct fore200e_bus*) pci_ent->driver_data;
2709     struct fore200e* fore200e;
2710     int err = 0;
2711     static int index = 0;
2712
2713     if (pci_enable_device(pci_dev)) {
2714         err = -EINVAL;
2715         goto out;
2716     }
2717     
2718     fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2719     if (fore200e == NULL) {
2720         err = -ENOMEM;
2721         goto out_disable;
2722     }
2723
2724     fore200e->bus       = bus;
2725     fore200e->bus_dev   = pci_dev;    
2726     fore200e->irq       = pci_dev->irq;
2727     fore200e->phys_base = pci_resource_start(pci_dev, 0);
2728
2729     sprintf(fore200e->name, "%s-%d", bus->model_name, index - 1);
2730
2731     pci_set_master(pci_dev);
2732
2733     printk(FORE200E "device %s found at 0x%lx, IRQ %s\n",
2734            fore200e->bus->model_name, 
2735            fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2736
2737     sprintf(fore200e->name, "%s-%d", bus->model_name, index);
2738
2739     err = fore200e_init(fore200e);
2740     if (err < 0) {
2741         fore200e_shutdown(fore200e);
2742         goto out_free;
2743     }
2744
2745     ++index;
2746     pci_set_drvdata(pci_dev, fore200e);
2747
2748 out:
2749     return err;
2750
2751 out_free:
2752     kfree(fore200e);
2753 out_disable:
2754     pci_disable_device(pci_dev);
2755     goto out;
2756 }
2757
2758
2759 static void __devexit fore200e_pca_remove_one(struct pci_dev *pci_dev)
2760 {
2761     struct fore200e *fore200e;
2762
2763     fore200e = pci_get_drvdata(pci_dev);
2764
2765     fore200e_shutdown(fore200e);
2766     kfree(fore200e);
2767     pci_disable_device(pci_dev);
2768 }
2769
2770
2771 static struct pci_device_id fore200e_pca_tbl[] = {
2772     { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_PCA200E, PCI_ANY_ID, PCI_ANY_ID,
2773       0, 0, (unsigned long) &fore200e_bus[0] },
2774     { 0, }
2775 };
2776
2777 MODULE_DEVICE_TABLE(pci, fore200e_pca_tbl);
2778
2779 static struct pci_driver fore200e_pca_driver = {
2780     .name =     "fore_200e",
2781     .probe =    fore200e_pca_detect,
2782     .remove =   __devexit_p(fore200e_pca_remove_one),
2783     .id_table = fore200e_pca_tbl,
2784 };
2785 #endif
2786
2787
2788 static int __init
2789 fore200e_module_init(void)
2790 {
2791     const struct fore200e_bus* bus;
2792     struct       fore200e*     fore200e;
2793     int                        index;
2794
2795     printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
2796
2797     /* for each configured bus interface */
2798     for (bus = fore200e_bus; bus->model_name; bus++) {
2799
2800         /* detect all boards present on that bus */
2801         for (index = 0; bus->detect && (fore200e = bus->detect(bus, index)); index++) {
2802             
2803             printk(FORE200E "device %s found at 0x%lx, IRQ %s\n",
2804                    fore200e->bus->model_name, 
2805                    fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2806
2807             sprintf(fore200e->name, "%s-%d", bus->model_name, index);
2808
2809             if (fore200e_init(fore200e) < 0) {
2810
2811                 fore200e_shutdown(fore200e);
2812                 break;
2813             }
2814
2815             list_add(&fore200e->entry, &fore200e_boards);
2816         }
2817     }
2818
2819 #ifdef CONFIG_PCI
2820     if (!pci_register_driver(&fore200e_pca_driver))
2821         return 0;
2822 #endif
2823
2824     if (!list_empty(&fore200e_boards))
2825         return 0;
2826
2827     return -ENODEV;
2828 }
2829
2830
2831 static void __exit
2832 fore200e_module_cleanup(void)
2833 {
2834     struct fore200e *fore200e, *next;
2835
2836 #ifdef CONFIG_PCI
2837     pci_unregister_driver(&fore200e_pca_driver);
2838 #endif
2839
2840     list_for_each_entry_safe(fore200e, next, &fore200e_boards, entry) {
2841         fore200e_shutdown(fore200e);
2842         kfree(fore200e);
2843     }
2844     DPRINTK(1, "module being removed\n");
2845 }
2846
2847
2848 static int
2849 fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
2850 {
2851     struct fore200e*     fore200e  = FORE200E_DEV(dev);
2852     struct fore200e_vcc* fore200e_vcc;
2853     struct atm_vcc*      vcc;
2854     int                  i, len, left = *pos;
2855     unsigned long        flags;
2856
2857     if (!left--) {
2858
2859         if (fore200e_getstats(fore200e) < 0)
2860             return -EIO;
2861
2862         len = sprintf(page,"\n"
2863                        " device:\n"
2864                        "   internal name:\t\t%s\n", fore200e->name);
2865
2866         /* print bus-specific information */
2867         if (fore200e->bus->proc_read)
2868             len += fore200e->bus->proc_read(fore200e, page + len);
2869         
2870         len += sprintf(page + len,
2871                 "   interrupt line:\t\t%s\n"
2872                 "   physical base address:\t0x%p\n"
2873                 "   virtual base address:\t0x%p\n"
2874                 "   factory address (ESI):\t%02x:%02x:%02x:%02x:%02x:%02x\n"
2875                 "   board serial number:\t\t%d\n\n",
2876                 fore200e_irq_itoa(fore200e->irq),
2877                 (void*)fore200e->phys_base,
2878                 fore200e->virt_base,
2879                 fore200e->esi[0], fore200e->esi[1], fore200e->esi[2],
2880                 fore200e->esi[3], fore200e->esi[4], fore200e->esi[5],
2881                 fore200e->esi[4] * 256 + fore200e->esi[5]);
2882
2883         return len;
2884     }
2885
2886     if (!left--)
2887         return sprintf(page,
2888                        "   free small bufs, scheme 1:\t%d\n"
2889                        "   free large bufs, scheme 1:\t%d\n"
2890                        "   free small bufs, scheme 2:\t%d\n"
2891                        "   free large bufs, scheme 2:\t%d\n",
2892                        fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2893                        fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2894                        fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2895                        fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2896
2897     if (!left--) {
2898         u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2899
2900         len = sprintf(page,"\n\n"
2901                       " cell processor:\n"
2902                       "   heartbeat state:\t\t");
2903         
2904         if (hb >> 16 != 0xDEAD)
2905             len += sprintf(page + len, "0x%08x\n", hb);
2906         else
2907             len += sprintf(page + len, "*** FATAL ERROR %04x ***\n", hb & 0xFFFF);
2908
2909         return len;
2910     }
2911
2912     if (!left--) {
2913         static const char* media_name[] = {
2914             "unshielded twisted pair",
2915             "multimode optical fiber ST",
2916             "multimode optical fiber SC",
2917             "single-mode optical fiber ST",
2918             "single-mode optical fiber SC",
2919             "unknown"
2920         };
2921
2922         static const char* oc3_mode[] = {
2923             "normal operation",
2924             "diagnostic loopback",
2925             "line loopback",
2926             "unknown"
2927         };
2928
2929         u32 fw_release     = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2930         u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2931         u32 oc3_revision   = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2932         u32 media_index    = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2933         u32 oc3_index;
2934
2935         if ((media_index < 0) || (media_index > 4))
2936             media_index = 5;
2937         
2938         switch (fore200e->loop_mode) {
2939             case ATM_LM_NONE:    oc3_index = 0;
2940                                  break;
2941             case ATM_LM_LOC_PHY: oc3_index = 1;
2942                                  break;
2943             case ATM_LM_RMT_PHY: oc3_index = 2;
2944                                  break;
2945             default:             oc3_index = 3;
2946         }
2947
2948         return sprintf(page,
2949                        "   firmware release:\t\t%d.%d.%d\n"
2950                        "   monitor release:\t\t%d.%d\n"
2951                        "   media type:\t\t\t%s\n"
2952                        "   OC-3 revision:\t\t0x%x\n"
2953                        "   OC-3 mode:\t\t\t%s",
2954                        fw_release >> 16, fw_release << 16 >> 24,  fw_release << 24 >> 24,
2955                        mon960_release >> 16, mon960_release << 16 >> 16,
2956                        media_name[ media_index ],
2957                        oc3_revision,
2958                        oc3_mode[ oc3_index ]);
2959     }
2960
2961     if (!left--) {
2962         struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2963
2964         return sprintf(page,
2965                        "\n\n"
2966                        " monitor:\n"
2967                        "   version number:\t\t%d\n"
2968                        "   boot status word:\t\t0x%08x\n",
2969                        fore200e->bus->read(&cp_monitor->mon_version),
2970                        fore200e->bus->read(&cp_monitor->bstat));
2971     }
2972
2973     if (!left--)
2974         return sprintf(page,
2975                        "\n"
2976                        " device statistics:\n"
2977                        "  4b5b:\n"
2978                        "     crc_header_errors:\t\t%10u\n"
2979                        "     framing_errors:\t\t%10u\n",
2980                        be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2981                        be32_to_cpu(fore200e->stats->phy.framing_errors));
2982     
2983     if (!left--)
2984         return sprintf(page, "\n"
2985                        "  OC-3:\n"
2986                        "     section_bip8_errors:\t%10u\n"
2987                        "     path_bip8_errors:\t\t%10u\n"
2988                        "     line_bip24_errors:\t\t%10u\n"
2989                        "     line_febe_errors:\t\t%10u\n"
2990                        "     path_febe_errors:\t\t%10u\n"
2991                        "     corr_hcs_errors:\t\t%10u\n"
2992                        "     ucorr_hcs_errors:\t\t%10u\n",
2993                        be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2994                        be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2995                        be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2996                        be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2997                        be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2998                        be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2999                        be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
3000
3001     if (!left--)
3002         return sprintf(page,"\n"
3003                        "   ATM:\t\t\t\t     cells\n"
3004                        "     TX:\t\t\t%10u\n"
3005                        "     RX:\t\t\t%10u\n"
3006                        "     vpi out of range:\t\t%10u\n"
3007                        "     vpi no conn:\t\t%10u\n"
3008                        "     vci out of range:\t\t%10u\n"
3009                        "     vci no conn:\t\t%10u\n",
3010                        be32_to_cpu(fore200e->stats->atm.cells_transmitted),
3011                        be32_to_cpu(fore200e->stats->atm.cells_received),
3012                        be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
3013                        be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
3014                        be32_to_cpu(fore200e->stats->atm.vci_bad_range),
3015                        be32_to_cpu(fore200e->stats->atm.vci_no_conn));
3016     
3017     if (!left--)
3018         return sprintf(page,"\n"
3019                        "   AAL0:\t\t\t     cells\n"
3020                        "     TX:\t\t\t%10u\n"
3021                        "     RX:\t\t\t%10u\n"
3022                        "     dropped:\t\t\t%10u\n",
3023                        be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
3024                        be32_to_cpu(fore200e->stats->aal0.cells_received),
3025                        be32_to_cpu(fore200e->stats->aal0.cells_dropped));
3026     
3027     if (!left--)
3028         return sprintf(page,"\n"
3029                        "   AAL3/4:\n"
3030                        "     SAR sublayer:\t\t     cells\n"
3031                        "       TX:\t\t\t%10u\n"
3032                        "       RX:\t\t\t%10u\n"
3033                        "       dropped:\t\t\t%10u\n"
3034                        "       CRC errors:\t\t%10u\n"
3035                        "       protocol errors:\t\t%10u\n\n"
3036                        "     CS  sublayer:\t\t      PDUs\n"
3037                        "       TX:\t\t\t%10u\n"
3038                        "       RX:\t\t\t%10u\n"
3039                        "       dropped:\t\t\t%10u\n"
3040                        "       protocol errors:\t\t%10u\n",
3041                        be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
3042                        be32_to_cpu(fore200e->stats->aal34.cells_received),
3043                        be32_to_cpu(fore200e->stats->aal34.cells_dropped),
3044                        be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
3045                        be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
3046                        be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
3047                        be32_to_cpu(fore200e->stats->aal34.cspdus_received),
3048                        be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
3049                        be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
3050     
3051     if (!left--)
3052         return sprintf(page,"\n"
3053                        "   AAL5:\n"
3054                        "     SAR sublayer:\t\t     cells\n"
3055                        "       TX:\t\t\t%10u\n"
3056                        "       RX:\t\t\t%10u\n"
3057                        "       dropped:\t\t\t%10u\n"
3058                        "       congestions:\t\t%10u\n\n"
3059                        "     CS  sublayer:\t\t      PDUs\n"
3060                        "       TX:\t\t\t%10u\n"
3061                        "       RX:\t\t\t%10u\n"
3062                        "       dropped:\t\t\t%10u\n"
3063                        "       CRC errors:\t\t%10u\n"
3064                        "       protocol errors:\t\t%10u\n",
3065                        be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
3066                        be32_to_cpu(fore200e->stats->aal5.cells_received),
3067                        be32_to_cpu(fore200e->stats->aal5.cells_dropped),
3068                        be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
3069                        be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
3070                        be32_to_cpu(fore200e->stats->aal5.cspdus_received),
3071                        be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
3072                        be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
3073                        be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
3074     
3075     if (!left--)
3076         return sprintf(page,"\n"
3077                        "   AUX:\t\t       allocation failures\n"
3078                        "     small b1:\t\t\t%10u\n"
3079                        "     large b1:\t\t\t%10u\n"
3080                        "     small b2:\t\t\t%10u\n"
3081                        "     large b2:\t\t\t%10u\n"
3082                        "     RX PDUs:\t\t\t%10u\n"
3083                        "     TX PDUs:\t\t\t%10lu\n",
3084                        be32_to_cpu(fore200e->stats->aux.small_b1_failed),
3085                        be32_to_cpu(fore200e->stats->aux.large_b1_failed),
3086                        be32_to_cpu(fore200e->stats->aux.small_b2_failed),
3087                        be32_to_cpu(fore200e->stats->aux.large_b2_failed),
3088                        be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
3089                        fore200e->tx_sat);
3090     
3091     if (!left--)
3092         return sprintf(page,"\n"
3093                        " receive carrier:\t\t\t%s\n",
3094                        fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
3095     
3096     if (!left--) {
3097         return sprintf(page,"\n"
3098                        " VCCs:\n  address   VPI VCI   AAL "
3099                        "TX PDUs   TX min/max size  RX PDUs   RX min/max size\n");
3100     }
3101
3102     for (i = 0; i < NBR_CONNECT; i++) {
3103
3104         vcc = fore200e->vc_map[i].vcc;
3105
3106         if (vcc == NULL)
3107             continue;
3108
3109         spin_lock_irqsave(&fore200e->q_lock, flags);
3110
3111         if (vcc && test_bit(ATM_VF_READY, &vcc->flags) && !left--) {
3112
3113             fore200e_vcc = FORE200E_VCC(vcc);
3114             ASSERT(fore200e_vcc);
3115
3116             len = sprintf(page,
3117                           "  %08x  %03d %05d %1d   %09lu %05d/%05d      %09lu %05d/%05d\n",
3118                           (u32)(unsigned long)vcc,
3119                           vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
3120                           fore200e_vcc->tx_pdu,
3121                           fore200e_vcc->tx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->tx_min_pdu,
3122                           fore200e_vcc->tx_max_pdu,
3123                           fore200e_vcc->rx_pdu,
3124                           fore200e_vcc->rx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->rx_min_pdu,
3125                           fore200e_vcc->rx_max_pdu);
3126
3127             spin_unlock_irqrestore(&fore200e->q_lock, flags);
3128             return len;
3129         }
3130
3131         spin_unlock_irqrestore(&fore200e->q_lock, flags);
3132     }
3133     
3134     return 0;
3135 }
3136
3137 module_init(fore200e_module_init);
3138 module_exit(fore200e_module_cleanup);
3139
3140
3141 static const struct atmdev_ops fore200e_ops =
3142 {
3143         .open       = fore200e_open,
3144         .close      = fore200e_close,
3145         .ioctl      = fore200e_ioctl,
3146         .getsockopt = fore200e_getsockopt,
3147         .setsockopt = fore200e_setsockopt,
3148         .send       = fore200e_send,
3149         .change_qos = fore200e_change_qos,
3150         .proc_read  = fore200e_proc_read,
3151         .owner      = THIS_MODULE
3152 };
3153
3154
3155 static const struct fore200e_bus fore200e_bus[] = {
3156 #ifdef CONFIG_PCI
3157     { "PCA-200E", "pca200e", 32, 4, 32, 
3158       fore200e_pca_read,
3159       fore200e_pca_write,
3160       fore200e_pca_dma_map,
3161       fore200e_pca_dma_unmap,
3162       fore200e_pca_dma_sync_for_cpu,
3163       fore200e_pca_dma_sync_for_device,
3164       fore200e_pca_dma_chunk_alloc,
3165       fore200e_pca_dma_chunk_free,
3166       NULL,
3167       fore200e_pca_configure,
3168       fore200e_pca_map,
3169       fore200e_pca_reset,
3170       fore200e_pca_prom_read,
3171       fore200e_pca_unmap,
3172       NULL,
3173       fore200e_pca_irq_check,
3174       fore200e_pca_irq_ack,
3175       fore200e_pca_proc_read,
3176     },
3177 #endif
3178 #ifdef CONFIG_SBUS
3179     { "SBA-200E", "sba200e", 32, 64, 32,
3180       fore200e_sba_read,
3181       fore200e_sba_write,
3182       fore200e_sba_dma_map,
3183       fore200e_sba_dma_unmap,
3184       fore200e_sba_dma_sync_for_cpu,
3185       fore200e_sba_dma_sync_for_device,
3186       fore200e_sba_dma_chunk_alloc,
3187       fore200e_sba_dma_chunk_free,
3188       fore200e_sba_detect, 
3189       fore200e_sba_configure,
3190       fore200e_sba_map,
3191       fore200e_sba_reset,
3192       fore200e_sba_prom_read,
3193       fore200e_sba_unmap,
3194       fore200e_sba_irq_enable,
3195       fore200e_sba_irq_check,
3196       fore200e_sba_irq_ack,
3197       fore200e_sba_proc_read,
3198     },
3199 #endif
3200     {}
3201 };
3202
3203 MODULE_LICENSE("GPL");
3204 #ifdef CONFIG_PCI
3205 #ifdef __LITTLE_ENDIAN__
3206 MODULE_FIRMWARE("pca200e.bin");
3207 #else
3208 MODULE_FIRMWARE("pca200e_ecd.bin2");
3209 #endif
3210 #endif /* CONFIG_PCI */
3211 #ifdef CONFIG_SBUS
3212 MODULE_FIRMWARE("sba200e_ecd.bin2");
3213 #endif