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>
28 #include <linux/pgtable.h>
30 #include <asm/string.h>
34 #include <asm/byteorder.h>
35 #include <linux/uaccess.h>
36 #include <linux/atomic.h>
40 #include <linux/of_device.h>
41 #include <asm/idprom.h>
42 #include <asm/openprom.h>
43 #include <asm/oplib.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);
1713 #if 0 /* currently unused */
1715 fore200e_get_oc3(struct fore200e* fore200e, struct oc3_regs* regs)
1717 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1718 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1719 struct oc3_opcode opcode;
1721 u32 oc3_regs_dma_addr;
1723 oc3_regs_dma_addr = fore200e->bus->dma_map(fore200e, regs, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1725 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1727 opcode.opcode = OPCODE_GET_OC3;
1732 fore200e->bus->write(oc3_regs_dma_addr, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1734 *entry->status = STATUS_PENDING;
1736 fore200e->bus->write(*(u32*)&opcode, (u32*)&entry->cp_entry->cmd.oc3_block.opcode);
1738 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1740 *entry->status = STATUS_FREE;
1742 fore200e->bus->dma_unmap(fore200e, oc3_regs_dma_addr, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1745 printk(FORE200E "unable to get OC-3 regs of device %s\n", fore200e->name);
1755 fore200e_set_oc3(struct fore200e* fore200e, u32 reg, u32 value, u32 mask)
1757 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1758 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1759 struct oc3_opcode opcode;
1762 DPRINTK(2, "set OC-3 reg = 0x%02x, value = 0x%02x, mask = 0x%02x\n", reg, value, mask);
1764 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1766 opcode.opcode = OPCODE_SET_OC3;
1768 opcode.value = value;
1771 fore200e->bus->write(0, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1773 *entry->status = STATUS_PENDING;
1775 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.oc3_block.opcode);
1777 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1779 *entry->status = STATUS_FREE;
1782 printk(FORE200E "unable to set OC-3 reg 0x%02x of device %s\n", reg, fore200e->name);
1791 fore200e_setloop(struct fore200e* fore200e, int loop_mode)
1793 u32 mct_value, mct_mask;
1796 if (!capable(CAP_NET_ADMIN))
1799 switch (loop_mode) {
1803 mct_mask = SUNI_MCT_DLE | SUNI_MCT_LLE;
1806 case ATM_LM_LOC_PHY:
1807 mct_value = mct_mask = SUNI_MCT_DLE;
1810 case ATM_LM_RMT_PHY:
1811 mct_value = mct_mask = SUNI_MCT_LLE;
1818 error = fore200e_set_oc3(fore200e, SUNI_MCT, mct_value, mct_mask);
1820 fore200e->loop_mode = loop_mode;
1827 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
1829 struct sonet_stats tmp;
1831 if (fore200e_getstats(fore200e) < 0)
1834 tmp.section_bip = be32_to_cpu(fore200e->stats->oc3.section_bip8_errors);
1835 tmp.line_bip = be32_to_cpu(fore200e->stats->oc3.line_bip24_errors);
1836 tmp.path_bip = be32_to_cpu(fore200e->stats->oc3.path_bip8_errors);
1837 tmp.line_febe = be32_to_cpu(fore200e->stats->oc3.line_febe_errors);
1838 tmp.path_febe = be32_to_cpu(fore200e->stats->oc3.path_febe_errors);
1839 tmp.corr_hcs = be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors);
1840 tmp.uncorr_hcs = be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors);
1841 tmp.tx_cells = be32_to_cpu(fore200e->stats->aal0.cells_transmitted) +
1842 be32_to_cpu(fore200e->stats->aal34.cells_transmitted) +
1843 be32_to_cpu(fore200e->stats->aal5.cells_transmitted);
1844 tmp.rx_cells = be32_to_cpu(fore200e->stats->aal0.cells_received) +
1845 be32_to_cpu(fore200e->stats->aal34.cells_received) +
1846 be32_to_cpu(fore200e->stats->aal5.cells_received);
1849 return copy_to_user(arg, &tmp, sizeof(struct sonet_stats)) ? -EFAULT : 0;
1856 fore200e_ioctl(struct atm_dev* dev, unsigned int cmd, void __user * arg)
1858 struct fore200e* fore200e = FORE200E_DEV(dev);
1860 DPRINTK(2, "ioctl cmd = 0x%x (%u), arg = 0x%p (%lu)\n", cmd, cmd, arg, (unsigned long)arg);
1865 return fore200e_fetch_stats(fore200e, (struct sonet_stats __user *)arg);
1868 return put_user(0, (int __user *)arg) ? -EFAULT : 0;
1871 return fore200e_setloop(fore200e, (int)(unsigned long)arg);
1874 return put_user(fore200e->loop_mode, (int __user *)arg) ? -EFAULT : 0;
1877 return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY, (int __user *)arg) ? -EFAULT : 0;
1880 return -ENOSYS; /* not implemented */
1885 fore200e_change_qos(struct atm_vcc* vcc,struct atm_qos* qos, int flags)
1887 struct fore200e_vcc* fore200e_vcc = FORE200E_VCC(vcc);
1888 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1890 if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1891 DPRINTK(1, "VC %d.%d.%d not ready for QoS change\n", vcc->itf, vcc->vpi, vcc->vpi);
1895 DPRINTK(2, "change_qos %d.%d.%d, "
1896 "(tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1897 "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d), flags = 0x%x\n"
1898 "available_cell_rate = %u",
1899 vcc->itf, vcc->vpi, vcc->vci,
1900 fore200e_traffic_class[ qos->txtp.traffic_class ],
1901 qos->txtp.min_pcr, qos->txtp.max_pcr, qos->txtp.max_cdv, qos->txtp.max_sdu,
1902 fore200e_traffic_class[ qos->rxtp.traffic_class ],
1903 qos->rxtp.min_pcr, qos->rxtp.max_pcr, qos->rxtp.max_cdv, qos->rxtp.max_sdu,
1904 flags, fore200e->available_cell_rate);
1906 if ((qos->txtp.traffic_class == ATM_CBR) && (qos->txtp.max_pcr > 0)) {
1908 mutex_lock(&fore200e->rate_mtx);
1909 if (fore200e->available_cell_rate + vcc->qos.txtp.max_pcr < qos->txtp.max_pcr) {
1910 mutex_unlock(&fore200e->rate_mtx);
1914 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1915 fore200e->available_cell_rate -= qos->txtp.max_pcr;
1917 mutex_unlock(&fore200e->rate_mtx);
1919 memcpy(&vcc->qos, qos, sizeof(struct atm_qos));
1921 /* update rate control parameters */
1922 fore200e_rate_ctrl(qos, &fore200e_vcc->rate);
1924 set_bit(ATM_VF_HASQOS, &vcc->flags);
1933 static int fore200e_irq_request(struct fore200e *fore200e)
1935 if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
1937 printk(FORE200E "unable to reserve IRQ %s for device %s\n",
1938 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1942 printk(FORE200E "IRQ %s reserved for device %s\n",
1943 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1945 #ifdef FORE200E_USE_TASKLET
1946 tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
1947 tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
1950 fore200e->state = FORE200E_STATE_IRQ;
1955 static int fore200e_get_esi(struct fore200e *fore200e)
1957 struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL);
1963 ok = fore200e->bus->prom_read(fore200e, prom);
1969 printk(FORE200E "device %s, rev. %c, S/N: %d, ESI: %pM\n",
1971 (prom->hw_revision & 0xFF) + '@', /* probably meaningless with SBA boards */
1972 prom->serial_number & 0xFFFF, &prom->mac_addr[2]);
1974 for (i = 0; i < ESI_LEN; i++) {
1975 fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
1984 static int fore200e_alloc_rx_buf(struct fore200e *fore200e)
1986 int scheme, magn, nbr, size, i;
1988 struct host_bsq* bsq;
1989 struct buffer* buffer;
1991 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
1992 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
1994 bsq = &fore200e->host_bsq[ scheme ][ magn ];
1996 nbr = fore200e_rx_buf_nbr[ scheme ][ magn ];
1997 size = fore200e_rx_buf_size[ scheme ][ magn ];
1999 DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
2001 /* allocate the array of receive buffers */
2002 buffer = bsq->buffer = kcalloc(nbr, sizeof(struct buffer),
2008 bsq->freebuf = NULL;
2010 for (i = 0; i < nbr; i++) {
2012 buffer[ i ].scheme = scheme;
2013 buffer[ i ].magn = magn;
2014 #ifdef FORE200E_BSQ_DEBUG
2015 buffer[ i ].index = i;
2016 buffer[ i ].supplied = 0;
2019 /* allocate the receive buffer body */
2020 if (fore200e_chunk_alloc(fore200e,
2021 &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2022 DMA_FROM_DEVICE) < 0) {
2025 fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2031 /* insert the buffer into the free buffer list */
2032 buffer[ i ].next = bsq->freebuf;
2033 bsq->freebuf = &buffer[ i ];
2035 /* all the buffers are free, initially */
2036 bsq->freebuf_count = nbr;
2038 #ifdef FORE200E_BSQ_DEBUG
2039 bsq_audit(3, bsq, scheme, magn);
2044 fore200e->state = FORE200E_STATE_ALLOC_BUF;
2049 static int fore200e_init_bs_queue(struct fore200e *fore200e)
2051 int scheme, magn, i;
2053 struct host_bsq* bsq;
2054 struct cp_bsq_entry __iomem * cp_entry;
2056 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2057 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2059 DPRINTK(2, "buffer supply queue %d / %d is being initialized\n", scheme, magn);
2061 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2063 /* allocate and align the array of status words */
2064 if (fore200e_dma_chunk_alloc(fore200e,
2066 sizeof(enum status),
2068 fore200e->bus->status_alignment) < 0) {
2072 /* allocate and align the array of receive buffer descriptors */
2073 if (fore200e_dma_chunk_alloc(fore200e,
2075 sizeof(struct rbd_block),
2077 fore200e->bus->descr_alignment) < 0) {
2079 fore200e_dma_chunk_free(fore200e, &bsq->status);
2083 /* get the base address of the cp resident buffer supply queue entries */
2084 cp_entry = fore200e->virt_base +
2085 fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2087 /* fill the host resident and cp resident buffer supply queue entries */
2088 for (i = 0; i < QUEUE_SIZE_BS; i++) {
2090 bsq->host_entry[ i ].status =
2091 FORE200E_INDEX(bsq->status.align_addr, enum status, i);
2092 bsq->host_entry[ i ].rbd_block =
2093 FORE200E_INDEX(bsq->rbd_block.align_addr, struct rbd_block, i);
2094 bsq->host_entry[ i ].rbd_block_dma =
2095 FORE200E_DMA_INDEX(bsq->rbd_block.dma_addr, struct rbd_block, i);
2096 bsq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2098 *bsq->host_entry[ i ].status = STATUS_FREE;
2100 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i),
2101 &cp_entry[ i ].status_haddr);
2106 fore200e->state = FORE200E_STATE_INIT_BSQ;
2111 static int fore200e_init_rx_queue(struct fore200e *fore200e)
2113 struct host_rxq* rxq = &fore200e->host_rxq;
2114 struct cp_rxq_entry __iomem * cp_entry;
2117 DPRINTK(2, "receive queue is being initialized\n");
2119 /* allocate and align the array of status words */
2120 if (fore200e_dma_chunk_alloc(fore200e,
2122 sizeof(enum status),
2124 fore200e->bus->status_alignment) < 0) {
2128 /* allocate and align the array of receive PDU descriptors */
2129 if (fore200e_dma_chunk_alloc(fore200e,
2133 fore200e->bus->descr_alignment) < 0) {
2135 fore200e_dma_chunk_free(fore200e, &rxq->status);
2139 /* get the base address of the cp resident rx queue entries */
2140 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2142 /* fill the host resident and cp resident rx entries */
2143 for (i=0; i < QUEUE_SIZE_RX; i++) {
2145 rxq->host_entry[ i ].status =
2146 FORE200E_INDEX(rxq->status.align_addr, enum status, i);
2147 rxq->host_entry[ i ].rpd =
2148 FORE200E_INDEX(rxq->rpd.align_addr, struct rpd, i);
2149 rxq->host_entry[ i ].rpd_dma =
2150 FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i);
2151 rxq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2153 *rxq->host_entry[ i ].status = STATUS_FREE;
2155 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i),
2156 &cp_entry[ i ].status_haddr);
2158 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2159 &cp_entry[ i ].rpd_haddr);
2162 /* set the head entry of the queue */
2165 fore200e->state = FORE200E_STATE_INIT_RXQ;
2170 static int fore200e_init_tx_queue(struct fore200e *fore200e)
2172 struct host_txq* txq = &fore200e->host_txq;
2173 struct cp_txq_entry __iomem * cp_entry;
2176 DPRINTK(2, "transmit queue is being initialized\n");
2178 /* allocate and align the array of status words */
2179 if (fore200e_dma_chunk_alloc(fore200e,
2181 sizeof(enum status),
2183 fore200e->bus->status_alignment) < 0) {
2187 /* allocate and align the array of transmit PDU descriptors */
2188 if (fore200e_dma_chunk_alloc(fore200e,
2192 fore200e->bus->descr_alignment) < 0) {
2194 fore200e_dma_chunk_free(fore200e, &txq->status);
2198 /* get the base address of the cp resident tx queue entries */
2199 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2201 /* fill the host resident and cp resident tx entries */
2202 for (i=0; i < QUEUE_SIZE_TX; i++) {
2204 txq->host_entry[ i ].status =
2205 FORE200E_INDEX(txq->status.align_addr, enum status, i);
2206 txq->host_entry[ i ].tpd =
2207 FORE200E_INDEX(txq->tpd.align_addr, struct tpd, i);
2208 txq->host_entry[ i ].tpd_dma =
2209 FORE200E_DMA_INDEX(txq->tpd.dma_addr, struct tpd, i);
2210 txq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2212 *txq->host_entry[ i ].status = STATUS_FREE;
2214 fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i),
2215 &cp_entry[ i ].status_haddr);
2217 /* although there is a one-to-one mapping of tx queue entries and tpds,
2218 we do not write here the DMA (physical) base address of each tpd into
2219 the related cp resident entry, because the cp relies on this write
2220 operation to detect that a new pdu has been submitted for tx */
2223 /* set the head and tail entries of the queue */
2227 fore200e->state = FORE200E_STATE_INIT_TXQ;
2232 static int fore200e_init_cmd_queue(struct fore200e *fore200e)
2234 struct host_cmdq* cmdq = &fore200e->host_cmdq;
2235 struct cp_cmdq_entry __iomem * cp_entry;
2238 DPRINTK(2, "command queue is being initialized\n");
2240 /* allocate and align the array of status words */
2241 if (fore200e_dma_chunk_alloc(fore200e,
2243 sizeof(enum status),
2245 fore200e->bus->status_alignment) < 0) {
2249 /* get the base address of the cp resident cmd queue entries */
2250 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2252 /* fill the host resident and cp resident cmd entries */
2253 for (i=0; i < QUEUE_SIZE_CMD; i++) {
2255 cmdq->host_entry[ i ].status =
2256 FORE200E_INDEX(cmdq->status.align_addr, enum status, i);
2257 cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2259 *cmdq->host_entry[ i ].status = STATUS_FREE;
2261 fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),
2262 &cp_entry[ i ].status_haddr);
2265 /* set the head entry of the queue */
2268 fore200e->state = FORE200E_STATE_INIT_CMDQ;
2273 static void fore200e_param_bs_queue(struct fore200e *fore200e,
2274 enum buffer_scheme scheme,
2275 enum buffer_magn magn, int queue_length,
2276 int pool_size, int supply_blksize)
2278 struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2280 fore200e->bus->write(queue_length, &bs_spec->queue_length);
2281 fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2282 fore200e->bus->write(pool_size, &bs_spec->pool_size);
2283 fore200e->bus->write(supply_blksize, &bs_spec->supply_blksize);
2287 static int fore200e_initialize(struct fore200e *fore200e)
2289 struct cp_queues __iomem * cpq;
2290 int ok, scheme, magn;
2292 DPRINTK(2, "device %s being initialized\n", fore200e->name);
2294 mutex_init(&fore200e->rate_mtx);
2295 spin_lock_init(&fore200e->q_lock);
2297 cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2299 /* enable cp to host interrupts */
2300 fore200e->bus->write(1, &cpq->imask);
2302 if (fore200e->bus->irq_enable)
2303 fore200e->bus->irq_enable(fore200e);
2305 fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2307 fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2308 fore200e->bus->write(QUEUE_SIZE_RX, &cpq->init.rx_queue_len);
2309 fore200e->bus->write(QUEUE_SIZE_TX, &cpq->init.tx_queue_len);
2311 fore200e->bus->write(RSD_EXTENSION, &cpq->init.rsd_extension);
2312 fore200e->bus->write(TSD_EXTENSION, &cpq->init.tsd_extension);
2314 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++)
2315 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++)
2316 fore200e_param_bs_queue(fore200e, scheme, magn,
2318 fore200e_rx_buf_nbr[ scheme ][ magn ],
2321 /* issue the initialize command */
2322 fore200e->bus->write(STATUS_PENDING, &cpq->init.status);
2323 fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2325 ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2327 printk(FORE200E "device %s initialization failed\n", fore200e->name);
2331 printk(FORE200E "device %s initialized\n", fore200e->name);
2333 fore200e->state = FORE200E_STATE_INITIALIZE;
2338 static void fore200e_monitor_putc(struct fore200e *fore200e, char c)
2340 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2345 fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2349 static int fore200e_monitor_getc(struct fore200e *fore200e)
2351 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2352 unsigned long timeout = jiffies + msecs_to_jiffies(50);
2355 while (time_before(jiffies, timeout)) {
2357 c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2359 if (c & FORE200E_CP_MONITOR_UART_AVAIL) {
2361 fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2363 printk("%c", c & 0xFF);
2373 static void fore200e_monitor_puts(struct fore200e *fore200e, char *str)
2377 /* the i960 monitor doesn't accept any new character if it has something to say */
2378 while (fore200e_monitor_getc(fore200e) >= 0);
2380 fore200e_monitor_putc(fore200e, *str++);
2383 while (fore200e_monitor_getc(fore200e) >= 0);
2388 static int fore200e_load_and_start_fw(struct fore200e *fore200e)
2390 const struct firmware *firmware;
2391 const struct fw_header *fw_header;
2392 const __le32 *fw_data;
2394 u32 __iomem *load_addr;
2399 if ((err = reject_firmware(&firmware, buf, fore200e->dev)) < 0) {
2400 printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
2404 fw_data = (const __le32 *)firmware->data;
2405 fw_size = firmware->size / sizeof(u32);
2406 fw_header = (const struct fw_header *)firmware->data;
2407 load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2409 DPRINTK(2, "device %s firmware being loaded at 0x%p (%d words)\n",
2410 fore200e->name, load_addr, fw_size);
2412 if (le32_to_cpu(fw_header->magic) != FW_HEADER_MAGIC) {
2413 printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2417 for (; fw_size--; fw_data++, load_addr++)
2418 fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2420 DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2422 #if defined(__sparc_v9__)
2423 /* reported to be required by SBA cards on some sparc64 hosts */
2427 sprintf(buf, "\rgo %x\r", le32_to_cpu(fw_header->start_offset));
2428 fore200e_monitor_puts(fore200e, buf);
2430 if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2431 printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2435 printk(FORE200E "device %s firmware started\n", fore200e->name);
2437 fore200e->state = FORE200E_STATE_START_FW;
2441 release_firmware(firmware);
2446 static int fore200e_register(struct fore200e *fore200e, struct device *parent)
2448 struct atm_dev* atm_dev;
2450 DPRINTK(2, "device %s being registered\n", fore200e->name);
2452 atm_dev = atm_dev_register(fore200e->bus->proc_name, parent, &fore200e_ops,
2454 if (atm_dev == NULL) {
2455 printk(FORE200E "unable to register device %s\n", fore200e->name);
2459 atm_dev->dev_data = fore200e;
2460 fore200e->atm_dev = atm_dev;
2462 atm_dev->ci_range.vpi_bits = FORE200E_VPI_BITS;
2463 atm_dev->ci_range.vci_bits = FORE200E_VCI_BITS;
2465 fore200e->available_cell_rate = ATM_OC3_PCR;
2467 fore200e->state = FORE200E_STATE_REGISTER;
2472 static int fore200e_init(struct fore200e *fore200e, struct device *parent)
2474 if (fore200e_register(fore200e, parent) < 0)
2477 if (fore200e->bus->configure(fore200e) < 0)
2480 if (fore200e->bus->map(fore200e) < 0)
2483 if (fore200e_reset(fore200e, 1) < 0)
2486 if (fore200e_load_and_start_fw(fore200e) < 0)
2489 if (fore200e_initialize(fore200e) < 0)
2492 if (fore200e_init_cmd_queue(fore200e) < 0)
2495 if (fore200e_init_tx_queue(fore200e) < 0)
2498 if (fore200e_init_rx_queue(fore200e) < 0)
2501 if (fore200e_init_bs_queue(fore200e) < 0)
2504 if (fore200e_alloc_rx_buf(fore200e) < 0)
2507 if (fore200e_get_esi(fore200e) < 0)
2510 if (fore200e_irq_request(fore200e) < 0)
2513 fore200e_supply(fore200e);
2515 /* all done, board initialization is now complete */
2516 fore200e->state = FORE200E_STATE_COMPLETE;
2521 static const struct of_device_id fore200e_sba_match[];
2522 static int fore200e_sba_probe(struct platform_device *op)
2524 const struct of_device_id *match;
2525 struct fore200e *fore200e;
2526 static int index = 0;
2529 match = of_match_device(fore200e_sba_match, &op->dev);
2533 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2537 fore200e->bus = &fore200e_sbus_ops;
2538 fore200e->dev = &op->dev;
2539 fore200e->irq = op->archdata.irqs[0];
2540 fore200e->phys_base = op->resource[0].start;
2542 sprintf(fore200e->name, "SBA-200E-%d", index);
2544 err = fore200e_init(fore200e, &op->dev);
2546 fore200e_shutdown(fore200e);
2552 dev_set_drvdata(&op->dev, fore200e);
2557 static int fore200e_sba_remove(struct platform_device *op)
2559 struct fore200e *fore200e = dev_get_drvdata(&op->dev);
2561 fore200e_shutdown(fore200e);
2567 static const struct of_device_id fore200e_sba_match[] = {
2569 .name = SBA200E_PROM_NAME,
2573 MODULE_DEVICE_TABLE(of, fore200e_sba_match);
2575 static struct platform_driver fore200e_sba_driver = {
2577 .name = "fore_200e",
2578 .of_match_table = fore200e_sba_match,
2580 .probe = fore200e_sba_probe,
2581 .remove = fore200e_sba_remove,
2586 static int fore200e_pca_detect(struct pci_dev *pci_dev,
2587 const struct pci_device_id *pci_ent)
2589 struct fore200e* fore200e;
2591 static int index = 0;
2593 if (pci_enable_device(pci_dev)) {
2598 if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) {
2603 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2604 if (fore200e == NULL) {
2609 fore200e->bus = &fore200e_pci_ops;
2610 fore200e->dev = &pci_dev->dev;
2611 fore200e->irq = pci_dev->irq;
2612 fore200e->phys_base = pci_resource_start(pci_dev, 0);
2614 sprintf(fore200e->name, "PCA-200E-%d", index - 1);
2616 pci_set_master(pci_dev);
2618 printk(FORE200E "device PCA-200E found at 0x%lx, IRQ %s\n",
2619 fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2621 sprintf(fore200e->name, "PCA-200E-%d", index);
2623 err = fore200e_init(fore200e, &pci_dev->dev);
2625 fore200e_shutdown(fore200e);
2630 pci_set_drvdata(pci_dev, fore200e);
2638 pci_disable_device(pci_dev);
2643 static void fore200e_pca_remove_one(struct pci_dev *pci_dev)
2645 struct fore200e *fore200e;
2647 fore200e = pci_get_drvdata(pci_dev);
2649 fore200e_shutdown(fore200e);
2651 pci_disable_device(pci_dev);
2655 static const struct pci_device_id fore200e_pca_tbl[] = {
2656 { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_PCA200E, PCI_ANY_ID, PCI_ANY_ID },
2660 MODULE_DEVICE_TABLE(pci, fore200e_pca_tbl);
2662 static struct pci_driver fore200e_pca_driver = {
2663 .name = "fore_200e",
2664 .probe = fore200e_pca_detect,
2665 .remove = fore200e_pca_remove_one,
2666 .id_table = fore200e_pca_tbl,
2670 static int __init fore200e_module_init(void)
2674 printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
2677 err = platform_driver_register(&fore200e_sba_driver);
2683 err = pci_register_driver(&fore200e_pca_driver);
2688 platform_driver_unregister(&fore200e_sba_driver);
2694 static void __exit fore200e_module_cleanup(void)
2697 pci_unregister_driver(&fore200e_pca_driver);
2700 platform_driver_unregister(&fore200e_sba_driver);
2705 fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
2707 struct fore200e* fore200e = FORE200E_DEV(dev);
2708 struct fore200e_vcc* fore200e_vcc;
2709 struct atm_vcc* vcc;
2710 int i, len, left = *pos;
2711 unsigned long flags;
2715 if (fore200e_getstats(fore200e) < 0)
2718 len = sprintf(page,"\n"
2720 " internal name:\t\t%s\n", fore200e->name);
2722 /* print bus-specific information */
2723 if (fore200e->bus->proc_read)
2724 len += fore200e->bus->proc_read(fore200e, page + len);
2726 len += sprintf(page + len,
2727 " interrupt line:\t\t%s\n"
2728 " physical base address:\t0x%p\n"
2729 " virtual base address:\t0x%p\n"
2730 " factory address (ESI):\t%pM\n"
2731 " board serial number:\t\t%d\n\n",
2732 fore200e_irq_itoa(fore200e->irq),
2733 (void*)fore200e->phys_base,
2734 fore200e->virt_base,
2736 fore200e->esi[4] * 256 + fore200e->esi[5]);
2742 return sprintf(page,
2743 " free small bufs, scheme 1:\t%d\n"
2744 " free large bufs, scheme 1:\t%d\n"
2745 " free small bufs, scheme 2:\t%d\n"
2746 " free large bufs, scheme 2:\t%d\n",
2747 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2748 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2749 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2750 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2753 u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2755 len = sprintf(page,"\n\n"
2756 " cell processor:\n"
2757 " heartbeat state:\t\t");
2759 if (hb >> 16 != 0xDEAD)
2760 len += sprintf(page + len, "0x%08x\n", hb);
2762 len += sprintf(page + len, "*** FATAL ERROR %04x ***\n", hb & 0xFFFF);
2768 static const char* media_name[] = {
2769 "unshielded twisted pair",
2770 "multimode optical fiber ST",
2771 "multimode optical fiber SC",
2772 "single-mode optical fiber ST",
2773 "single-mode optical fiber SC",
2777 static const char* oc3_mode[] = {
2779 "diagnostic loopback",
2784 u32 fw_release = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2785 u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2786 u32 oc3_revision = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2787 u32 media_index = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2790 if (media_index > 4)
2793 switch (fore200e->loop_mode) {
2794 case ATM_LM_NONE: oc3_index = 0;
2796 case ATM_LM_LOC_PHY: oc3_index = 1;
2798 case ATM_LM_RMT_PHY: oc3_index = 2;
2800 default: oc3_index = 3;
2803 return sprintf(page,
2804 " firmware release:\t\t%d.%d.%d\n"
2805 " monitor release:\t\t%d.%d\n"
2806 " media type:\t\t\t%s\n"
2807 " OC-3 revision:\t\t0x%x\n"
2808 " OC-3 mode:\t\t\t%s",
2809 fw_release >> 16, fw_release << 16 >> 24, fw_release << 24 >> 24,
2810 mon960_release >> 16, mon960_release << 16 >> 16,
2811 media_name[ media_index ],
2813 oc3_mode[ oc3_index ]);
2817 struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2819 return sprintf(page,
2822 " version number:\t\t%d\n"
2823 " boot status word:\t\t0x%08x\n",
2824 fore200e->bus->read(&cp_monitor->mon_version),
2825 fore200e->bus->read(&cp_monitor->bstat));
2829 return sprintf(page,
2831 " device statistics:\n"
2833 " crc_header_errors:\t\t%10u\n"
2834 " framing_errors:\t\t%10u\n",
2835 be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2836 be32_to_cpu(fore200e->stats->phy.framing_errors));
2839 return sprintf(page, "\n"
2841 " section_bip8_errors:\t%10u\n"
2842 " path_bip8_errors:\t\t%10u\n"
2843 " line_bip24_errors:\t\t%10u\n"
2844 " line_febe_errors:\t\t%10u\n"
2845 " path_febe_errors:\t\t%10u\n"
2846 " corr_hcs_errors:\t\t%10u\n"
2847 " ucorr_hcs_errors:\t\t%10u\n",
2848 be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2849 be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2850 be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2851 be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2852 be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2853 be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2854 be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
2857 return sprintf(page,"\n"
2858 " ATM:\t\t\t\t cells\n"
2861 " vpi out of range:\t\t%10u\n"
2862 " vpi no conn:\t\t%10u\n"
2863 " vci out of range:\t\t%10u\n"
2864 " vci no conn:\t\t%10u\n",
2865 be32_to_cpu(fore200e->stats->atm.cells_transmitted),
2866 be32_to_cpu(fore200e->stats->atm.cells_received),
2867 be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
2868 be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
2869 be32_to_cpu(fore200e->stats->atm.vci_bad_range),
2870 be32_to_cpu(fore200e->stats->atm.vci_no_conn));
2873 return sprintf(page,"\n"
2874 " AAL0:\t\t\t cells\n"
2877 " dropped:\t\t\t%10u\n",
2878 be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
2879 be32_to_cpu(fore200e->stats->aal0.cells_received),
2880 be32_to_cpu(fore200e->stats->aal0.cells_dropped));
2883 return sprintf(page,"\n"
2885 " SAR sublayer:\t\t cells\n"
2888 " dropped:\t\t\t%10u\n"
2889 " CRC errors:\t\t%10u\n"
2890 " protocol errors:\t\t%10u\n\n"
2891 " CS sublayer:\t\t PDUs\n"
2894 " dropped:\t\t\t%10u\n"
2895 " protocol errors:\t\t%10u\n",
2896 be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
2897 be32_to_cpu(fore200e->stats->aal34.cells_received),
2898 be32_to_cpu(fore200e->stats->aal34.cells_dropped),
2899 be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
2900 be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
2901 be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
2902 be32_to_cpu(fore200e->stats->aal34.cspdus_received),
2903 be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
2904 be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
2907 return sprintf(page,"\n"
2909 " SAR sublayer:\t\t cells\n"
2912 " dropped:\t\t\t%10u\n"
2913 " congestions:\t\t%10u\n\n"
2914 " CS sublayer:\t\t PDUs\n"
2917 " dropped:\t\t\t%10u\n"
2918 " CRC errors:\t\t%10u\n"
2919 " protocol errors:\t\t%10u\n",
2920 be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
2921 be32_to_cpu(fore200e->stats->aal5.cells_received),
2922 be32_to_cpu(fore200e->stats->aal5.cells_dropped),
2923 be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
2924 be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
2925 be32_to_cpu(fore200e->stats->aal5.cspdus_received),
2926 be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
2927 be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
2928 be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
2931 return sprintf(page,"\n"
2932 " AUX:\t\t allocation failures\n"
2933 " small b1:\t\t\t%10u\n"
2934 " large b1:\t\t\t%10u\n"
2935 " small b2:\t\t\t%10u\n"
2936 " large b2:\t\t\t%10u\n"
2937 " RX PDUs:\t\t\t%10u\n"
2938 " TX PDUs:\t\t\t%10lu\n",
2939 be32_to_cpu(fore200e->stats->aux.small_b1_failed),
2940 be32_to_cpu(fore200e->stats->aux.large_b1_failed),
2941 be32_to_cpu(fore200e->stats->aux.small_b2_failed),
2942 be32_to_cpu(fore200e->stats->aux.large_b2_failed),
2943 be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
2947 return sprintf(page,"\n"
2948 " receive carrier:\t\t\t%s\n",
2949 fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
2952 return sprintf(page,"\n"
2953 " VCCs:\n address VPI VCI AAL "
2954 "TX PDUs TX min/max size RX PDUs RX min/max size\n");
2957 for (i = 0; i < NBR_CONNECT; i++) {
2959 vcc = fore200e->vc_map[i].vcc;
2964 spin_lock_irqsave(&fore200e->q_lock, flags);
2966 if (vcc && test_bit(ATM_VF_READY, &vcc->flags) && !left--) {
2968 fore200e_vcc = FORE200E_VCC(vcc);
2969 ASSERT(fore200e_vcc);
2972 " %pK %03d %05d %1d %09lu %05d/%05d %09lu %05d/%05d\n",
2974 vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
2975 fore200e_vcc->tx_pdu,
2976 fore200e_vcc->tx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->tx_min_pdu,
2977 fore200e_vcc->tx_max_pdu,
2978 fore200e_vcc->rx_pdu,
2979 fore200e_vcc->rx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->rx_min_pdu,
2980 fore200e_vcc->rx_max_pdu);
2982 spin_unlock_irqrestore(&fore200e->q_lock, flags);
2986 spin_unlock_irqrestore(&fore200e->q_lock, flags);
2992 module_init(fore200e_module_init);
2993 module_exit(fore200e_module_cleanup);
2996 static const struct atmdev_ops fore200e_ops = {
2997 .open = fore200e_open,
2998 .close = fore200e_close,
2999 .ioctl = fore200e_ioctl,
3000 .send = fore200e_send,
3001 .change_qos = fore200e_change_qos,
3002 .proc_read = fore200e_proc_read,
3003 .owner = THIS_MODULE
3006 MODULE_LICENSE("GPL");
3008 #ifdef __LITTLE_ENDIAN__
3013 #endif /* CONFIG_PCI */