1 // SPDX-License-Identifier: GPL-2.0-or-later
3 A FORE Systems 200E-series driver for ATM on Linux.
4 Christophe Lizzi (lizzi@cnam.fr), October 1999-March 2003.
6 Based on the PCA-200E driver from Uwe Dannowski (Uwe.Dannowski@inf.tu-dresden.de).
8 This driver simultaneously supports PCA-200E and SBA-200E adapters
9 on i386, alpha (untested), powerpc, sparc and sparc64 architectures.
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/init.h>
17 #include <linux/capability.h>
18 #include <linux/interrupt.h>
19 #include <linux/bitops.h>
20 #include <linux/pci.h>
21 #include <linux/module.h>
22 #include <linux/atmdev.h>
23 #include <linux/sonet.h>
24 #include <linux/atm_suni.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/delay.h>
27 #include <linux/firmware.h>
29 #include <asm/string.h>
33 #include <asm/byteorder.h>
34 #include <linux/uaccess.h>
35 #include <linux/atomic.h>
39 #include <linux/of_device.h>
40 #include <asm/idprom.h>
41 #include <asm/openprom.h>
42 #include <asm/oplib.h>
43 #include <asm/pgtable.h>
46 #if defined(CONFIG_ATM_FORE200E_USE_TASKLET) /* defer interrupt work to a tasklet */
47 #define FORE200E_USE_TASKLET
50 #if 0 /* enable the debugging code of the buffer supply queues */
51 #define FORE200E_BSQ_DEBUG
54 #if 1 /* ensure correct handling of 52-byte AAL0 SDUs expected by atmdump-like apps */
55 #define FORE200E_52BYTE_AAL0_SDU
61 #define FORE200E_VERSION "0.3e"
63 #define FORE200E "fore200e: "
65 #if 0 /* override .config */
66 #define CONFIG_ATM_FORE200E_DEBUG 1
68 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
69 #define DPRINTK(level, format, args...) do { if (CONFIG_ATM_FORE200E_DEBUG >= (level)) \
70 printk(FORE200E format, ##args); } while (0)
72 #define DPRINTK(level, format, args...) do {} while (0)
76 #define FORE200E_ALIGN(addr, alignment) \
77 ((((unsigned long)(addr) + (alignment - 1)) & ~(alignment - 1)) - (unsigned long)(addr))
79 #define FORE200E_DMA_INDEX(dma_addr, type, index) ((dma_addr) + (index) * sizeof(type))
81 #define FORE200E_INDEX(virt_addr, type, index) (&((type *)(virt_addr))[ index ])
83 #define FORE200E_NEXT_ENTRY(index, modulo) (index = ((index) + 1) % (modulo))
86 #define ASSERT(expr) if (!(expr)) { \
87 printk(FORE200E "assertion failed! %s[%d]: %s\n", \
88 __func__, __LINE__, #expr); \
89 panic(FORE200E "%s", __func__); \
92 #define ASSERT(expr) do {} while (0)
96 static const struct atmdev_ops fore200e_ops;
98 static LIST_HEAD(fore200e_boards);
101 MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");
102 MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);
103 MODULE_SUPPORTED_DEVICE("PCA-200E, SBA-200E");
106 static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
107 { BUFFER_S1_NBR, BUFFER_L1_NBR },
108 { BUFFER_S2_NBR, BUFFER_L2_NBR }
111 static const int fore200e_rx_buf_size[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
112 { BUFFER_S1_SIZE, BUFFER_L1_SIZE },
113 { BUFFER_S2_SIZE, BUFFER_L2_SIZE }
117 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
118 static const char* fore200e_traffic_class[] = { "NONE", "UBR", "CBR", "VBR", "ABR", "ANY" };
122 #if 0 /* currently unused */
124 fore200e_fore2atm_aal(enum fore200e_aal aal)
127 case FORE200E_AAL0: return ATM_AAL0;
128 case FORE200E_AAL34: return ATM_AAL34;
129 case FORE200E_AAL5: return ATM_AAL5;
137 static enum fore200e_aal
138 fore200e_atm2fore_aal(int aal)
141 case ATM_AAL0: return FORE200E_AAL0;
142 case ATM_AAL34: return FORE200E_AAL34;
145 case ATM_AAL5: return FORE200E_AAL5;
153 fore200e_irq_itoa(int irq)
156 sprintf(str, "%d", irq);
161 /* allocate and align a chunk of memory intended to hold the data behing exchanged
162 between the driver and the adapter (using streaming DVMA) */
165 fore200e_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, int size, int alignment, int direction)
167 unsigned long offset = 0;
169 if (alignment <= sizeof(int))
172 chunk->alloc_size = size + alignment;
173 chunk->direction = direction;
175 chunk->alloc_addr = kzalloc(chunk->alloc_size, GFP_KERNEL);
176 if (chunk->alloc_addr == NULL)
180 offset = FORE200E_ALIGN(chunk->alloc_addr, alignment);
182 chunk->align_addr = chunk->alloc_addr + offset;
184 chunk->dma_addr = dma_map_single(fore200e->dev, chunk->align_addr,
186 if (dma_mapping_error(fore200e->dev, chunk->dma_addr)) {
187 kfree(chunk->alloc_addr);
194 /* free a chunk of memory */
197 fore200e_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
199 dma_unmap_single(fore200e->dev, chunk->dma_addr, chunk->dma_size,
201 kfree(chunk->alloc_addr);
205 * Allocate a DMA consistent chunk of memory intended to act as a communication
206 * mechanism (to hold descriptors, status, queues, etc.) shared by the driver
210 fore200e_dma_chunk_alloc(struct fore200e *fore200e, struct chunk *chunk,
211 int size, int nbr, int alignment)
213 /* returned chunks are page-aligned */
214 chunk->alloc_size = size * nbr;
215 chunk->alloc_addr = dma_alloc_coherent(fore200e->dev, chunk->alloc_size,
216 &chunk->dma_addr, GFP_KERNEL);
217 if (!chunk->alloc_addr)
219 chunk->align_addr = chunk->alloc_addr;
224 * Free a DMA consistent chunk of memory.
227 fore200e_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
229 dma_free_coherent(fore200e->dev, chunk->alloc_size, chunk->alloc_addr,
234 fore200e_spin(int msecs)
236 unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
237 while (time_before(jiffies, timeout));
242 fore200e_poll(struct fore200e* fore200e, volatile u32* addr, u32 val, int msecs)
244 unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
249 if ((ok = (*addr == val)) || (*addr & STATUS_ERROR))
252 } while (time_before(jiffies, timeout));
256 printk(FORE200E "cmd polling failed, got status 0x%08x, expected 0x%08x\n",
266 fore200e_io_poll(struct fore200e* fore200e, volatile u32 __iomem *addr, u32 val, int msecs)
268 unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
272 if ((ok = (fore200e->bus->read(addr) == val)))
275 } while (time_before(jiffies, timeout));
279 printk(FORE200E "I/O polling failed, got status 0x%08x, expected 0x%08x\n",
280 fore200e->bus->read(addr), val);
289 fore200e_free_rx_buf(struct fore200e* fore200e)
291 int scheme, magn, nbr;
292 struct buffer* buffer;
294 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
295 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
297 if ((buffer = fore200e->host_bsq[ scheme ][ magn ].buffer) != NULL) {
299 for (nbr = 0; nbr < fore200e_rx_buf_nbr[ scheme ][ magn ]; nbr++) {
301 struct chunk* data = &buffer[ nbr ].data;
303 if (data->alloc_addr != NULL)
304 fore200e_chunk_free(fore200e, data);
313 fore200e_uninit_bs_queue(struct fore200e* fore200e)
317 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
318 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
320 struct chunk* status = &fore200e->host_bsq[ scheme ][ magn ].status;
321 struct chunk* rbd_block = &fore200e->host_bsq[ scheme ][ magn ].rbd_block;
323 if (status->alloc_addr)
324 fore200e_dma_chunk_free(fore200e, status);
326 if (rbd_block->alloc_addr)
327 fore200e_dma_chunk_free(fore200e, rbd_block);
334 fore200e_reset(struct fore200e* fore200e, int diag)
338 fore200e->cp_monitor = fore200e->virt_base + FORE200E_CP_MONITOR_OFFSET;
340 fore200e->bus->write(BSTAT_COLD_START, &fore200e->cp_monitor->bstat);
342 fore200e->bus->reset(fore200e);
345 ok = fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_SELFTEST_OK, 1000);
348 printk(FORE200E "device %s self-test failed\n", fore200e->name);
352 printk(FORE200E "device %s self-test passed\n", fore200e->name);
354 fore200e->state = FORE200E_STATE_RESET;
362 fore200e_shutdown(struct fore200e* fore200e)
364 printk(FORE200E "removing device %s at 0x%lx, IRQ %s\n",
365 fore200e->name, fore200e->phys_base,
366 fore200e_irq_itoa(fore200e->irq));
368 if (fore200e->state > FORE200E_STATE_RESET) {
369 /* first, reset the board to prevent further interrupts or data transfers */
370 fore200e_reset(fore200e, 0);
373 /* then, release all allocated resources */
374 switch(fore200e->state) {
376 case FORE200E_STATE_COMPLETE:
377 kfree(fore200e->stats);
380 case FORE200E_STATE_IRQ:
381 free_irq(fore200e->irq, fore200e->atm_dev);
384 case FORE200E_STATE_ALLOC_BUF:
385 fore200e_free_rx_buf(fore200e);
388 case FORE200E_STATE_INIT_BSQ:
389 fore200e_uninit_bs_queue(fore200e);
392 case FORE200E_STATE_INIT_RXQ:
393 fore200e_dma_chunk_free(fore200e, &fore200e->host_rxq.status);
394 fore200e_dma_chunk_free(fore200e, &fore200e->host_rxq.rpd);
397 case FORE200E_STATE_INIT_TXQ:
398 fore200e_dma_chunk_free(fore200e, &fore200e->host_txq.status);
399 fore200e_dma_chunk_free(fore200e, &fore200e->host_txq.tpd);
402 case FORE200E_STATE_INIT_CMDQ:
403 fore200e_dma_chunk_free(fore200e, &fore200e->host_cmdq.status);
406 case FORE200E_STATE_INITIALIZE:
407 /* nothing to do for that state */
409 case FORE200E_STATE_START_FW:
410 /* nothing to do for that state */
412 case FORE200E_STATE_RESET:
413 /* nothing to do for that state */
415 case FORE200E_STATE_MAP:
416 fore200e->bus->unmap(fore200e);
419 case FORE200E_STATE_CONFIGURE:
420 /* nothing to do for that state */
422 case FORE200E_STATE_REGISTER:
423 /* XXX shouldn't we *start* by deregistering the device? */
424 atm_dev_deregister(fore200e->atm_dev);
426 case FORE200E_STATE_BLANK:
427 /* nothing to do for that state */
435 static u32 fore200e_pca_read(volatile u32 __iomem *addr)
437 /* on big-endian hosts, the board is configured to convert
438 the endianess of slave RAM accesses */
439 return le32_to_cpu(readl(addr));
443 static void fore200e_pca_write(u32 val, volatile u32 __iomem *addr)
445 /* on big-endian hosts, the board is configured to convert
446 the endianess of slave RAM accesses */
447 writel(cpu_to_le32(val), addr);
451 fore200e_pca_irq_check(struct fore200e* fore200e)
453 /* this is a 1 bit register */
454 int irq_posted = readl(fore200e->regs.pca.psr);
456 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG == 2)
457 if (irq_posted && (readl(fore200e->regs.pca.hcr) & PCA200E_HCR_OUTFULL)) {
458 DPRINTK(2,"FIFO OUT full, device %d\n", fore200e->atm_dev->number);
467 fore200e_pca_irq_ack(struct fore200e* fore200e)
469 writel(PCA200E_HCR_CLRINTR, fore200e->regs.pca.hcr);
474 fore200e_pca_reset(struct fore200e* fore200e)
476 writel(PCA200E_HCR_RESET, fore200e->regs.pca.hcr);
478 writel(0, fore200e->regs.pca.hcr);
482 static int fore200e_pca_map(struct fore200e* fore200e)
484 DPRINTK(2, "device %s being mapped in memory\n", fore200e->name);
486 fore200e->virt_base = ioremap(fore200e->phys_base, PCA200E_IOSPACE_LENGTH);
488 if (fore200e->virt_base == NULL) {
489 printk(FORE200E "can't map device %s\n", fore200e->name);
493 DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
495 /* gain access to the PCA specific registers */
496 fore200e->regs.pca.hcr = fore200e->virt_base + PCA200E_HCR_OFFSET;
497 fore200e->regs.pca.imr = fore200e->virt_base + PCA200E_IMR_OFFSET;
498 fore200e->regs.pca.psr = fore200e->virt_base + PCA200E_PSR_OFFSET;
500 fore200e->state = FORE200E_STATE_MAP;
506 fore200e_pca_unmap(struct fore200e* fore200e)
508 DPRINTK(2, "device %s being unmapped from memory\n", fore200e->name);
510 if (fore200e->virt_base != NULL)
511 iounmap(fore200e->virt_base);
515 static int fore200e_pca_configure(struct fore200e *fore200e)
517 struct pci_dev *pci_dev = to_pci_dev(fore200e->dev);
518 u8 master_ctrl, latency;
520 DPRINTK(2, "device %s being configured\n", fore200e->name);
522 if ((pci_dev->irq == 0) || (pci_dev->irq == 0xFF)) {
523 printk(FORE200E "incorrect IRQ setting - misconfigured PCI-PCI bridge?\n");
527 pci_read_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, &master_ctrl);
529 master_ctrl = master_ctrl
530 #if defined(__BIG_ENDIAN)
531 /* request the PCA board to convert the endianess of slave RAM accesses */
532 | PCA200E_CTRL_CONVERT_ENDIAN
535 | PCA200E_CTRL_DIS_CACHE_RD
536 | PCA200E_CTRL_DIS_WRT_INVAL
537 | PCA200E_CTRL_ENA_CONT_REQ_MODE
538 | PCA200E_CTRL_2_CACHE_WRT_INVAL
540 | PCA200E_CTRL_LARGE_PCI_BURSTS;
542 pci_write_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, master_ctrl);
544 /* raise latency from 32 (default) to 192, as this seems to prevent NIC
545 lockups (under heavy rx loads) due to continuous 'FIFO OUT full' condition.
546 this may impact the performances of other PCI devices on the same bus, though */
548 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
550 fore200e->state = FORE200E_STATE_CONFIGURE;
556 fore200e_pca_prom_read(struct fore200e* fore200e, struct prom_data* prom)
558 struct host_cmdq* cmdq = &fore200e->host_cmdq;
559 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
560 struct prom_opcode opcode;
564 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
566 opcode.opcode = OPCODE_GET_PROM;
569 prom_dma = dma_map_single(fore200e->dev, prom, sizeof(struct prom_data),
571 if (dma_mapping_error(fore200e->dev, prom_dma))
574 fore200e->bus->write(prom_dma, &entry->cp_entry->cmd.prom_block.prom_haddr);
576 *entry->status = STATUS_PENDING;
578 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.prom_block.opcode);
580 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
582 *entry->status = STATUS_FREE;
584 dma_unmap_single(fore200e->dev, prom_dma, sizeof(struct prom_data), DMA_FROM_DEVICE);
587 printk(FORE200E "unable to get PROM data from device %s\n", fore200e->name);
591 #if defined(__BIG_ENDIAN)
593 #define swap_here(addr) (*((u32*)(addr)) = swab32( *((u32*)(addr)) ))
595 /* MAC address is stored as little-endian */
596 swap_here(&prom->mac_addr[0]);
597 swap_here(&prom->mac_addr[4]);
605 fore200e_pca_proc_read(struct fore200e* fore200e, char *page)
607 struct pci_dev *pci_dev = to_pci_dev(fore200e->dev);
609 return sprintf(page, " PCI bus/slot/function:\t%d/%d/%d\n",
610 pci_dev->bus->number, PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
613 static const struct fore200e_bus fore200e_pci_ops = {
614 .model_name = "PCA-200E",
615 .proc_name = "pca200e",
616 .descr_alignment = 32,
617 .buffer_alignment = 4,
618 .status_alignment = 32,
619 .read = fore200e_pca_read,
620 .write = fore200e_pca_write,
621 .configure = fore200e_pca_configure,
622 .map = fore200e_pca_map,
623 .reset = fore200e_pca_reset,
624 .prom_read = fore200e_pca_prom_read,
625 .unmap = fore200e_pca_unmap,
626 .irq_check = fore200e_pca_irq_check,
627 .irq_ack = fore200e_pca_irq_ack,
628 .proc_read = fore200e_pca_proc_read,
630 #endif /* CONFIG_PCI */
634 static u32 fore200e_sba_read(volatile u32 __iomem *addr)
636 return sbus_readl(addr);
639 static void fore200e_sba_write(u32 val, volatile u32 __iomem *addr)
641 sbus_writel(val, addr);
644 static void fore200e_sba_irq_enable(struct fore200e *fore200e)
646 u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
647 fore200e->bus->write(hcr | SBA200E_HCR_INTR_ENA, fore200e->regs.sba.hcr);
650 static int fore200e_sba_irq_check(struct fore200e *fore200e)
652 return fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_INTR_REQ;
655 static void fore200e_sba_irq_ack(struct fore200e *fore200e)
657 u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
658 fore200e->bus->write(hcr | SBA200E_HCR_INTR_CLR, fore200e->regs.sba.hcr);
661 static void fore200e_sba_reset(struct fore200e *fore200e)
663 fore200e->bus->write(SBA200E_HCR_RESET, fore200e->regs.sba.hcr);
665 fore200e->bus->write(0, fore200e->regs.sba.hcr);
668 static int __init fore200e_sba_map(struct fore200e *fore200e)
670 struct platform_device *op = to_platform_device(fore200e->dev);
673 /* gain access to the SBA specific registers */
674 fore200e->regs.sba.hcr = of_ioremap(&op->resource[0], 0, SBA200E_HCR_LENGTH, "SBA HCR");
675 fore200e->regs.sba.bsr = of_ioremap(&op->resource[1], 0, SBA200E_BSR_LENGTH, "SBA BSR");
676 fore200e->regs.sba.isr = of_ioremap(&op->resource[2], 0, SBA200E_ISR_LENGTH, "SBA ISR");
677 fore200e->virt_base = of_ioremap(&op->resource[3], 0, SBA200E_RAM_LENGTH, "SBA RAM");
679 if (!fore200e->virt_base) {
680 printk(FORE200E "unable to map RAM of device %s\n", fore200e->name);
684 DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
686 fore200e->bus->write(0x02, fore200e->regs.sba.isr); /* XXX hardwired interrupt level */
688 /* get the supported DVMA burst sizes */
689 bursts = of_getintprop_default(op->dev.of_node->parent, "burst-sizes", 0x00);
691 if (sbus_can_dma_64bit())
692 sbus_set_sbus64(&op->dev, bursts);
694 fore200e->state = FORE200E_STATE_MAP;
698 static void fore200e_sba_unmap(struct fore200e *fore200e)
700 struct platform_device *op = to_platform_device(fore200e->dev);
702 of_iounmap(&op->resource[0], fore200e->regs.sba.hcr, SBA200E_HCR_LENGTH);
703 of_iounmap(&op->resource[1], fore200e->regs.sba.bsr, SBA200E_BSR_LENGTH);
704 of_iounmap(&op->resource[2], fore200e->regs.sba.isr, SBA200E_ISR_LENGTH);
705 of_iounmap(&op->resource[3], fore200e->virt_base, SBA200E_RAM_LENGTH);
708 static int __init fore200e_sba_configure(struct fore200e *fore200e)
710 fore200e->state = FORE200E_STATE_CONFIGURE;
714 static int __init fore200e_sba_prom_read(struct fore200e *fore200e, struct prom_data *prom)
716 struct platform_device *op = to_platform_device(fore200e->dev);
720 prop = of_get_property(op->dev.of_node, "madaddrlo2", &len);
723 memcpy(&prom->mac_addr[4], prop, 4);
725 prop = of_get_property(op->dev.of_node, "madaddrhi4", &len);
728 memcpy(&prom->mac_addr[2], prop, 4);
730 prom->serial_number = of_getintprop_default(op->dev.of_node,
732 prom->hw_revision = of_getintprop_default(op->dev.of_node,
738 static int fore200e_sba_proc_read(struct fore200e *fore200e, char *page)
740 struct platform_device *op = to_platform_device(fore200e->dev);
741 const struct linux_prom_registers *regs;
743 regs = of_get_property(op->dev.of_node, "reg", NULL);
745 return sprintf(page, " SBUS slot/device:\t\t%d/'%pOFn'\n",
746 (regs ? regs->which_io : 0), op->dev.of_node);
749 static const struct fore200e_bus fore200e_sbus_ops = {
750 .model_name = "SBA-200E",
751 .proc_name = "sba200e",
752 .descr_alignment = 32,
753 .buffer_alignment = 64,
754 .status_alignment = 32,
755 .read = fore200e_sba_read,
756 .write = fore200e_sba_write,
757 .configure = fore200e_sba_configure,
758 .map = fore200e_sba_map,
759 .reset = fore200e_sba_reset,
760 .prom_read = fore200e_sba_prom_read,
761 .unmap = fore200e_sba_unmap,
762 .irq_enable = fore200e_sba_irq_enable,
763 .irq_check = fore200e_sba_irq_check,
764 .irq_ack = fore200e_sba_irq_ack,
765 .proc_read = fore200e_sba_proc_read,
767 #endif /* CONFIG_SBUS */
770 fore200e_tx_irq(struct fore200e* fore200e)
772 struct host_txq* txq = &fore200e->host_txq;
773 struct host_txq_entry* entry;
775 struct fore200e_vc_map* vc_map;
777 if (fore200e->host_txq.txing == 0)
782 entry = &txq->host_entry[ txq->tail ];
784 if ((*entry->status & STATUS_COMPLETE) == 0) {
788 DPRINTK(3, "TX COMPLETED: entry = %p [tail = %d], vc_map = %p, skb = %p\n",
789 entry, txq->tail, entry->vc_map, entry->skb);
791 /* free copy of misaligned data */
794 /* remove DMA mapping */
795 dma_unmap_single(fore200e->dev, entry->tpd->tsd[ 0 ].buffer, entry->tpd->tsd[ 0 ].length,
798 vc_map = entry->vc_map;
800 /* vcc closed since the time the entry was submitted for tx? */
801 if ((vc_map->vcc == NULL) ||
802 (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
804 DPRINTK(1, "no ready vcc found for PDU sent on device %d\n",
805 fore200e->atm_dev->number);
807 dev_kfree_skb_any(entry->skb);
812 /* vcc closed then immediately re-opened? */
813 if (vc_map->incarn != entry->incarn) {
815 /* when a vcc is closed, some PDUs may be still pending in the tx queue.
816 if the same vcc is immediately re-opened, those pending PDUs must
817 not be popped after the completion of their emission, as they refer
818 to the prior incarnation of that vcc. otherwise, sk_atm(vcc)->sk_wmem_alloc
819 would be decremented by the size of the (unrelated) skb, possibly
820 leading to a negative sk->sk_wmem_alloc count, ultimately freezing the vcc.
821 we thus bind the tx entry to the current incarnation of the vcc
822 when the entry is submitted for tx. When the tx later completes,
823 if the incarnation number of the tx entry does not match the one
824 of the vcc, then this implies that the vcc has been closed then re-opened.
825 we thus just drop the skb here. */
827 DPRINTK(1, "vcc closed-then-re-opened; dropping PDU sent on device %d\n",
828 fore200e->atm_dev->number);
830 dev_kfree_skb_any(entry->skb);
836 /* notify tx completion */
838 vcc->pop(vcc, entry->skb);
841 dev_kfree_skb_any(entry->skb);
844 /* check error condition */
845 if (*entry->status & STATUS_ERROR)
846 atomic_inc(&vcc->stats->tx_err);
848 atomic_inc(&vcc->stats->tx);
852 *entry->status = STATUS_FREE;
854 fore200e->host_txq.txing--;
856 FORE200E_NEXT_ENTRY(txq->tail, QUEUE_SIZE_TX);
861 #ifdef FORE200E_BSQ_DEBUG
862 int bsq_audit(int where, struct host_bsq* bsq, int scheme, int magn)
864 struct buffer* buffer;
867 buffer = bsq->freebuf;
870 if (buffer->supplied) {
871 printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld supplied but in free list!\n",
872 where, scheme, magn, buffer->index);
875 if (buffer->magn != magn) {
876 printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected magn = %d\n",
877 where, scheme, magn, buffer->index, buffer->magn);
880 if (buffer->scheme != scheme) {
881 printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected scheme = %d\n",
882 where, scheme, magn, buffer->index, buffer->scheme);
885 if ((buffer->index < 0) || (buffer->index >= fore200e_rx_buf_nbr[ scheme ][ magn ])) {
886 printk(FORE200E "bsq_audit(%d): queue %d.%d, out of range buffer index = %ld !\n",
887 where, scheme, magn, buffer->index);
891 buffer = buffer->next;
894 if (count != bsq->freebuf_count) {
895 printk(FORE200E "bsq_audit(%d): queue %d.%d, %d bufs in free list, but freebuf_count = %d\n",
896 where, scheme, magn, count, bsq->freebuf_count);
904 fore200e_supply(struct fore200e* fore200e)
908 struct host_bsq* bsq;
909 struct host_bsq_entry* entry;
910 struct buffer* buffer;
912 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
913 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
915 bsq = &fore200e->host_bsq[ scheme ][ magn ];
917 #ifdef FORE200E_BSQ_DEBUG
918 bsq_audit(1, bsq, scheme, magn);
920 while (bsq->freebuf_count >= RBD_BLK_SIZE) {
922 DPRINTK(2, "supplying %d rx buffers to queue %d / %d, freebuf_count = %d\n",
923 RBD_BLK_SIZE, scheme, magn, bsq->freebuf_count);
925 entry = &bsq->host_entry[ bsq->head ];
927 for (i = 0; i < RBD_BLK_SIZE; i++) {
929 /* take the first buffer in the free buffer list */
930 buffer = bsq->freebuf;
932 printk(FORE200E "no more free bufs in queue %d.%d, but freebuf_count = %d\n",
933 scheme, magn, bsq->freebuf_count);
936 bsq->freebuf = buffer->next;
938 #ifdef FORE200E_BSQ_DEBUG
939 if (buffer->supplied)
940 printk(FORE200E "queue %d.%d, buffer %lu already supplied\n",
941 scheme, magn, buffer->index);
942 buffer->supplied = 1;
944 entry->rbd_block->rbd[ i ].buffer_haddr = buffer->data.dma_addr;
945 entry->rbd_block->rbd[ i ].handle = FORE200E_BUF2HDL(buffer);
948 FORE200E_NEXT_ENTRY(bsq->head, QUEUE_SIZE_BS);
950 /* decrease accordingly the number of free rx buffers */
951 bsq->freebuf_count -= RBD_BLK_SIZE;
953 *entry->status = STATUS_PENDING;
954 fore200e->bus->write(entry->rbd_block_dma, &entry->cp_entry->rbd_block_haddr);
962 fore200e_push_rpd(struct fore200e* fore200e, struct atm_vcc* vcc, struct rpd* rpd)
965 struct buffer* buffer;
966 struct fore200e_vcc* fore200e_vcc;
968 #ifdef FORE200E_52BYTE_AAL0_SDU
974 fore200e_vcc = FORE200E_VCC(vcc);
975 ASSERT(fore200e_vcc);
977 #ifdef FORE200E_52BYTE_AAL0_SDU
978 if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.rxtp.max_sdu == ATM_AAL0_SDU)) {
980 cell_header = (rpd->atm_header.gfc << ATM_HDR_GFC_SHIFT) |
981 (rpd->atm_header.vpi << ATM_HDR_VPI_SHIFT) |
982 (rpd->atm_header.vci << ATM_HDR_VCI_SHIFT) |
983 (rpd->atm_header.plt << ATM_HDR_PTI_SHIFT) |
989 /* compute total PDU length */
990 for (i = 0; i < rpd->nseg; i++)
991 pdu_len += rpd->rsd[ i ].length;
993 skb = alloc_skb(pdu_len, GFP_ATOMIC);
995 DPRINTK(2, "unable to alloc new skb, rx PDU length = %d\n", pdu_len);
997 atomic_inc(&vcc->stats->rx_drop);
1001 __net_timestamp(skb);
1003 #ifdef FORE200E_52BYTE_AAL0_SDU
1005 *((u32*)skb_put(skb, 4)) = cell_header;
1009 /* reassemble segments */
1010 for (i = 0; i < rpd->nseg; i++) {
1012 /* rebuild rx buffer address from rsd handle */
1013 buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1015 /* Make device DMA transfer visible to CPU. */
1016 dma_sync_single_for_cpu(fore200e->dev, buffer->data.dma_addr,
1017 rpd->rsd[i].length, DMA_FROM_DEVICE);
1019 skb_put_data(skb, buffer->data.align_addr, rpd->rsd[i].length);
1021 /* Now let the device get at it again. */
1022 dma_sync_single_for_device(fore200e->dev, buffer->data.dma_addr,
1023 rpd->rsd[i].length, DMA_FROM_DEVICE);
1026 DPRINTK(3, "rx skb: len = %d, truesize = %d\n", skb->len, skb->truesize);
1028 if (pdu_len < fore200e_vcc->rx_min_pdu)
1029 fore200e_vcc->rx_min_pdu = pdu_len;
1030 if (pdu_len > fore200e_vcc->rx_max_pdu)
1031 fore200e_vcc->rx_max_pdu = pdu_len;
1032 fore200e_vcc->rx_pdu++;
1035 if (atm_charge(vcc, skb->truesize) == 0) {
1037 DPRINTK(2, "receive buffers saturated for %d.%d.%d - PDU dropped\n",
1038 vcc->itf, vcc->vpi, vcc->vci);
1040 dev_kfree_skb_any(skb);
1042 atomic_inc(&vcc->stats->rx_drop);
1046 vcc->push(vcc, skb);
1047 atomic_inc(&vcc->stats->rx);
1054 fore200e_collect_rpd(struct fore200e* fore200e, struct rpd* rpd)
1056 struct host_bsq* bsq;
1057 struct buffer* buffer;
1060 for (i = 0; i < rpd->nseg; i++) {
1062 /* rebuild rx buffer address from rsd handle */
1063 buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1065 bsq = &fore200e->host_bsq[ buffer->scheme ][ buffer->magn ];
1067 #ifdef FORE200E_BSQ_DEBUG
1068 bsq_audit(2, bsq, buffer->scheme, buffer->magn);
1070 if (buffer->supplied == 0)
1071 printk(FORE200E "queue %d.%d, buffer %ld was not supplied\n",
1072 buffer->scheme, buffer->magn, buffer->index);
1073 buffer->supplied = 0;
1076 /* re-insert the buffer into the free buffer list */
1077 buffer->next = bsq->freebuf;
1078 bsq->freebuf = buffer;
1080 /* then increment the number of free rx buffers */
1081 bsq->freebuf_count++;
1087 fore200e_rx_irq(struct fore200e* fore200e)
1089 struct host_rxq* rxq = &fore200e->host_rxq;
1090 struct host_rxq_entry* entry;
1091 struct atm_vcc* vcc;
1092 struct fore200e_vc_map* vc_map;
1096 entry = &rxq->host_entry[ rxq->head ];
1098 /* no more received PDUs */
1099 if ((*entry->status & STATUS_COMPLETE) == 0)
1102 vc_map = FORE200E_VC_MAP(fore200e, entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1104 if ((vc_map->vcc == NULL) ||
1105 (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
1107 DPRINTK(1, "no ready VC found for PDU received on %d.%d.%d\n",
1108 fore200e->atm_dev->number,
1109 entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1115 if ((*entry->status & STATUS_ERROR) == 0) {
1117 fore200e_push_rpd(fore200e, vcc, entry->rpd);
1120 DPRINTK(2, "damaged PDU on %d.%d.%d\n",
1121 fore200e->atm_dev->number,
1122 entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1123 atomic_inc(&vcc->stats->rx_err);
1127 FORE200E_NEXT_ENTRY(rxq->head, QUEUE_SIZE_RX);
1129 fore200e_collect_rpd(fore200e, entry->rpd);
1131 /* rewrite the rpd address to ack the received PDU */
1132 fore200e->bus->write(entry->rpd_dma, &entry->cp_entry->rpd_haddr);
1133 *entry->status = STATUS_FREE;
1135 fore200e_supply(fore200e);
1140 #ifndef FORE200E_USE_TASKLET
1142 fore200e_irq(struct fore200e* fore200e)
1144 unsigned long flags;
1146 spin_lock_irqsave(&fore200e->q_lock, flags);
1147 fore200e_rx_irq(fore200e);
1148 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1150 spin_lock_irqsave(&fore200e->q_lock, flags);
1151 fore200e_tx_irq(fore200e);
1152 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1158 fore200e_interrupt(int irq, void* dev)
1160 struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev);
1162 if (fore200e->bus->irq_check(fore200e) == 0) {
1164 DPRINTK(3, "interrupt NOT triggered by device %d\n", fore200e->atm_dev->number);
1167 DPRINTK(3, "interrupt triggered by device %d\n", fore200e->atm_dev->number);
1169 #ifdef FORE200E_USE_TASKLET
1170 tasklet_schedule(&fore200e->tx_tasklet);
1171 tasklet_schedule(&fore200e->rx_tasklet);
1173 fore200e_irq(fore200e);
1176 fore200e->bus->irq_ack(fore200e);
1181 #ifdef FORE200E_USE_TASKLET
1183 fore200e_tx_tasklet(unsigned long data)
1185 struct fore200e* fore200e = (struct fore200e*) data;
1186 unsigned long flags;
1188 DPRINTK(3, "tx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1190 spin_lock_irqsave(&fore200e->q_lock, flags);
1191 fore200e_tx_irq(fore200e);
1192 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1197 fore200e_rx_tasklet(unsigned long data)
1199 struct fore200e* fore200e = (struct fore200e*) data;
1200 unsigned long flags;
1202 DPRINTK(3, "rx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1204 spin_lock_irqsave(&fore200e->q_lock, flags);
1205 fore200e_rx_irq((struct fore200e*) data);
1206 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1212 fore200e_select_scheme(struct atm_vcc* vcc)
1214 /* fairly balance the VCs over (identical) buffer schemes */
1215 int scheme = vcc->vci % 2 ? BUFFER_SCHEME_ONE : BUFFER_SCHEME_TWO;
1217 DPRINTK(1, "VC %d.%d.%d uses buffer scheme %d\n",
1218 vcc->itf, vcc->vpi, vcc->vci, scheme);
1225 fore200e_activate_vcin(struct fore200e* fore200e, int activate, struct atm_vcc* vcc, int mtu)
1227 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1228 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1229 struct activate_opcode activ_opcode;
1230 struct deactivate_opcode deactiv_opcode;
1233 enum fore200e_aal aal = fore200e_atm2fore_aal(vcc->qos.aal);
1235 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1238 FORE200E_VCC(vcc)->scheme = fore200e_select_scheme(vcc);
1240 activ_opcode.opcode = OPCODE_ACTIVATE_VCIN;
1241 activ_opcode.aal = aal;
1242 activ_opcode.scheme = FORE200E_VCC(vcc)->scheme;
1243 activ_opcode.pad = 0;
1246 deactiv_opcode.opcode = OPCODE_DEACTIVATE_VCIN;
1247 deactiv_opcode.pad = 0;
1250 vpvc.vci = vcc->vci;
1251 vpvc.vpi = vcc->vpi;
1253 *entry->status = STATUS_PENDING;
1257 #ifdef FORE200E_52BYTE_AAL0_SDU
1260 /* the MTU is not used by the cp, except in the case of AAL0 */
1261 fore200e->bus->write(mtu, &entry->cp_entry->cmd.activate_block.mtu);
1262 fore200e->bus->write(*(u32*)&vpvc, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.vpvc);
1263 fore200e->bus->write(*(u32*)&activ_opcode, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.opcode);
1266 fore200e->bus->write(*(u32*)&vpvc, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.vpvc);
1267 fore200e->bus->write(*(u32*)&deactiv_opcode, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.opcode);
1270 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1272 *entry->status = STATUS_FREE;
1275 printk(FORE200E "unable to %s VC %d.%d.%d\n",
1276 activate ? "open" : "close", vcc->itf, vcc->vpi, vcc->vci);
1280 DPRINTK(1, "VC %d.%d.%d %sed\n", vcc->itf, vcc->vpi, vcc->vci,
1281 activate ? "open" : "clos");
1287 #define FORE200E_MAX_BACK2BACK_CELLS 255 /* XXX depends on CDVT */
1290 fore200e_rate_ctrl(struct atm_qos* qos, struct tpd_rate* rate)
1292 if (qos->txtp.max_pcr < ATM_OC3_PCR) {
1294 /* compute the data cells to idle cells ratio from the tx PCR */
1295 rate->data_cells = qos->txtp.max_pcr * FORE200E_MAX_BACK2BACK_CELLS / ATM_OC3_PCR;
1296 rate->idle_cells = FORE200E_MAX_BACK2BACK_CELLS - rate->data_cells;
1299 /* disable rate control */
1300 rate->data_cells = rate->idle_cells = 0;
1306 fore200e_open(struct atm_vcc *vcc)
1308 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1309 struct fore200e_vcc* fore200e_vcc;
1310 struct fore200e_vc_map* vc_map;
1311 unsigned long flags;
1313 short vpi = vcc->vpi;
1315 ASSERT((vpi >= 0) && (vpi < 1<<FORE200E_VPI_BITS));
1316 ASSERT((vci >= 0) && (vci < 1<<FORE200E_VCI_BITS));
1318 spin_lock_irqsave(&fore200e->q_lock, flags);
1320 vc_map = FORE200E_VC_MAP(fore200e, vpi, vci);
1323 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1325 printk(FORE200E "VC %d.%d.%d already in use\n",
1326 fore200e->atm_dev->number, vpi, vci);
1333 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1335 fore200e_vcc = kzalloc(sizeof(struct fore200e_vcc), GFP_ATOMIC);
1336 if (fore200e_vcc == NULL) {
1341 DPRINTK(2, "opening %d.%d.%d:%d QoS = (tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1342 "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d)\n",
1343 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1344 fore200e_traffic_class[ vcc->qos.txtp.traffic_class ],
1345 vcc->qos.txtp.min_pcr, vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_cdv, vcc->qos.txtp.max_sdu,
1346 fore200e_traffic_class[ vcc->qos.rxtp.traffic_class ],
1347 vcc->qos.rxtp.min_pcr, vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_cdv, vcc->qos.rxtp.max_sdu);
1349 /* pseudo-CBR bandwidth requested? */
1350 if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1352 mutex_lock(&fore200e->rate_mtx);
1353 if (fore200e->available_cell_rate < vcc->qos.txtp.max_pcr) {
1354 mutex_unlock(&fore200e->rate_mtx);
1356 kfree(fore200e_vcc);
1361 /* reserve bandwidth */
1362 fore200e->available_cell_rate -= vcc->qos.txtp.max_pcr;
1363 mutex_unlock(&fore200e->rate_mtx);
1366 vcc->itf = vcc->dev->number;
1368 set_bit(ATM_VF_PARTIAL,&vcc->flags);
1369 set_bit(ATM_VF_ADDR, &vcc->flags);
1371 vcc->dev_data = fore200e_vcc;
1373 if (fore200e_activate_vcin(fore200e, 1, vcc, vcc->qos.rxtp.max_sdu) < 0) {
1377 clear_bit(ATM_VF_ADDR, &vcc->flags);
1378 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1380 vcc->dev_data = NULL;
1382 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1384 kfree(fore200e_vcc);
1388 /* compute rate control parameters */
1389 if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1391 fore200e_rate_ctrl(&vcc->qos, &fore200e_vcc->rate);
1392 set_bit(ATM_VF_HASQOS, &vcc->flags);
1394 DPRINTK(3, "tx on %d.%d.%d:%d, tx PCR = %d, rx PCR = %d, data_cells = %u, idle_cells = %u\n",
1395 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1396 vcc->qos.txtp.max_pcr, vcc->qos.rxtp.max_pcr,
1397 fore200e_vcc->rate.data_cells, fore200e_vcc->rate.idle_cells);
1400 fore200e_vcc->tx_min_pdu = fore200e_vcc->rx_min_pdu = MAX_PDU_SIZE + 1;
1401 fore200e_vcc->tx_max_pdu = fore200e_vcc->rx_max_pdu = 0;
1402 fore200e_vcc->tx_pdu = fore200e_vcc->rx_pdu = 0;
1404 /* new incarnation of the vcc */
1405 vc_map->incarn = ++fore200e->incarn_count;
1407 /* VC unusable before this flag is set */
1408 set_bit(ATM_VF_READY, &vcc->flags);
1415 fore200e_close(struct atm_vcc* vcc)
1417 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1418 struct fore200e_vcc* fore200e_vcc;
1419 struct fore200e_vc_map* vc_map;
1420 unsigned long flags;
1423 ASSERT((vcc->vpi >= 0) && (vcc->vpi < 1<<FORE200E_VPI_BITS));
1424 ASSERT((vcc->vci >= 0) && (vcc->vci < 1<<FORE200E_VCI_BITS));
1426 DPRINTK(2, "closing %d.%d.%d:%d\n", vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal));
1428 clear_bit(ATM_VF_READY, &vcc->flags);
1430 fore200e_activate_vcin(fore200e, 0, vcc, 0);
1432 spin_lock_irqsave(&fore200e->q_lock, flags);
1434 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1436 /* the vc is no longer considered as "in use" by fore200e_open() */
1439 vcc->itf = vcc->vci = vcc->vpi = 0;
1441 fore200e_vcc = FORE200E_VCC(vcc);
1442 vcc->dev_data = NULL;
1444 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1446 /* release reserved bandwidth, if any */
1447 if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1449 mutex_lock(&fore200e->rate_mtx);
1450 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1451 mutex_unlock(&fore200e->rate_mtx);
1453 clear_bit(ATM_VF_HASQOS, &vcc->flags);
1456 clear_bit(ATM_VF_ADDR, &vcc->flags);
1457 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1459 ASSERT(fore200e_vcc);
1460 kfree(fore200e_vcc);
1465 fore200e_send(struct atm_vcc *vcc, struct sk_buff *skb)
1467 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1468 struct fore200e_vcc* fore200e_vcc = FORE200E_VCC(vcc);
1469 struct fore200e_vc_map* vc_map;
1470 struct host_txq* txq = &fore200e->host_txq;
1471 struct host_txq_entry* entry;
1473 struct tpd_haddr tpd_haddr;
1474 int retry = CONFIG_ATM_FORE200E_TX_RETRY;
1476 int tx_len = skb->len;
1477 u32* cell_header = NULL;
1478 unsigned char* skb_data;
1480 unsigned char* data;
1481 unsigned long flags;
1485 ASSERT(fore200e_vcc);
1487 if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1488 DPRINTK(1, "VC %d.%d.%d not ready for tx\n", vcc->itf, vcc->vpi, vcc->vpi);
1489 dev_kfree_skb_any(skb);
1493 #ifdef FORE200E_52BYTE_AAL0_SDU
1494 if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.txtp.max_sdu == ATM_AAL0_SDU)) {
1495 cell_header = (u32*) skb->data;
1496 skb_data = skb->data + 4; /* skip 4-byte cell header */
1497 skb_len = tx_len = skb->len - 4;
1499 DPRINTK(3, "user-supplied cell header = 0x%08x\n", *cell_header);
1504 skb_data = skb->data;
1508 if (((unsigned long)skb_data) & 0x3) {
1510 DPRINTK(2, "misaligned tx PDU on device %s\n", fore200e->name);
1515 if ((vcc->qos.aal == ATM_AAL0) && (skb_len % ATM_CELL_PAYLOAD)) {
1517 /* this simply NUKES the PCA board */
1518 DPRINTK(2, "incomplete tx AAL0 PDU on device %s\n", fore200e->name);
1520 tx_len = ((skb_len / ATM_CELL_PAYLOAD) + 1) * ATM_CELL_PAYLOAD;
1524 data = kmalloc(tx_len, GFP_ATOMIC);
1530 dev_kfree_skb_any(skb);
1535 memcpy(data, skb_data, skb_len);
1536 if (skb_len < tx_len)
1537 memset(data + skb_len, 0x00, tx_len - skb_len);
1543 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1544 ASSERT(vc_map->vcc == vcc);
1548 spin_lock_irqsave(&fore200e->q_lock, flags);
1550 entry = &txq->host_entry[ txq->head ];
1552 if ((*entry->status != STATUS_FREE) || (txq->txing >= QUEUE_SIZE_TX - 2)) {
1554 /* try to free completed tx queue entries */
1555 fore200e_tx_irq(fore200e);
1557 if (*entry->status != STATUS_FREE) {
1559 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1561 /* retry once again? */
1567 atomic_inc(&vcc->stats->tx_err);
1570 DPRINTK(2, "tx queue of device %s is saturated, PDU dropped - heartbeat is %08x\n",
1571 fore200e->name, fore200e->cp_queues->heartbeat);
1576 dev_kfree_skb_any(skb);
1586 entry->incarn = vc_map->incarn;
1587 entry->vc_map = vc_map;
1589 entry->data = tx_copy ? data : NULL;
1592 tpd->tsd[ 0 ].buffer = dma_map_single(fore200e->dev, data, tx_len,
1594 if (dma_mapping_error(fore200e->dev, tpd->tsd[0].buffer)) {
1597 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1600 tpd->tsd[ 0 ].length = tx_len;
1602 FORE200E_NEXT_ENTRY(txq->head, QUEUE_SIZE_TX);
1605 /* The dma_map call above implies a dma_sync so the device can use it,
1606 * thus no explicit dma_sync call is necessary here.
1609 DPRINTK(3, "tx on %d.%d.%d:%d, len = %u (%u)\n",
1610 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1611 tpd->tsd[0].length, skb_len);
1613 if (skb_len < fore200e_vcc->tx_min_pdu)
1614 fore200e_vcc->tx_min_pdu = skb_len;
1615 if (skb_len > fore200e_vcc->tx_max_pdu)
1616 fore200e_vcc->tx_max_pdu = skb_len;
1617 fore200e_vcc->tx_pdu++;
1619 /* set tx rate control information */
1620 tpd->rate.data_cells = fore200e_vcc->rate.data_cells;
1621 tpd->rate.idle_cells = fore200e_vcc->rate.idle_cells;
1624 tpd->atm_header.clp = (*cell_header & ATM_HDR_CLP);
1625 tpd->atm_header.plt = (*cell_header & ATM_HDR_PTI_MASK) >> ATM_HDR_PTI_SHIFT;
1626 tpd->atm_header.vci = (*cell_header & ATM_HDR_VCI_MASK) >> ATM_HDR_VCI_SHIFT;
1627 tpd->atm_header.vpi = (*cell_header & ATM_HDR_VPI_MASK) >> ATM_HDR_VPI_SHIFT;
1628 tpd->atm_header.gfc = (*cell_header & ATM_HDR_GFC_MASK) >> ATM_HDR_GFC_SHIFT;
1631 /* set the ATM header, common to all cells conveying the PDU */
1632 tpd->atm_header.clp = 0;
1633 tpd->atm_header.plt = 0;
1634 tpd->atm_header.vci = vcc->vci;
1635 tpd->atm_header.vpi = vcc->vpi;
1636 tpd->atm_header.gfc = 0;
1639 tpd->spec.length = tx_len;
1641 tpd->spec.aal = fore200e_atm2fore_aal(vcc->qos.aal);
1644 tpd_haddr.size = sizeof(struct tpd) / (1<<TPD_HADDR_SHIFT); /* size is expressed in 32 byte blocks */
1646 tpd_haddr.haddr = entry->tpd_dma >> TPD_HADDR_SHIFT; /* shift the address, as we are in a bitfield */
1648 *entry->status = STATUS_PENDING;
1649 fore200e->bus->write(*(u32*)&tpd_haddr, (u32 __iomem *)&entry->cp_entry->tpd_haddr);
1651 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1658 fore200e_getstats(struct fore200e* fore200e)
1660 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1661 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1662 struct stats_opcode opcode;
1666 if (fore200e->stats == NULL) {
1667 fore200e->stats = kzalloc(sizeof(struct stats), GFP_KERNEL);
1668 if (fore200e->stats == NULL)
1672 stats_dma_addr = dma_map_single(fore200e->dev, fore200e->stats,
1673 sizeof(struct stats), DMA_FROM_DEVICE);
1674 if (dma_mapping_error(fore200e->dev, stats_dma_addr))
1677 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1679 opcode.opcode = OPCODE_GET_STATS;
1682 fore200e->bus->write(stats_dma_addr, &entry->cp_entry->cmd.stats_block.stats_haddr);
1684 *entry->status = STATUS_PENDING;
1686 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.stats_block.opcode);
1688 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1690 *entry->status = STATUS_FREE;
1692 dma_unmap_single(fore200e->dev, stats_dma_addr, sizeof(struct stats), DMA_FROM_DEVICE);
1695 printk(FORE200E "unable to get statistics from device %s\n", fore200e->name);
1704 fore200e_getsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, int optlen)
1706 /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1708 DPRINTK(2, "getsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1709 vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1716 fore200e_setsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, unsigned int optlen)
1718 /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1720 DPRINTK(2, "setsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1721 vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1727 #if 0 /* currently unused */
1729 fore200e_get_oc3(struct fore200e* fore200e, struct oc3_regs* regs)
1731 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1732 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1733 struct oc3_opcode opcode;
1735 u32 oc3_regs_dma_addr;
1737 oc3_regs_dma_addr = fore200e->bus->dma_map(fore200e, regs, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1739 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1741 opcode.opcode = OPCODE_GET_OC3;
1746 fore200e->bus->write(oc3_regs_dma_addr, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1748 *entry->status = STATUS_PENDING;
1750 fore200e->bus->write(*(u32*)&opcode, (u32*)&entry->cp_entry->cmd.oc3_block.opcode);
1752 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1754 *entry->status = STATUS_FREE;
1756 fore200e->bus->dma_unmap(fore200e, oc3_regs_dma_addr, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1759 printk(FORE200E "unable to get OC-3 regs of device %s\n", fore200e->name);
1769 fore200e_set_oc3(struct fore200e* fore200e, u32 reg, u32 value, u32 mask)
1771 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1772 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1773 struct oc3_opcode opcode;
1776 DPRINTK(2, "set OC-3 reg = 0x%02x, value = 0x%02x, mask = 0x%02x\n", reg, value, mask);
1778 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1780 opcode.opcode = OPCODE_SET_OC3;
1782 opcode.value = value;
1785 fore200e->bus->write(0, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1787 *entry->status = STATUS_PENDING;
1789 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.oc3_block.opcode);
1791 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1793 *entry->status = STATUS_FREE;
1796 printk(FORE200E "unable to set OC-3 reg 0x%02x of device %s\n", reg, fore200e->name);
1805 fore200e_setloop(struct fore200e* fore200e, int loop_mode)
1807 u32 mct_value, mct_mask;
1810 if (!capable(CAP_NET_ADMIN))
1813 switch (loop_mode) {
1817 mct_mask = SUNI_MCT_DLE | SUNI_MCT_LLE;
1820 case ATM_LM_LOC_PHY:
1821 mct_value = mct_mask = SUNI_MCT_DLE;
1824 case ATM_LM_RMT_PHY:
1825 mct_value = mct_mask = SUNI_MCT_LLE;
1832 error = fore200e_set_oc3(fore200e, SUNI_MCT, mct_value, mct_mask);
1834 fore200e->loop_mode = loop_mode;
1841 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
1843 struct sonet_stats tmp;
1845 if (fore200e_getstats(fore200e) < 0)
1848 tmp.section_bip = be32_to_cpu(fore200e->stats->oc3.section_bip8_errors);
1849 tmp.line_bip = be32_to_cpu(fore200e->stats->oc3.line_bip24_errors);
1850 tmp.path_bip = be32_to_cpu(fore200e->stats->oc3.path_bip8_errors);
1851 tmp.line_febe = be32_to_cpu(fore200e->stats->oc3.line_febe_errors);
1852 tmp.path_febe = be32_to_cpu(fore200e->stats->oc3.path_febe_errors);
1853 tmp.corr_hcs = be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors);
1854 tmp.uncorr_hcs = be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors);
1855 tmp.tx_cells = be32_to_cpu(fore200e->stats->aal0.cells_transmitted) +
1856 be32_to_cpu(fore200e->stats->aal34.cells_transmitted) +
1857 be32_to_cpu(fore200e->stats->aal5.cells_transmitted);
1858 tmp.rx_cells = be32_to_cpu(fore200e->stats->aal0.cells_received) +
1859 be32_to_cpu(fore200e->stats->aal34.cells_received) +
1860 be32_to_cpu(fore200e->stats->aal5.cells_received);
1863 return copy_to_user(arg, &tmp, sizeof(struct sonet_stats)) ? -EFAULT : 0;
1870 fore200e_ioctl(struct atm_dev* dev, unsigned int cmd, void __user * arg)
1872 struct fore200e* fore200e = FORE200E_DEV(dev);
1874 DPRINTK(2, "ioctl cmd = 0x%x (%u), arg = 0x%p (%lu)\n", cmd, cmd, arg, (unsigned long)arg);
1879 return fore200e_fetch_stats(fore200e, (struct sonet_stats __user *)arg);
1882 return put_user(0, (int __user *)arg) ? -EFAULT : 0;
1885 return fore200e_setloop(fore200e, (int)(unsigned long)arg);
1888 return put_user(fore200e->loop_mode, (int __user *)arg) ? -EFAULT : 0;
1891 return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY, (int __user *)arg) ? -EFAULT : 0;
1894 return -ENOSYS; /* not implemented */
1899 fore200e_change_qos(struct atm_vcc* vcc,struct atm_qos* qos, int flags)
1901 struct fore200e_vcc* fore200e_vcc = FORE200E_VCC(vcc);
1902 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1904 if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1905 DPRINTK(1, "VC %d.%d.%d not ready for QoS change\n", vcc->itf, vcc->vpi, vcc->vpi);
1909 DPRINTK(2, "change_qos %d.%d.%d, "
1910 "(tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1911 "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d), flags = 0x%x\n"
1912 "available_cell_rate = %u",
1913 vcc->itf, vcc->vpi, vcc->vci,
1914 fore200e_traffic_class[ qos->txtp.traffic_class ],
1915 qos->txtp.min_pcr, qos->txtp.max_pcr, qos->txtp.max_cdv, qos->txtp.max_sdu,
1916 fore200e_traffic_class[ qos->rxtp.traffic_class ],
1917 qos->rxtp.min_pcr, qos->rxtp.max_pcr, qos->rxtp.max_cdv, qos->rxtp.max_sdu,
1918 flags, fore200e->available_cell_rate);
1920 if ((qos->txtp.traffic_class == ATM_CBR) && (qos->txtp.max_pcr > 0)) {
1922 mutex_lock(&fore200e->rate_mtx);
1923 if (fore200e->available_cell_rate + vcc->qos.txtp.max_pcr < qos->txtp.max_pcr) {
1924 mutex_unlock(&fore200e->rate_mtx);
1928 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1929 fore200e->available_cell_rate -= qos->txtp.max_pcr;
1931 mutex_unlock(&fore200e->rate_mtx);
1933 memcpy(&vcc->qos, qos, sizeof(struct atm_qos));
1935 /* update rate control parameters */
1936 fore200e_rate_ctrl(qos, &fore200e_vcc->rate);
1938 set_bit(ATM_VF_HASQOS, &vcc->flags);
1947 static int fore200e_irq_request(struct fore200e *fore200e)
1949 if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
1951 printk(FORE200E "unable to reserve IRQ %s for device %s\n",
1952 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1956 printk(FORE200E "IRQ %s reserved for device %s\n",
1957 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1959 #ifdef FORE200E_USE_TASKLET
1960 tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
1961 tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
1964 fore200e->state = FORE200E_STATE_IRQ;
1969 static int fore200e_get_esi(struct fore200e *fore200e)
1971 struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL);
1977 ok = fore200e->bus->prom_read(fore200e, prom);
1983 printk(FORE200E "device %s, rev. %c, S/N: %d, ESI: %pM\n",
1985 (prom->hw_revision & 0xFF) + '@', /* probably meaningless with SBA boards */
1986 prom->serial_number & 0xFFFF, &prom->mac_addr[2]);
1988 for (i = 0; i < ESI_LEN; i++) {
1989 fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
1998 static int fore200e_alloc_rx_buf(struct fore200e *fore200e)
2000 int scheme, magn, nbr, size, i;
2002 struct host_bsq* bsq;
2003 struct buffer* buffer;
2005 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2006 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2008 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2010 nbr = fore200e_rx_buf_nbr[ scheme ][ magn ];
2011 size = fore200e_rx_buf_size[ scheme ][ magn ];
2013 DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
2015 /* allocate the array of receive buffers */
2016 buffer = bsq->buffer = kcalloc(nbr, sizeof(struct buffer),
2022 bsq->freebuf = NULL;
2024 for (i = 0; i < nbr; i++) {
2026 buffer[ i ].scheme = scheme;
2027 buffer[ i ].magn = magn;
2028 #ifdef FORE200E_BSQ_DEBUG
2029 buffer[ i ].index = i;
2030 buffer[ i ].supplied = 0;
2033 /* allocate the receive buffer body */
2034 if (fore200e_chunk_alloc(fore200e,
2035 &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2036 DMA_FROM_DEVICE) < 0) {
2039 fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2045 /* insert the buffer into the free buffer list */
2046 buffer[ i ].next = bsq->freebuf;
2047 bsq->freebuf = &buffer[ i ];
2049 /* all the buffers are free, initially */
2050 bsq->freebuf_count = nbr;
2052 #ifdef FORE200E_BSQ_DEBUG
2053 bsq_audit(3, bsq, scheme, magn);
2058 fore200e->state = FORE200E_STATE_ALLOC_BUF;
2063 static int fore200e_init_bs_queue(struct fore200e *fore200e)
2065 int scheme, magn, i;
2067 struct host_bsq* bsq;
2068 struct cp_bsq_entry __iomem * cp_entry;
2070 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2071 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2073 DPRINTK(2, "buffer supply queue %d / %d is being initialized\n", scheme, magn);
2075 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2077 /* allocate and align the array of status words */
2078 if (fore200e_dma_chunk_alloc(fore200e,
2080 sizeof(enum status),
2082 fore200e->bus->status_alignment) < 0) {
2086 /* allocate and align the array of receive buffer descriptors */
2087 if (fore200e_dma_chunk_alloc(fore200e,
2089 sizeof(struct rbd_block),
2091 fore200e->bus->descr_alignment) < 0) {
2093 fore200e_dma_chunk_free(fore200e, &bsq->status);
2097 /* get the base address of the cp resident buffer supply queue entries */
2098 cp_entry = fore200e->virt_base +
2099 fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2101 /* fill the host resident and cp resident buffer supply queue entries */
2102 for (i = 0; i < QUEUE_SIZE_BS; i++) {
2104 bsq->host_entry[ i ].status =
2105 FORE200E_INDEX(bsq->status.align_addr, enum status, i);
2106 bsq->host_entry[ i ].rbd_block =
2107 FORE200E_INDEX(bsq->rbd_block.align_addr, struct rbd_block, i);
2108 bsq->host_entry[ i ].rbd_block_dma =
2109 FORE200E_DMA_INDEX(bsq->rbd_block.dma_addr, struct rbd_block, i);
2110 bsq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2112 *bsq->host_entry[ i ].status = STATUS_FREE;
2114 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i),
2115 &cp_entry[ i ].status_haddr);
2120 fore200e->state = FORE200E_STATE_INIT_BSQ;
2125 static int fore200e_init_rx_queue(struct fore200e *fore200e)
2127 struct host_rxq* rxq = &fore200e->host_rxq;
2128 struct cp_rxq_entry __iomem * cp_entry;
2131 DPRINTK(2, "receive queue is being initialized\n");
2133 /* allocate and align the array of status words */
2134 if (fore200e_dma_chunk_alloc(fore200e,
2136 sizeof(enum status),
2138 fore200e->bus->status_alignment) < 0) {
2142 /* allocate and align the array of receive PDU descriptors */
2143 if (fore200e_dma_chunk_alloc(fore200e,
2147 fore200e->bus->descr_alignment) < 0) {
2149 fore200e_dma_chunk_free(fore200e, &rxq->status);
2153 /* get the base address of the cp resident rx queue entries */
2154 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2156 /* fill the host resident and cp resident rx entries */
2157 for (i=0; i < QUEUE_SIZE_RX; i++) {
2159 rxq->host_entry[ i ].status =
2160 FORE200E_INDEX(rxq->status.align_addr, enum status, i);
2161 rxq->host_entry[ i ].rpd =
2162 FORE200E_INDEX(rxq->rpd.align_addr, struct rpd, i);
2163 rxq->host_entry[ i ].rpd_dma =
2164 FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i);
2165 rxq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2167 *rxq->host_entry[ i ].status = STATUS_FREE;
2169 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i),
2170 &cp_entry[ i ].status_haddr);
2172 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2173 &cp_entry[ i ].rpd_haddr);
2176 /* set the head entry of the queue */
2179 fore200e->state = FORE200E_STATE_INIT_RXQ;
2184 static int fore200e_init_tx_queue(struct fore200e *fore200e)
2186 struct host_txq* txq = &fore200e->host_txq;
2187 struct cp_txq_entry __iomem * cp_entry;
2190 DPRINTK(2, "transmit queue is being initialized\n");
2192 /* allocate and align the array of status words */
2193 if (fore200e_dma_chunk_alloc(fore200e,
2195 sizeof(enum status),
2197 fore200e->bus->status_alignment) < 0) {
2201 /* allocate and align the array of transmit PDU descriptors */
2202 if (fore200e_dma_chunk_alloc(fore200e,
2206 fore200e->bus->descr_alignment) < 0) {
2208 fore200e_dma_chunk_free(fore200e, &txq->status);
2212 /* get the base address of the cp resident tx queue entries */
2213 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2215 /* fill the host resident and cp resident tx entries */
2216 for (i=0; i < QUEUE_SIZE_TX; i++) {
2218 txq->host_entry[ i ].status =
2219 FORE200E_INDEX(txq->status.align_addr, enum status, i);
2220 txq->host_entry[ i ].tpd =
2221 FORE200E_INDEX(txq->tpd.align_addr, struct tpd, i);
2222 txq->host_entry[ i ].tpd_dma =
2223 FORE200E_DMA_INDEX(txq->tpd.dma_addr, struct tpd, i);
2224 txq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2226 *txq->host_entry[ i ].status = STATUS_FREE;
2228 fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i),
2229 &cp_entry[ i ].status_haddr);
2231 /* although there is a one-to-one mapping of tx queue entries and tpds,
2232 we do not write here the DMA (physical) base address of each tpd into
2233 the related cp resident entry, because the cp relies on this write
2234 operation to detect that a new pdu has been submitted for tx */
2237 /* set the head and tail entries of the queue */
2241 fore200e->state = FORE200E_STATE_INIT_TXQ;
2246 static int fore200e_init_cmd_queue(struct fore200e *fore200e)
2248 struct host_cmdq* cmdq = &fore200e->host_cmdq;
2249 struct cp_cmdq_entry __iomem * cp_entry;
2252 DPRINTK(2, "command queue is being initialized\n");
2254 /* allocate and align the array of status words */
2255 if (fore200e_dma_chunk_alloc(fore200e,
2257 sizeof(enum status),
2259 fore200e->bus->status_alignment) < 0) {
2263 /* get the base address of the cp resident cmd queue entries */
2264 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2266 /* fill the host resident and cp resident cmd entries */
2267 for (i=0; i < QUEUE_SIZE_CMD; i++) {
2269 cmdq->host_entry[ i ].status =
2270 FORE200E_INDEX(cmdq->status.align_addr, enum status, i);
2271 cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2273 *cmdq->host_entry[ i ].status = STATUS_FREE;
2275 fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),
2276 &cp_entry[ i ].status_haddr);
2279 /* set the head entry of the queue */
2282 fore200e->state = FORE200E_STATE_INIT_CMDQ;
2287 static void fore200e_param_bs_queue(struct fore200e *fore200e,
2288 enum buffer_scheme scheme,
2289 enum buffer_magn magn, int queue_length,
2290 int pool_size, int supply_blksize)
2292 struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2294 fore200e->bus->write(queue_length, &bs_spec->queue_length);
2295 fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2296 fore200e->bus->write(pool_size, &bs_spec->pool_size);
2297 fore200e->bus->write(supply_blksize, &bs_spec->supply_blksize);
2301 static int fore200e_initialize(struct fore200e *fore200e)
2303 struct cp_queues __iomem * cpq;
2304 int ok, scheme, magn;
2306 DPRINTK(2, "device %s being initialized\n", fore200e->name);
2308 mutex_init(&fore200e->rate_mtx);
2309 spin_lock_init(&fore200e->q_lock);
2311 cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2313 /* enable cp to host interrupts */
2314 fore200e->bus->write(1, &cpq->imask);
2316 if (fore200e->bus->irq_enable)
2317 fore200e->bus->irq_enable(fore200e);
2319 fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2321 fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2322 fore200e->bus->write(QUEUE_SIZE_RX, &cpq->init.rx_queue_len);
2323 fore200e->bus->write(QUEUE_SIZE_TX, &cpq->init.tx_queue_len);
2325 fore200e->bus->write(RSD_EXTENSION, &cpq->init.rsd_extension);
2326 fore200e->bus->write(TSD_EXTENSION, &cpq->init.tsd_extension);
2328 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++)
2329 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++)
2330 fore200e_param_bs_queue(fore200e, scheme, magn,
2332 fore200e_rx_buf_nbr[ scheme ][ magn ],
2335 /* issue the initialize command */
2336 fore200e->bus->write(STATUS_PENDING, &cpq->init.status);
2337 fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2339 ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2341 printk(FORE200E "device %s initialization failed\n", fore200e->name);
2345 printk(FORE200E "device %s initialized\n", fore200e->name);
2347 fore200e->state = FORE200E_STATE_INITIALIZE;
2352 static void fore200e_monitor_putc(struct fore200e *fore200e, char c)
2354 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2359 fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2363 static int fore200e_monitor_getc(struct fore200e *fore200e)
2365 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2366 unsigned long timeout = jiffies + msecs_to_jiffies(50);
2369 while (time_before(jiffies, timeout)) {
2371 c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2373 if (c & FORE200E_CP_MONITOR_UART_AVAIL) {
2375 fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2377 printk("%c", c & 0xFF);
2387 static void fore200e_monitor_puts(struct fore200e *fore200e, char *str)
2391 /* the i960 monitor doesn't accept any new character if it has something to say */
2392 while (fore200e_monitor_getc(fore200e) >= 0);
2394 fore200e_monitor_putc(fore200e, *str++);
2397 while (fore200e_monitor_getc(fore200e) >= 0);
2400 #ifdef __LITTLE_ENDIAN
2401 #define FW_EXT ".bin"
2403 #define FW_EXT "_ecd.bin2"
2406 static int fore200e_load_and_start_fw(struct fore200e *fore200e)
2408 const struct firmware *firmware;
2409 const struct fw_header *fw_header;
2410 const __le32 *fw_data;
2412 u32 __iomem *load_addr;
2416 sprintf(buf, "%s%s", fore200e->bus->proc_name, FW_EXT);
2417 if ((err = request_firmware(&firmware, buf, fore200e->dev)) < 0) {
2418 printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
2422 fw_data = (const __le32 *)firmware->data;
2423 fw_size = firmware->size / sizeof(u32);
2424 fw_header = (const struct fw_header *)firmware->data;
2425 load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2427 DPRINTK(2, "device %s firmware being loaded at 0x%p (%d words)\n",
2428 fore200e->name, load_addr, fw_size);
2430 if (le32_to_cpu(fw_header->magic) != FW_HEADER_MAGIC) {
2431 printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2435 for (; fw_size--; fw_data++, load_addr++)
2436 fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2438 DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2440 #if defined(__sparc_v9__)
2441 /* reported to be required by SBA cards on some sparc64 hosts */
2445 sprintf(buf, "\rgo %x\r", le32_to_cpu(fw_header->start_offset));
2446 fore200e_monitor_puts(fore200e, buf);
2448 if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2449 printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2453 printk(FORE200E "device %s firmware started\n", fore200e->name);
2455 fore200e->state = FORE200E_STATE_START_FW;
2459 release_firmware(firmware);
2464 static int fore200e_register(struct fore200e *fore200e, struct device *parent)
2466 struct atm_dev* atm_dev;
2468 DPRINTK(2, "device %s being registered\n", fore200e->name);
2470 atm_dev = atm_dev_register(fore200e->bus->proc_name, parent, &fore200e_ops,
2472 if (atm_dev == NULL) {
2473 printk(FORE200E "unable to register device %s\n", fore200e->name);
2477 atm_dev->dev_data = fore200e;
2478 fore200e->atm_dev = atm_dev;
2480 atm_dev->ci_range.vpi_bits = FORE200E_VPI_BITS;
2481 atm_dev->ci_range.vci_bits = FORE200E_VCI_BITS;
2483 fore200e->available_cell_rate = ATM_OC3_PCR;
2485 fore200e->state = FORE200E_STATE_REGISTER;
2490 static int fore200e_init(struct fore200e *fore200e, struct device *parent)
2492 if (fore200e_register(fore200e, parent) < 0)
2495 if (fore200e->bus->configure(fore200e) < 0)
2498 if (fore200e->bus->map(fore200e) < 0)
2501 if (fore200e_reset(fore200e, 1) < 0)
2504 if (fore200e_load_and_start_fw(fore200e) < 0)
2507 if (fore200e_initialize(fore200e) < 0)
2510 if (fore200e_init_cmd_queue(fore200e) < 0)
2513 if (fore200e_init_tx_queue(fore200e) < 0)
2516 if (fore200e_init_rx_queue(fore200e) < 0)
2519 if (fore200e_init_bs_queue(fore200e) < 0)
2522 if (fore200e_alloc_rx_buf(fore200e) < 0)
2525 if (fore200e_get_esi(fore200e) < 0)
2528 if (fore200e_irq_request(fore200e) < 0)
2531 fore200e_supply(fore200e);
2533 /* all done, board initialization is now complete */
2534 fore200e->state = FORE200E_STATE_COMPLETE;
2539 static const struct of_device_id fore200e_sba_match[];
2540 static int fore200e_sba_probe(struct platform_device *op)
2542 const struct of_device_id *match;
2543 struct fore200e *fore200e;
2544 static int index = 0;
2547 match = of_match_device(fore200e_sba_match, &op->dev);
2551 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2555 fore200e->bus = &fore200e_sbus_ops;
2556 fore200e->dev = &op->dev;
2557 fore200e->irq = op->archdata.irqs[0];
2558 fore200e->phys_base = op->resource[0].start;
2560 sprintf(fore200e->name, "SBA-200E-%d", index);
2562 err = fore200e_init(fore200e, &op->dev);
2564 fore200e_shutdown(fore200e);
2570 dev_set_drvdata(&op->dev, fore200e);
2575 static int fore200e_sba_remove(struct platform_device *op)
2577 struct fore200e *fore200e = dev_get_drvdata(&op->dev);
2579 fore200e_shutdown(fore200e);
2585 static const struct of_device_id fore200e_sba_match[] = {
2587 .name = SBA200E_PROM_NAME,
2591 MODULE_DEVICE_TABLE(of, fore200e_sba_match);
2593 static struct platform_driver fore200e_sba_driver = {
2595 .name = "fore_200e",
2596 .of_match_table = fore200e_sba_match,
2598 .probe = fore200e_sba_probe,
2599 .remove = fore200e_sba_remove,
2604 static int fore200e_pca_detect(struct pci_dev *pci_dev,
2605 const struct pci_device_id *pci_ent)
2607 struct fore200e* fore200e;
2609 static int index = 0;
2611 if (pci_enable_device(pci_dev)) {
2616 if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) {
2621 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2622 if (fore200e == NULL) {
2627 fore200e->bus = &fore200e_pci_ops;
2628 fore200e->dev = &pci_dev->dev;
2629 fore200e->irq = pci_dev->irq;
2630 fore200e->phys_base = pci_resource_start(pci_dev, 0);
2632 sprintf(fore200e->name, "PCA-200E-%d", index - 1);
2634 pci_set_master(pci_dev);
2636 printk(FORE200E "device PCA-200E found at 0x%lx, IRQ %s\n",
2637 fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2639 sprintf(fore200e->name, "PCA-200E-%d", index);
2641 err = fore200e_init(fore200e, &pci_dev->dev);
2643 fore200e_shutdown(fore200e);
2648 pci_set_drvdata(pci_dev, fore200e);
2656 pci_disable_device(pci_dev);
2661 static void fore200e_pca_remove_one(struct pci_dev *pci_dev)
2663 struct fore200e *fore200e;
2665 fore200e = pci_get_drvdata(pci_dev);
2667 fore200e_shutdown(fore200e);
2669 pci_disable_device(pci_dev);
2673 static const struct pci_device_id fore200e_pca_tbl[] = {
2674 { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_PCA200E, PCI_ANY_ID, PCI_ANY_ID },
2678 MODULE_DEVICE_TABLE(pci, fore200e_pca_tbl);
2680 static struct pci_driver fore200e_pca_driver = {
2681 .name = "fore_200e",
2682 .probe = fore200e_pca_detect,
2683 .remove = fore200e_pca_remove_one,
2684 .id_table = fore200e_pca_tbl,
2688 static int __init fore200e_module_init(void)
2692 printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
2695 err = platform_driver_register(&fore200e_sba_driver);
2701 err = pci_register_driver(&fore200e_pca_driver);
2706 platform_driver_unregister(&fore200e_sba_driver);
2712 static void __exit fore200e_module_cleanup(void)
2715 pci_unregister_driver(&fore200e_pca_driver);
2718 platform_driver_unregister(&fore200e_sba_driver);
2723 fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
2725 struct fore200e* fore200e = FORE200E_DEV(dev);
2726 struct fore200e_vcc* fore200e_vcc;
2727 struct atm_vcc* vcc;
2728 int i, len, left = *pos;
2729 unsigned long flags;
2733 if (fore200e_getstats(fore200e) < 0)
2736 len = sprintf(page,"\n"
2738 " internal name:\t\t%s\n", fore200e->name);
2740 /* print bus-specific information */
2741 if (fore200e->bus->proc_read)
2742 len += fore200e->bus->proc_read(fore200e, page + len);
2744 len += sprintf(page + len,
2745 " interrupt line:\t\t%s\n"
2746 " physical base address:\t0x%p\n"
2747 " virtual base address:\t0x%p\n"
2748 " factory address (ESI):\t%pM\n"
2749 " board serial number:\t\t%d\n\n",
2750 fore200e_irq_itoa(fore200e->irq),
2751 (void*)fore200e->phys_base,
2752 fore200e->virt_base,
2754 fore200e->esi[4] * 256 + fore200e->esi[5]);
2760 return sprintf(page,
2761 " free small bufs, scheme 1:\t%d\n"
2762 " free large bufs, scheme 1:\t%d\n"
2763 " free small bufs, scheme 2:\t%d\n"
2764 " free large bufs, scheme 2:\t%d\n",
2765 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2766 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2767 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2768 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2771 u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2773 len = sprintf(page,"\n\n"
2774 " cell processor:\n"
2775 " heartbeat state:\t\t");
2777 if (hb >> 16 != 0xDEAD)
2778 len += sprintf(page + len, "0x%08x\n", hb);
2780 len += sprintf(page + len, "*** FATAL ERROR %04x ***\n", hb & 0xFFFF);
2786 static const char* media_name[] = {
2787 "unshielded twisted pair",
2788 "multimode optical fiber ST",
2789 "multimode optical fiber SC",
2790 "single-mode optical fiber ST",
2791 "single-mode optical fiber SC",
2795 static const char* oc3_mode[] = {
2797 "diagnostic loopback",
2802 u32 fw_release = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2803 u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2804 u32 oc3_revision = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2805 u32 media_index = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2808 if (media_index > 4)
2811 switch (fore200e->loop_mode) {
2812 case ATM_LM_NONE: oc3_index = 0;
2814 case ATM_LM_LOC_PHY: oc3_index = 1;
2816 case ATM_LM_RMT_PHY: oc3_index = 2;
2818 default: oc3_index = 3;
2821 return sprintf(page,
2822 " firmware release:\t\t%d.%d.%d\n"
2823 " monitor release:\t\t%d.%d\n"
2824 " media type:\t\t\t%s\n"
2825 " OC-3 revision:\t\t0x%x\n"
2826 " OC-3 mode:\t\t\t%s",
2827 fw_release >> 16, fw_release << 16 >> 24, fw_release << 24 >> 24,
2828 mon960_release >> 16, mon960_release << 16 >> 16,
2829 media_name[ media_index ],
2831 oc3_mode[ oc3_index ]);
2835 struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2837 return sprintf(page,
2840 " version number:\t\t%d\n"
2841 " boot status word:\t\t0x%08x\n",
2842 fore200e->bus->read(&cp_monitor->mon_version),
2843 fore200e->bus->read(&cp_monitor->bstat));
2847 return sprintf(page,
2849 " device statistics:\n"
2851 " crc_header_errors:\t\t%10u\n"
2852 " framing_errors:\t\t%10u\n",
2853 be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2854 be32_to_cpu(fore200e->stats->phy.framing_errors));
2857 return sprintf(page, "\n"
2859 " section_bip8_errors:\t%10u\n"
2860 " path_bip8_errors:\t\t%10u\n"
2861 " line_bip24_errors:\t\t%10u\n"
2862 " line_febe_errors:\t\t%10u\n"
2863 " path_febe_errors:\t\t%10u\n"
2864 " corr_hcs_errors:\t\t%10u\n"
2865 " ucorr_hcs_errors:\t\t%10u\n",
2866 be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2867 be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2868 be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2869 be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2870 be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2871 be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2872 be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
2875 return sprintf(page,"\n"
2876 " ATM:\t\t\t\t cells\n"
2879 " vpi out of range:\t\t%10u\n"
2880 " vpi no conn:\t\t%10u\n"
2881 " vci out of range:\t\t%10u\n"
2882 " vci no conn:\t\t%10u\n",
2883 be32_to_cpu(fore200e->stats->atm.cells_transmitted),
2884 be32_to_cpu(fore200e->stats->atm.cells_received),
2885 be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
2886 be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
2887 be32_to_cpu(fore200e->stats->atm.vci_bad_range),
2888 be32_to_cpu(fore200e->stats->atm.vci_no_conn));
2891 return sprintf(page,"\n"
2892 " AAL0:\t\t\t cells\n"
2895 " dropped:\t\t\t%10u\n",
2896 be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
2897 be32_to_cpu(fore200e->stats->aal0.cells_received),
2898 be32_to_cpu(fore200e->stats->aal0.cells_dropped));
2901 return sprintf(page,"\n"
2903 " SAR sublayer:\t\t cells\n"
2906 " dropped:\t\t\t%10u\n"
2907 " CRC errors:\t\t%10u\n"
2908 " protocol errors:\t\t%10u\n\n"
2909 " CS sublayer:\t\t PDUs\n"
2912 " dropped:\t\t\t%10u\n"
2913 " protocol errors:\t\t%10u\n",
2914 be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
2915 be32_to_cpu(fore200e->stats->aal34.cells_received),
2916 be32_to_cpu(fore200e->stats->aal34.cells_dropped),
2917 be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
2918 be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
2919 be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
2920 be32_to_cpu(fore200e->stats->aal34.cspdus_received),
2921 be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
2922 be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
2925 return sprintf(page,"\n"
2927 " SAR sublayer:\t\t cells\n"
2930 " dropped:\t\t\t%10u\n"
2931 " congestions:\t\t%10u\n\n"
2932 " CS sublayer:\t\t PDUs\n"
2935 " dropped:\t\t\t%10u\n"
2936 " CRC errors:\t\t%10u\n"
2937 " protocol errors:\t\t%10u\n",
2938 be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
2939 be32_to_cpu(fore200e->stats->aal5.cells_received),
2940 be32_to_cpu(fore200e->stats->aal5.cells_dropped),
2941 be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
2942 be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
2943 be32_to_cpu(fore200e->stats->aal5.cspdus_received),
2944 be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
2945 be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
2946 be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
2949 return sprintf(page,"\n"
2950 " AUX:\t\t allocation failures\n"
2951 " small b1:\t\t\t%10u\n"
2952 " large b1:\t\t\t%10u\n"
2953 " small b2:\t\t\t%10u\n"
2954 " large b2:\t\t\t%10u\n"
2955 " RX PDUs:\t\t\t%10u\n"
2956 " TX PDUs:\t\t\t%10lu\n",
2957 be32_to_cpu(fore200e->stats->aux.small_b1_failed),
2958 be32_to_cpu(fore200e->stats->aux.large_b1_failed),
2959 be32_to_cpu(fore200e->stats->aux.small_b2_failed),
2960 be32_to_cpu(fore200e->stats->aux.large_b2_failed),
2961 be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
2965 return sprintf(page,"\n"
2966 " receive carrier:\t\t\t%s\n",
2967 fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
2970 return sprintf(page,"\n"
2971 " VCCs:\n address VPI VCI AAL "
2972 "TX PDUs TX min/max size RX PDUs RX min/max size\n");
2975 for (i = 0; i < NBR_CONNECT; i++) {
2977 vcc = fore200e->vc_map[i].vcc;
2982 spin_lock_irqsave(&fore200e->q_lock, flags);
2984 if (vcc && test_bit(ATM_VF_READY, &vcc->flags) && !left--) {
2986 fore200e_vcc = FORE200E_VCC(vcc);
2987 ASSERT(fore200e_vcc);
2990 " %pK %03d %05d %1d %09lu %05d/%05d %09lu %05d/%05d\n",
2992 vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
2993 fore200e_vcc->tx_pdu,
2994 fore200e_vcc->tx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->tx_min_pdu,
2995 fore200e_vcc->tx_max_pdu,
2996 fore200e_vcc->rx_pdu,
2997 fore200e_vcc->rx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->rx_min_pdu,
2998 fore200e_vcc->rx_max_pdu);
3000 spin_unlock_irqrestore(&fore200e->q_lock, flags);
3004 spin_unlock_irqrestore(&fore200e->q_lock, flags);
3010 module_init(fore200e_module_init);
3011 module_exit(fore200e_module_cleanup);
3014 static const struct atmdev_ops fore200e_ops = {
3015 .open = fore200e_open,
3016 .close = fore200e_close,
3017 .ioctl = fore200e_ioctl,
3018 .getsockopt = fore200e_getsockopt,
3019 .setsockopt = fore200e_setsockopt,
3020 .send = fore200e_send,
3021 .change_qos = fore200e_change_qos,
3022 .proc_read = fore200e_proc_read,
3023 .owner = THIS_MODULE
3026 MODULE_LICENSE("GPL");
3028 #ifdef __LITTLE_ENDIAN__
3029 MODULE_FIRMWARE("pca200e.bin");
3031 MODULE_FIRMWARE("pca200e_ecd.bin2");
3033 #endif /* CONFIG_PCI */
3035 MODULE_FIRMWARE("sba200e_ecd.bin2");