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