Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 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

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

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