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_vcc* fore200e_vcc;
1418 struct fore200e* fore200e;
1419 struct fore200e_vc_map* vc_map;
1420 unsigned long flags;
1423 fore200e = FORE200E_DEV(vcc->dev);
1425 ASSERT((vcc->vpi >= 0) && (vcc->vpi < 1<<FORE200E_VPI_BITS));
1426 ASSERT((vcc->vci >= 0) && (vcc->vci < 1<<FORE200E_VCI_BITS));
1428 DPRINTK(2, "closing %d.%d.%d:%d\n", vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal));
1430 clear_bit(ATM_VF_READY, &vcc->flags);
1432 fore200e_activate_vcin(fore200e, 0, vcc, 0);
1434 spin_lock_irqsave(&fore200e->q_lock, flags);
1436 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1438 /* the vc is no longer considered as "in use" by fore200e_open() */
1441 vcc->itf = vcc->vci = vcc->vpi = 0;
1443 fore200e_vcc = FORE200E_VCC(vcc);
1444 vcc->dev_data = NULL;
1446 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1448 /* release reserved bandwidth, if any */
1449 if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1451 mutex_lock(&fore200e->rate_mtx);
1452 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1453 mutex_unlock(&fore200e->rate_mtx);
1455 clear_bit(ATM_VF_HASQOS, &vcc->flags);
1458 clear_bit(ATM_VF_ADDR, &vcc->flags);
1459 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1461 ASSERT(fore200e_vcc);
1462 kfree(fore200e_vcc);
1467 fore200e_send(struct atm_vcc *vcc, struct sk_buff *skb)
1469 struct fore200e* fore200e;
1470 struct fore200e_vcc* fore200e_vcc;
1471 struct fore200e_vc_map* vc_map;
1472 struct host_txq* txq;
1473 struct host_txq_entry* entry;
1475 struct tpd_haddr tpd_haddr;
1476 int retry = CONFIG_ATM_FORE200E_TX_RETRY;
1478 int tx_len = skb->len;
1479 u32* cell_header = NULL;
1480 unsigned char* skb_data;
1482 unsigned char* data;
1483 unsigned long flags;
1488 fore200e = FORE200E_DEV(vcc->dev);
1489 fore200e_vcc = FORE200E_VCC(vcc);
1494 txq = &fore200e->host_txq;
1498 if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1499 DPRINTK(1, "VC %d.%d.%d not ready for tx\n", vcc->itf, vcc->vpi, vcc->vpi);
1500 dev_kfree_skb_any(skb);
1504 #ifdef FORE200E_52BYTE_AAL0_SDU
1505 if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.txtp.max_sdu == ATM_AAL0_SDU)) {
1506 cell_header = (u32*) skb->data;
1507 skb_data = skb->data + 4; /* skip 4-byte cell header */
1508 skb_len = tx_len = skb->len - 4;
1510 DPRINTK(3, "user-supplied cell header = 0x%08x\n", *cell_header);
1515 skb_data = skb->data;
1519 if (((unsigned long)skb_data) & 0x3) {
1521 DPRINTK(2, "misaligned tx PDU on device %s\n", fore200e->name);
1526 if ((vcc->qos.aal == ATM_AAL0) && (skb_len % ATM_CELL_PAYLOAD)) {
1528 /* this simply NUKES the PCA board */
1529 DPRINTK(2, "incomplete tx AAL0 PDU on device %s\n", fore200e->name);
1531 tx_len = ((skb_len / ATM_CELL_PAYLOAD) + 1) * ATM_CELL_PAYLOAD;
1535 data = kmalloc(tx_len, GFP_ATOMIC);
1541 dev_kfree_skb_any(skb);
1546 memcpy(data, skb_data, skb_len);
1547 if (skb_len < tx_len)
1548 memset(data + skb_len, 0x00, tx_len - skb_len);
1554 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1555 ASSERT(vc_map->vcc == vcc);
1559 spin_lock_irqsave(&fore200e->q_lock, flags);
1561 entry = &txq->host_entry[ txq->head ];
1563 if ((*entry->status != STATUS_FREE) || (txq->txing >= QUEUE_SIZE_TX - 2)) {
1565 /* try to free completed tx queue entries */
1566 fore200e_tx_irq(fore200e);
1568 if (*entry->status != STATUS_FREE) {
1570 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1572 /* retry once again? */
1578 atomic_inc(&vcc->stats->tx_err);
1581 DPRINTK(2, "tx queue of device %s is saturated, PDU dropped - heartbeat is %08x\n",
1582 fore200e->name, fore200e->cp_queues->heartbeat);
1587 dev_kfree_skb_any(skb);
1597 entry->incarn = vc_map->incarn;
1598 entry->vc_map = vc_map;
1600 entry->data = tx_copy ? data : NULL;
1603 tpd->tsd[ 0 ].buffer = dma_map_single(fore200e->dev, data, tx_len,
1605 if (dma_mapping_error(fore200e->dev, tpd->tsd[0].buffer)) {
1608 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1611 tpd->tsd[ 0 ].length = tx_len;
1613 FORE200E_NEXT_ENTRY(txq->head, QUEUE_SIZE_TX);
1616 /* The dma_map call above implies a dma_sync so the device can use it,
1617 * thus no explicit dma_sync call is necessary here.
1620 DPRINTK(3, "tx on %d.%d.%d:%d, len = %u (%u)\n",
1621 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1622 tpd->tsd[0].length, skb_len);
1624 if (skb_len < fore200e_vcc->tx_min_pdu)
1625 fore200e_vcc->tx_min_pdu = skb_len;
1626 if (skb_len > fore200e_vcc->tx_max_pdu)
1627 fore200e_vcc->tx_max_pdu = skb_len;
1628 fore200e_vcc->tx_pdu++;
1630 /* set tx rate control information */
1631 tpd->rate.data_cells = fore200e_vcc->rate.data_cells;
1632 tpd->rate.idle_cells = fore200e_vcc->rate.idle_cells;
1635 tpd->atm_header.clp = (*cell_header & ATM_HDR_CLP);
1636 tpd->atm_header.plt = (*cell_header & ATM_HDR_PTI_MASK) >> ATM_HDR_PTI_SHIFT;
1637 tpd->atm_header.vci = (*cell_header & ATM_HDR_VCI_MASK) >> ATM_HDR_VCI_SHIFT;
1638 tpd->atm_header.vpi = (*cell_header & ATM_HDR_VPI_MASK) >> ATM_HDR_VPI_SHIFT;
1639 tpd->atm_header.gfc = (*cell_header & ATM_HDR_GFC_MASK) >> ATM_HDR_GFC_SHIFT;
1642 /* set the ATM header, common to all cells conveying the PDU */
1643 tpd->atm_header.clp = 0;
1644 tpd->atm_header.plt = 0;
1645 tpd->atm_header.vci = vcc->vci;
1646 tpd->atm_header.vpi = vcc->vpi;
1647 tpd->atm_header.gfc = 0;
1650 tpd->spec.length = tx_len;
1652 tpd->spec.aal = fore200e_atm2fore_aal(vcc->qos.aal);
1655 tpd_haddr.size = sizeof(struct tpd) / (1<<TPD_HADDR_SHIFT); /* size is expressed in 32 byte blocks */
1657 tpd_haddr.haddr = entry->tpd_dma >> TPD_HADDR_SHIFT; /* shift the address, as we are in a bitfield */
1659 *entry->status = STATUS_PENDING;
1660 fore200e->bus->write(*(u32*)&tpd_haddr, (u32 __iomem *)&entry->cp_entry->tpd_haddr);
1662 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1669 fore200e_getstats(struct fore200e* fore200e)
1671 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1672 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1673 struct stats_opcode opcode;
1677 if (fore200e->stats == NULL) {
1678 fore200e->stats = kzalloc(sizeof(struct stats), GFP_KERNEL);
1679 if (fore200e->stats == NULL)
1683 stats_dma_addr = dma_map_single(fore200e->dev, fore200e->stats,
1684 sizeof(struct stats), DMA_FROM_DEVICE);
1685 if (dma_mapping_error(fore200e->dev, stats_dma_addr))
1688 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1690 opcode.opcode = OPCODE_GET_STATS;
1693 fore200e->bus->write(stats_dma_addr, &entry->cp_entry->cmd.stats_block.stats_haddr);
1695 *entry->status = STATUS_PENDING;
1697 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.stats_block.opcode);
1699 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1701 *entry->status = STATUS_FREE;
1703 dma_unmap_single(fore200e->dev, stats_dma_addr, sizeof(struct stats), DMA_FROM_DEVICE);
1706 printk(FORE200E "unable to get statistics from device %s\n", fore200e->name);
1715 fore200e_getsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, int optlen)
1717 /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1719 DPRINTK(2, "getsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1720 vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1727 fore200e_setsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, unsigned int optlen)
1729 /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1731 DPRINTK(2, "setsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1732 vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1738 #if 0 /* currently unused */
1740 fore200e_get_oc3(struct fore200e* fore200e, struct oc3_regs* regs)
1742 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1743 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1744 struct oc3_opcode opcode;
1746 u32 oc3_regs_dma_addr;
1748 oc3_regs_dma_addr = fore200e->bus->dma_map(fore200e, regs, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1750 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1752 opcode.opcode = OPCODE_GET_OC3;
1757 fore200e->bus->write(oc3_regs_dma_addr, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1759 *entry->status = STATUS_PENDING;
1761 fore200e->bus->write(*(u32*)&opcode, (u32*)&entry->cp_entry->cmd.oc3_block.opcode);
1763 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1765 *entry->status = STATUS_FREE;
1767 fore200e->bus->dma_unmap(fore200e, oc3_regs_dma_addr, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1770 printk(FORE200E "unable to get OC-3 regs of device %s\n", fore200e->name);
1780 fore200e_set_oc3(struct fore200e* fore200e, u32 reg, u32 value, u32 mask)
1782 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1783 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1784 struct oc3_opcode opcode;
1787 DPRINTK(2, "set OC-3 reg = 0x%02x, value = 0x%02x, mask = 0x%02x\n", reg, value, mask);
1789 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1791 opcode.opcode = OPCODE_SET_OC3;
1793 opcode.value = value;
1796 fore200e->bus->write(0, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1798 *entry->status = STATUS_PENDING;
1800 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.oc3_block.opcode);
1802 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1804 *entry->status = STATUS_FREE;
1807 printk(FORE200E "unable to set OC-3 reg 0x%02x of device %s\n", reg, fore200e->name);
1816 fore200e_setloop(struct fore200e* fore200e, int loop_mode)
1818 u32 mct_value, mct_mask;
1821 if (!capable(CAP_NET_ADMIN))
1824 switch (loop_mode) {
1828 mct_mask = SUNI_MCT_DLE | SUNI_MCT_LLE;
1831 case ATM_LM_LOC_PHY:
1832 mct_value = mct_mask = SUNI_MCT_DLE;
1835 case ATM_LM_RMT_PHY:
1836 mct_value = mct_mask = SUNI_MCT_LLE;
1843 error = fore200e_set_oc3(fore200e, SUNI_MCT, mct_value, mct_mask);
1845 fore200e->loop_mode = loop_mode;
1852 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
1854 struct sonet_stats tmp;
1856 if (fore200e_getstats(fore200e) < 0)
1859 tmp.section_bip = be32_to_cpu(fore200e->stats->oc3.section_bip8_errors);
1860 tmp.line_bip = be32_to_cpu(fore200e->stats->oc3.line_bip24_errors);
1861 tmp.path_bip = be32_to_cpu(fore200e->stats->oc3.path_bip8_errors);
1862 tmp.line_febe = be32_to_cpu(fore200e->stats->oc3.line_febe_errors);
1863 tmp.path_febe = be32_to_cpu(fore200e->stats->oc3.path_febe_errors);
1864 tmp.corr_hcs = be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors);
1865 tmp.uncorr_hcs = be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors);
1866 tmp.tx_cells = be32_to_cpu(fore200e->stats->aal0.cells_transmitted) +
1867 be32_to_cpu(fore200e->stats->aal34.cells_transmitted) +
1868 be32_to_cpu(fore200e->stats->aal5.cells_transmitted);
1869 tmp.rx_cells = be32_to_cpu(fore200e->stats->aal0.cells_received) +
1870 be32_to_cpu(fore200e->stats->aal34.cells_received) +
1871 be32_to_cpu(fore200e->stats->aal5.cells_received);
1874 return copy_to_user(arg, &tmp, sizeof(struct sonet_stats)) ? -EFAULT : 0;
1881 fore200e_ioctl(struct atm_dev* dev, unsigned int cmd, void __user * arg)
1883 struct fore200e* fore200e = FORE200E_DEV(dev);
1885 DPRINTK(2, "ioctl cmd = 0x%x (%u), arg = 0x%p (%lu)\n", cmd, cmd, arg, (unsigned long)arg);
1890 return fore200e_fetch_stats(fore200e, (struct sonet_stats __user *)arg);
1893 return put_user(0, (int __user *)arg) ? -EFAULT : 0;
1896 return fore200e_setloop(fore200e, (int)(unsigned long)arg);
1899 return put_user(fore200e->loop_mode, (int __user *)arg) ? -EFAULT : 0;
1902 return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY, (int __user *)arg) ? -EFAULT : 0;
1905 return -ENOSYS; /* not implemented */
1910 fore200e_change_qos(struct atm_vcc* vcc,struct atm_qos* qos, int flags)
1912 struct fore200e_vcc* fore200e_vcc = FORE200E_VCC(vcc);
1913 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1915 if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1916 DPRINTK(1, "VC %d.%d.%d not ready for QoS change\n", vcc->itf, vcc->vpi, vcc->vpi);
1920 DPRINTK(2, "change_qos %d.%d.%d, "
1921 "(tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1922 "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d), flags = 0x%x\n"
1923 "available_cell_rate = %u",
1924 vcc->itf, vcc->vpi, vcc->vci,
1925 fore200e_traffic_class[ qos->txtp.traffic_class ],
1926 qos->txtp.min_pcr, qos->txtp.max_pcr, qos->txtp.max_cdv, qos->txtp.max_sdu,
1927 fore200e_traffic_class[ qos->rxtp.traffic_class ],
1928 qos->rxtp.min_pcr, qos->rxtp.max_pcr, qos->rxtp.max_cdv, qos->rxtp.max_sdu,
1929 flags, fore200e->available_cell_rate);
1931 if ((qos->txtp.traffic_class == ATM_CBR) && (qos->txtp.max_pcr > 0)) {
1933 mutex_lock(&fore200e->rate_mtx);
1934 if (fore200e->available_cell_rate + vcc->qos.txtp.max_pcr < qos->txtp.max_pcr) {
1935 mutex_unlock(&fore200e->rate_mtx);
1939 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1940 fore200e->available_cell_rate -= qos->txtp.max_pcr;
1942 mutex_unlock(&fore200e->rate_mtx);
1944 memcpy(&vcc->qos, qos, sizeof(struct atm_qos));
1946 /* update rate control parameters */
1947 fore200e_rate_ctrl(qos, &fore200e_vcc->rate);
1949 set_bit(ATM_VF_HASQOS, &vcc->flags);
1958 static int fore200e_irq_request(struct fore200e *fore200e)
1960 if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
1962 printk(FORE200E "unable to reserve IRQ %s for device %s\n",
1963 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1967 printk(FORE200E "IRQ %s reserved for device %s\n",
1968 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1970 #ifdef FORE200E_USE_TASKLET
1971 tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
1972 tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
1975 fore200e->state = FORE200E_STATE_IRQ;
1980 static int fore200e_get_esi(struct fore200e *fore200e)
1982 struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL);
1988 ok = fore200e->bus->prom_read(fore200e, prom);
1994 printk(FORE200E "device %s, rev. %c, S/N: %d, ESI: %pM\n",
1996 (prom->hw_revision & 0xFF) + '@', /* probably meaningless with SBA boards */
1997 prom->serial_number & 0xFFFF, &prom->mac_addr[2]);
1999 for (i = 0; i < ESI_LEN; i++) {
2000 fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
2009 static int fore200e_alloc_rx_buf(struct fore200e *fore200e)
2011 int scheme, magn, nbr, size, i;
2013 struct host_bsq* bsq;
2014 struct buffer* buffer;
2016 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2017 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2019 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2021 nbr = fore200e_rx_buf_nbr[ scheme ][ magn ];
2022 size = fore200e_rx_buf_size[ scheme ][ magn ];
2024 DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
2026 /* allocate the array of receive buffers */
2027 buffer = bsq->buffer = kcalloc(nbr, sizeof(struct buffer),
2033 bsq->freebuf = NULL;
2035 for (i = 0; i < nbr; i++) {
2037 buffer[ i ].scheme = scheme;
2038 buffer[ i ].magn = magn;
2039 #ifdef FORE200E_BSQ_DEBUG
2040 buffer[ i ].index = i;
2041 buffer[ i ].supplied = 0;
2044 /* allocate the receive buffer body */
2045 if (fore200e_chunk_alloc(fore200e,
2046 &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2047 DMA_FROM_DEVICE) < 0) {
2050 fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2056 /* insert the buffer into the free buffer list */
2057 buffer[ i ].next = bsq->freebuf;
2058 bsq->freebuf = &buffer[ i ];
2060 /* all the buffers are free, initially */
2061 bsq->freebuf_count = nbr;
2063 #ifdef FORE200E_BSQ_DEBUG
2064 bsq_audit(3, bsq, scheme, magn);
2069 fore200e->state = FORE200E_STATE_ALLOC_BUF;
2074 static int fore200e_init_bs_queue(struct fore200e *fore200e)
2076 int scheme, magn, i;
2078 struct host_bsq* bsq;
2079 struct cp_bsq_entry __iomem * cp_entry;
2081 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2082 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2084 DPRINTK(2, "buffer supply queue %d / %d is being initialized\n", scheme, magn);
2086 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2088 /* allocate and align the array of status words */
2089 if (fore200e_dma_chunk_alloc(fore200e,
2091 sizeof(enum status),
2093 fore200e->bus->status_alignment) < 0) {
2097 /* allocate and align the array of receive buffer descriptors */
2098 if (fore200e_dma_chunk_alloc(fore200e,
2100 sizeof(struct rbd_block),
2102 fore200e->bus->descr_alignment) < 0) {
2104 fore200e_dma_chunk_free(fore200e, &bsq->status);
2108 /* get the base address of the cp resident buffer supply queue entries */
2109 cp_entry = fore200e->virt_base +
2110 fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2112 /* fill the host resident and cp resident buffer supply queue entries */
2113 for (i = 0; i < QUEUE_SIZE_BS; i++) {
2115 bsq->host_entry[ i ].status =
2116 FORE200E_INDEX(bsq->status.align_addr, enum status, i);
2117 bsq->host_entry[ i ].rbd_block =
2118 FORE200E_INDEX(bsq->rbd_block.align_addr, struct rbd_block, i);
2119 bsq->host_entry[ i ].rbd_block_dma =
2120 FORE200E_DMA_INDEX(bsq->rbd_block.dma_addr, struct rbd_block, i);
2121 bsq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2123 *bsq->host_entry[ i ].status = STATUS_FREE;
2125 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i),
2126 &cp_entry[ i ].status_haddr);
2131 fore200e->state = FORE200E_STATE_INIT_BSQ;
2136 static int fore200e_init_rx_queue(struct fore200e *fore200e)
2138 struct host_rxq* rxq = &fore200e->host_rxq;
2139 struct cp_rxq_entry __iomem * cp_entry;
2142 DPRINTK(2, "receive queue is being initialized\n");
2144 /* allocate and align the array of status words */
2145 if (fore200e_dma_chunk_alloc(fore200e,
2147 sizeof(enum status),
2149 fore200e->bus->status_alignment) < 0) {
2153 /* allocate and align the array of receive PDU descriptors */
2154 if (fore200e_dma_chunk_alloc(fore200e,
2158 fore200e->bus->descr_alignment) < 0) {
2160 fore200e_dma_chunk_free(fore200e, &rxq->status);
2164 /* get the base address of the cp resident rx queue entries */
2165 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2167 /* fill the host resident and cp resident rx entries */
2168 for (i=0; i < QUEUE_SIZE_RX; i++) {
2170 rxq->host_entry[ i ].status =
2171 FORE200E_INDEX(rxq->status.align_addr, enum status, i);
2172 rxq->host_entry[ i ].rpd =
2173 FORE200E_INDEX(rxq->rpd.align_addr, struct rpd, i);
2174 rxq->host_entry[ i ].rpd_dma =
2175 FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i);
2176 rxq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2178 *rxq->host_entry[ i ].status = STATUS_FREE;
2180 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i),
2181 &cp_entry[ i ].status_haddr);
2183 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2184 &cp_entry[ i ].rpd_haddr);
2187 /* set the head entry of the queue */
2190 fore200e->state = FORE200E_STATE_INIT_RXQ;
2195 static int fore200e_init_tx_queue(struct fore200e *fore200e)
2197 struct host_txq* txq = &fore200e->host_txq;
2198 struct cp_txq_entry __iomem * cp_entry;
2201 DPRINTK(2, "transmit queue is being initialized\n");
2203 /* allocate and align the array of status words */
2204 if (fore200e_dma_chunk_alloc(fore200e,
2206 sizeof(enum status),
2208 fore200e->bus->status_alignment) < 0) {
2212 /* allocate and align the array of transmit PDU descriptors */
2213 if (fore200e_dma_chunk_alloc(fore200e,
2217 fore200e->bus->descr_alignment) < 0) {
2219 fore200e_dma_chunk_free(fore200e, &txq->status);
2223 /* get the base address of the cp resident tx queue entries */
2224 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2226 /* fill the host resident and cp resident tx entries */
2227 for (i=0; i < QUEUE_SIZE_TX; i++) {
2229 txq->host_entry[ i ].status =
2230 FORE200E_INDEX(txq->status.align_addr, enum status, i);
2231 txq->host_entry[ i ].tpd =
2232 FORE200E_INDEX(txq->tpd.align_addr, struct tpd, i);
2233 txq->host_entry[ i ].tpd_dma =
2234 FORE200E_DMA_INDEX(txq->tpd.dma_addr, struct tpd, i);
2235 txq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2237 *txq->host_entry[ i ].status = STATUS_FREE;
2239 fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i),
2240 &cp_entry[ i ].status_haddr);
2242 /* although there is a one-to-one mapping of tx queue entries and tpds,
2243 we do not write here the DMA (physical) base address of each tpd into
2244 the related cp resident entry, because the cp relies on this write
2245 operation to detect that a new pdu has been submitted for tx */
2248 /* set the head and tail entries of the queue */
2252 fore200e->state = FORE200E_STATE_INIT_TXQ;
2257 static int fore200e_init_cmd_queue(struct fore200e *fore200e)
2259 struct host_cmdq* cmdq = &fore200e->host_cmdq;
2260 struct cp_cmdq_entry __iomem * cp_entry;
2263 DPRINTK(2, "command queue is being initialized\n");
2265 /* allocate and align the array of status words */
2266 if (fore200e_dma_chunk_alloc(fore200e,
2268 sizeof(enum status),
2270 fore200e->bus->status_alignment) < 0) {
2274 /* get the base address of the cp resident cmd queue entries */
2275 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2277 /* fill the host resident and cp resident cmd entries */
2278 for (i=0; i < QUEUE_SIZE_CMD; i++) {
2280 cmdq->host_entry[ i ].status =
2281 FORE200E_INDEX(cmdq->status.align_addr, enum status, i);
2282 cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2284 *cmdq->host_entry[ i ].status = STATUS_FREE;
2286 fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),
2287 &cp_entry[ i ].status_haddr);
2290 /* set the head entry of the queue */
2293 fore200e->state = FORE200E_STATE_INIT_CMDQ;
2298 static void fore200e_param_bs_queue(struct fore200e *fore200e,
2299 enum buffer_scheme scheme,
2300 enum buffer_magn magn, int queue_length,
2301 int pool_size, int supply_blksize)
2303 struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2305 fore200e->bus->write(queue_length, &bs_spec->queue_length);
2306 fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2307 fore200e->bus->write(pool_size, &bs_spec->pool_size);
2308 fore200e->bus->write(supply_blksize, &bs_spec->supply_blksize);
2312 static int fore200e_initialize(struct fore200e *fore200e)
2314 struct cp_queues __iomem * cpq;
2315 int ok, scheme, magn;
2317 DPRINTK(2, "device %s being initialized\n", fore200e->name);
2319 mutex_init(&fore200e->rate_mtx);
2320 spin_lock_init(&fore200e->q_lock);
2322 cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2324 /* enable cp to host interrupts */
2325 fore200e->bus->write(1, &cpq->imask);
2327 if (fore200e->bus->irq_enable)
2328 fore200e->bus->irq_enable(fore200e);
2330 fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2332 fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2333 fore200e->bus->write(QUEUE_SIZE_RX, &cpq->init.rx_queue_len);
2334 fore200e->bus->write(QUEUE_SIZE_TX, &cpq->init.tx_queue_len);
2336 fore200e->bus->write(RSD_EXTENSION, &cpq->init.rsd_extension);
2337 fore200e->bus->write(TSD_EXTENSION, &cpq->init.tsd_extension);
2339 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++)
2340 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++)
2341 fore200e_param_bs_queue(fore200e, scheme, magn,
2343 fore200e_rx_buf_nbr[ scheme ][ magn ],
2346 /* issue the initialize command */
2347 fore200e->bus->write(STATUS_PENDING, &cpq->init.status);
2348 fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2350 ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2352 printk(FORE200E "device %s initialization failed\n", fore200e->name);
2356 printk(FORE200E "device %s initialized\n", fore200e->name);
2358 fore200e->state = FORE200E_STATE_INITIALIZE;
2363 static void fore200e_monitor_putc(struct fore200e *fore200e, char c)
2365 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2370 fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2374 static int fore200e_monitor_getc(struct fore200e *fore200e)
2376 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2377 unsigned long timeout = jiffies + msecs_to_jiffies(50);
2380 while (time_before(jiffies, timeout)) {
2382 c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2384 if (c & FORE200E_CP_MONITOR_UART_AVAIL) {
2386 fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2388 printk("%c", c & 0xFF);
2398 static void fore200e_monitor_puts(struct fore200e *fore200e, char *str)
2402 /* the i960 monitor doesn't accept any new character if it has something to say */
2403 while (fore200e_monitor_getc(fore200e) >= 0);
2405 fore200e_monitor_putc(fore200e, *str++);
2408 while (fore200e_monitor_getc(fore200e) >= 0);
2413 static int fore200e_load_and_start_fw(struct fore200e *fore200e)
2415 const struct firmware *firmware;
2416 const struct fw_header *fw_header;
2417 const __le32 *fw_data;
2419 u32 __iomem *load_addr;
2424 if ((err = reject_firmware(&firmware, buf, fore200e->dev)) < 0) {
2425 printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
2429 fw_data = (const __le32 *)firmware->data;
2430 fw_size = firmware->size / sizeof(u32);
2431 fw_header = (const struct fw_header *)firmware->data;
2432 load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2434 DPRINTK(2, "device %s firmware being loaded at 0x%p (%d words)\n",
2435 fore200e->name, load_addr, fw_size);
2437 if (le32_to_cpu(fw_header->magic) != FW_HEADER_MAGIC) {
2438 printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2442 for (; fw_size--; fw_data++, load_addr++)
2443 fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2445 DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2447 #if defined(__sparc_v9__)
2448 /* reported to be required by SBA cards on some sparc64 hosts */
2452 sprintf(buf, "\rgo %x\r", le32_to_cpu(fw_header->start_offset));
2453 fore200e_monitor_puts(fore200e, buf);
2455 if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2456 printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2460 printk(FORE200E "device %s firmware started\n", fore200e->name);
2462 fore200e->state = FORE200E_STATE_START_FW;
2466 release_firmware(firmware);
2471 static int fore200e_register(struct fore200e *fore200e, struct device *parent)
2473 struct atm_dev* atm_dev;
2475 DPRINTK(2, "device %s being registered\n", fore200e->name);
2477 atm_dev = atm_dev_register(fore200e->bus->proc_name, parent, &fore200e_ops,
2479 if (atm_dev == NULL) {
2480 printk(FORE200E "unable to register device %s\n", fore200e->name);
2484 atm_dev->dev_data = fore200e;
2485 fore200e->atm_dev = atm_dev;
2487 atm_dev->ci_range.vpi_bits = FORE200E_VPI_BITS;
2488 atm_dev->ci_range.vci_bits = FORE200E_VCI_BITS;
2490 fore200e->available_cell_rate = ATM_OC3_PCR;
2492 fore200e->state = FORE200E_STATE_REGISTER;
2497 static int fore200e_init(struct fore200e *fore200e, struct device *parent)
2499 if (fore200e_register(fore200e, parent) < 0)
2502 if (fore200e->bus->configure(fore200e) < 0)
2505 if (fore200e->bus->map(fore200e) < 0)
2508 if (fore200e_reset(fore200e, 1) < 0)
2511 if (fore200e_load_and_start_fw(fore200e) < 0)
2514 if (fore200e_initialize(fore200e) < 0)
2517 if (fore200e_init_cmd_queue(fore200e) < 0)
2520 if (fore200e_init_tx_queue(fore200e) < 0)
2523 if (fore200e_init_rx_queue(fore200e) < 0)
2526 if (fore200e_init_bs_queue(fore200e) < 0)
2529 if (fore200e_alloc_rx_buf(fore200e) < 0)
2532 if (fore200e_get_esi(fore200e) < 0)
2535 if (fore200e_irq_request(fore200e) < 0)
2538 fore200e_supply(fore200e);
2540 /* all done, board initialization is now complete */
2541 fore200e->state = FORE200E_STATE_COMPLETE;
2546 static const struct of_device_id fore200e_sba_match[];
2547 static int fore200e_sba_probe(struct platform_device *op)
2549 const struct of_device_id *match;
2550 struct fore200e *fore200e;
2551 static int index = 0;
2554 match = of_match_device(fore200e_sba_match, &op->dev);
2558 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2562 fore200e->bus = &fore200e_sbus_ops;
2563 fore200e->dev = &op->dev;
2564 fore200e->irq = op->archdata.irqs[0];
2565 fore200e->phys_base = op->resource[0].start;
2567 sprintf(fore200e->name, "SBA-200E-%d", index);
2569 err = fore200e_init(fore200e, &op->dev);
2571 fore200e_shutdown(fore200e);
2577 dev_set_drvdata(&op->dev, fore200e);
2582 static int fore200e_sba_remove(struct platform_device *op)
2584 struct fore200e *fore200e = dev_get_drvdata(&op->dev);
2586 fore200e_shutdown(fore200e);
2592 static const struct of_device_id fore200e_sba_match[] = {
2594 .name = SBA200E_PROM_NAME,
2598 MODULE_DEVICE_TABLE(of, fore200e_sba_match);
2600 static struct platform_driver fore200e_sba_driver = {
2602 .name = "fore_200e",
2603 .of_match_table = fore200e_sba_match,
2605 .probe = fore200e_sba_probe,
2606 .remove = fore200e_sba_remove,
2611 static int fore200e_pca_detect(struct pci_dev *pci_dev,
2612 const struct pci_device_id *pci_ent)
2614 struct fore200e* fore200e;
2616 static int index = 0;
2618 if (pci_enable_device(pci_dev)) {
2623 if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) {
2628 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2629 if (fore200e == NULL) {
2634 fore200e->bus = &fore200e_pci_ops;
2635 fore200e->dev = &pci_dev->dev;
2636 fore200e->irq = pci_dev->irq;
2637 fore200e->phys_base = pci_resource_start(pci_dev, 0);
2639 sprintf(fore200e->name, "PCA-200E-%d", index - 1);
2641 pci_set_master(pci_dev);
2643 printk(FORE200E "device PCA-200E found at 0x%lx, IRQ %s\n",
2644 fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2646 sprintf(fore200e->name, "PCA-200E-%d", index);
2648 err = fore200e_init(fore200e, &pci_dev->dev);
2650 fore200e_shutdown(fore200e);
2655 pci_set_drvdata(pci_dev, fore200e);
2663 pci_disable_device(pci_dev);
2668 static void fore200e_pca_remove_one(struct pci_dev *pci_dev)
2670 struct fore200e *fore200e;
2672 fore200e = pci_get_drvdata(pci_dev);
2674 fore200e_shutdown(fore200e);
2676 pci_disable_device(pci_dev);
2680 static const struct pci_device_id fore200e_pca_tbl[] = {
2681 { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_PCA200E, PCI_ANY_ID, PCI_ANY_ID },
2685 MODULE_DEVICE_TABLE(pci, fore200e_pca_tbl);
2687 static struct pci_driver fore200e_pca_driver = {
2688 .name = "fore_200e",
2689 .probe = fore200e_pca_detect,
2690 .remove = fore200e_pca_remove_one,
2691 .id_table = fore200e_pca_tbl,
2695 static int __init fore200e_module_init(void)
2699 printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
2702 err = platform_driver_register(&fore200e_sba_driver);
2708 err = pci_register_driver(&fore200e_pca_driver);
2713 platform_driver_unregister(&fore200e_sba_driver);
2719 static void __exit fore200e_module_cleanup(void)
2722 pci_unregister_driver(&fore200e_pca_driver);
2725 platform_driver_unregister(&fore200e_sba_driver);
2730 fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
2732 struct fore200e* fore200e = FORE200E_DEV(dev);
2733 struct fore200e_vcc* fore200e_vcc;
2734 struct atm_vcc* vcc;
2735 int i, len, left = *pos;
2736 unsigned long flags;
2740 if (fore200e_getstats(fore200e) < 0)
2743 len = sprintf(page,"\n"
2745 " internal name:\t\t%s\n", fore200e->name);
2747 /* print bus-specific information */
2748 if (fore200e->bus->proc_read)
2749 len += fore200e->bus->proc_read(fore200e, page + len);
2751 len += sprintf(page + len,
2752 " interrupt line:\t\t%s\n"
2753 " physical base address:\t0x%p\n"
2754 " virtual base address:\t0x%p\n"
2755 " factory address (ESI):\t%pM\n"
2756 " board serial number:\t\t%d\n\n",
2757 fore200e_irq_itoa(fore200e->irq),
2758 (void*)fore200e->phys_base,
2759 fore200e->virt_base,
2761 fore200e->esi[4] * 256 + fore200e->esi[5]);
2767 return sprintf(page,
2768 " free small bufs, scheme 1:\t%d\n"
2769 " free large bufs, scheme 1:\t%d\n"
2770 " free small bufs, scheme 2:\t%d\n"
2771 " free large bufs, scheme 2:\t%d\n",
2772 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2773 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2774 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2775 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2778 u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2780 len = sprintf(page,"\n\n"
2781 " cell processor:\n"
2782 " heartbeat state:\t\t");
2784 if (hb >> 16 != 0xDEAD)
2785 len += sprintf(page + len, "0x%08x\n", hb);
2787 len += sprintf(page + len, "*** FATAL ERROR %04x ***\n", hb & 0xFFFF);
2793 static const char* media_name[] = {
2794 "unshielded twisted pair",
2795 "multimode optical fiber ST",
2796 "multimode optical fiber SC",
2797 "single-mode optical fiber ST",
2798 "single-mode optical fiber SC",
2802 static const char* oc3_mode[] = {
2804 "diagnostic loopback",
2809 u32 fw_release = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2810 u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2811 u32 oc3_revision = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2812 u32 media_index = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2815 if (media_index > 4)
2818 switch (fore200e->loop_mode) {
2819 case ATM_LM_NONE: oc3_index = 0;
2821 case ATM_LM_LOC_PHY: oc3_index = 1;
2823 case ATM_LM_RMT_PHY: oc3_index = 2;
2825 default: oc3_index = 3;
2828 return sprintf(page,
2829 " firmware release:\t\t%d.%d.%d\n"
2830 " monitor release:\t\t%d.%d\n"
2831 " media type:\t\t\t%s\n"
2832 " OC-3 revision:\t\t0x%x\n"
2833 " OC-3 mode:\t\t\t%s",
2834 fw_release >> 16, fw_release << 16 >> 24, fw_release << 24 >> 24,
2835 mon960_release >> 16, mon960_release << 16 >> 16,
2836 media_name[ media_index ],
2838 oc3_mode[ oc3_index ]);
2842 struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2844 return sprintf(page,
2847 " version number:\t\t%d\n"
2848 " boot status word:\t\t0x%08x\n",
2849 fore200e->bus->read(&cp_monitor->mon_version),
2850 fore200e->bus->read(&cp_monitor->bstat));
2854 return sprintf(page,
2856 " device statistics:\n"
2858 " crc_header_errors:\t\t%10u\n"
2859 " framing_errors:\t\t%10u\n",
2860 be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2861 be32_to_cpu(fore200e->stats->phy.framing_errors));
2864 return sprintf(page, "\n"
2866 " section_bip8_errors:\t%10u\n"
2867 " path_bip8_errors:\t\t%10u\n"
2868 " line_bip24_errors:\t\t%10u\n"
2869 " line_febe_errors:\t\t%10u\n"
2870 " path_febe_errors:\t\t%10u\n"
2871 " corr_hcs_errors:\t\t%10u\n"
2872 " ucorr_hcs_errors:\t\t%10u\n",
2873 be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2874 be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2875 be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2876 be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2877 be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2878 be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2879 be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
2882 return sprintf(page,"\n"
2883 " ATM:\t\t\t\t cells\n"
2886 " vpi out of range:\t\t%10u\n"
2887 " vpi no conn:\t\t%10u\n"
2888 " vci out of range:\t\t%10u\n"
2889 " vci no conn:\t\t%10u\n",
2890 be32_to_cpu(fore200e->stats->atm.cells_transmitted),
2891 be32_to_cpu(fore200e->stats->atm.cells_received),
2892 be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
2893 be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
2894 be32_to_cpu(fore200e->stats->atm.vci_bad_range),
2895 be32_to_cpu(fore200e->stats->atm.vci_no_conn));
2898 return sprintf(page,"\n"
2899 " AAL0:\t\t\t cells\n"
2902 " dropped:\t\t\t%10u\n",
2903 be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
2904 be32_to_cpu(fore200e->stats->aal0.cells_received),
2905 be32_to_cpu(fore200e->stats->aal0.cells_dropped));
2908 return sprintf(page,"\n"
2910 " SAR sublayer:\t\t cells\n"
2913 " dropped:\t\t\t%10u\n"
2914 " CRC errors:\t\t%10u\n"
2915 " protocol errors:\t\t%10u\n\n"
2916 " CS sublayer:\t\t PDUs\n"
2919 " dropped:\t\t\t%10u\n"
2920 " protocol errors:\t\t%10u\n",
2921 be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
2922 be32_to_cpu(fore200e->stats->aal34.cells_received),
2923 be32_to_cpu(fore200e->stats->aal34.cells_dropped),
2924 be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
2925 be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
2926 be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
2927 be32_to_cpu(fore200e->stats->aal34.cspdus_received),
2928 be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
2929 be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
2932 return sprintf(page,"\n"
2934 " SAR sublayer:\t\t cells\n"
2937 " dropped:\t\t\t%10u\n"
2938 " congestions:\t\t%10u\n\n"
2939 " CS sublayer:\t\t PDUs\n"
2942 " dropped:\t\t\t%10u\n"
2943 " CRC errors:\t\t%10u\n"
2944 " protocol errors:\t\t%10u\n",
2945 be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
2946 be32_to_cpu(fore200e->stats->aal5.cells_received),
2947 be32_to_cpu(fore200e->stats->aal5.cells_dropped),
2948 be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
2949 be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
2950 be32_to_cpu(fore200e->stats->aal5.cspdus_received),
2951 be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
2952 be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
2953 be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
2956 return sprintf(page,"\n"
2957 " AUX:\t\t allocation failures\n"
2958 " small b1:\t\t\t%10u\n"
2959 " large b1:\t\t\t%10u\n"
2960 " small b2:\t\t\t%10u\n"
2961 " large b2:\t\t\t%10u\n"
2962 " RX PDUs:\t\t\t%10u\n"
2963 " TX PDUs:\t\t\t%10lu\n",
2964 be32_to_cpu(fore200e->stats->aux.small_b1_failed),
2965 be32_to_cpu(fore200e->stats->aux.large_b1_failed),
2966 be32_to_cpu(fore200e->stats->aux.small_b2_failed),
2967 be32_to_cpu(fore200e->stats->aux.large_b2_failed),
2968 be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
2972 return sprintf(page,"\n"
2973 " receive carrier:\t\t\t%s\n",
2974 fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
2977 return sprintf(page,"\n"
2978 " VCCs:\n address VPI VCI AAL "
2979 "TX PDUs TX min/max size RX PDUs RX min/max size\n");
2982 for (i = 0; i < NBR_CONNECT; i++) {
2984 vcc = fore200e->vc_map[i].vcc;
2989 spin_lock_irqsave(&fore200e->q_lock, flags);
2991 if (vcc && test_bit(ATM_VF_READY, &vcc->flags) && !left--) {
2993 fore200e_vcc = FORE200E_VCC(vcc);
2994 ASSERT(fore200e_vcc);
2997 " %pK %03d %05d %1d %09lu %05d/%05d %09lu %05d/%05d\n",
2999 vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
3000 fore200e_vcc->tx_pdu,
3001 fore200e_vcc->tx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->tx_min_pdu,
3002 fore200e_vcc->tx_max_pdu,
3003 fore200e_vcc->rx_pdu,
3004 fore200e_vcc->rx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->rx_min_pdu,
3005 fore200e_vcc->rx_max_pdu);
3007 spin_unlock_irqrestore(&fore200e->q_lock, flags);
3011 spin_unlock_irqrestore(&fore200e->q_lock, flags);
3017 module_init(fore200e_module_init);
3018 module_exit(fore200e_module_cleanup);
3021 static const struct atmdev_ops fore200e_ops = {
3022 .open = fore200e_open,
3023 .close = fore200e_close,
3024 .ioctl = fore200e_ioctl,
3025 .getsockopt = fore200e_getsockopt,
3026 .setsockopt = fore200e_setsockopt,
3027 .send = fore200e_send,
3028 .change_qos = fore200e_change_qos,
3029 .proc_read = fore200e_proc_read,
3030 .owner = THIS_MODULE
3033 MODULE_LICENSE("GPL");
3035 #ifdef __LITTLE_ENDIAN__
3040 #endif /* CONFIG_PCI */