Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/drivers/atm/fore200e.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us