2 A FORE Systems 200E-series driver for ATM on Linux.
3 Christophe Lizzi (lizzi@cnam.fr), October 1999-March 2003.
5 Based on the PCA-200E driver from Uwe Dannowski (Uwe.Dannowski@inf.tu-dresden.de).
7 This driver simultaneously supports PCA-200E and SBA-200E adapters
8 on i386, alpha (untested), powerpc, sparc and sparc64 architectures.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/kernel.h>
27 #include <linux/slab.h>
28 #include <linux/init.h>
29 #include <linux/capability.h>
30 #include <linux/interrupt.h>
31 #include <linux/bitops.h>
32 #include <linux/pci.h>
33 #include <linux/module.h>
34 #include <linux/atmdev.h>
35 #include <linux/sonet.h>
36 #include <linux/atm_suni.h>
37 #include <linux/dma-mapping.h>
38 #include <linux/delay.h>
39 #include <linux/firmware.h>
41 #include <asm/string.h>
45 #include <asm/byteorder.h>
46 #include <linux/uaccess.h>
47 #include <linux/atomic.h>
51 #include <linux/of_device.h>
52 #include <asm/idprom.h>
53 #include <asm/openprom.h>
54 #include <asm/oplib.h>
55 #include <asm/pgtable.h>
58 #if defined(CONFIG_ATM_FORE200E_USE_TASKLET) /* defer interrupt work to a tasklet */
59 #define FORE200E_USE_TASKLET
62 #if 0 /* enable the debugging code of the buffer supply queues */
63 #define FORE200E_BSQ_DEBUG
66 #if 1 /* ensure correct handling of 52-byte AAL0 SDUs expected by atmdump-like apps */
67 #define FORE200E_52BYTE_AAL0_SDU
73 #define FORE200E_VERSION "0.3e"
75 #define FORE200E "fore200e: "
77 #if 0 /* override .config */
78 #define CONFIG_ATM_FORE200E_DEBUG 1
80 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
81 #define DPRINTK(level, format, args...) do { if (CONFIG_ATM_FORE200E_DEBUG >= (level)) \
82 printk(FORE200E format, ##args); } while (0)
84 #define DPRINTK(level, format, args...) do {} while (0)
88 #define FORE200E_ALIGN(addr, alignment) \
89 ((((unsigned long)(addr) + (alignment - 1)) & ~(alignment - 1)) - (unsigned long)(addr))
91 #define FORE200E_DMA_INDEX(dma_addr, type, index) ((dma_addr) + (index) * sizeof(type))
93 #define FORE200E_INDEX(virt_addr, type, index) (&((type *)(virt_addr))[ index ])
95 #define FORE200E_NEXT_ENTRY(index, modulo) (index = ((index) + 1) % (modulo))
98 #define ASSERT(expr) if (!(expr)) { \
99 printk(FORE200E "assertion failed! %s[%d]: %s\n", \
100 __func__, __LINE__, #expr); \
101 panic(FORE200E "%s", __func__); \
104 #define ASSERT(expr) do {} while (0)
108 static const struct atmdev_ops fore200e_ops;
109 static const struct fore200e_bus fore200e_bus[];
111 static LIST_HEAD(fore200e_boards);
114 MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");
115 MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);
116 MODULE_SUPPORTED_DEVICE("PCA-200E, SBA-200E");
119 static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
120 { BUFFER_S1_NBR, BUFFER_L1_NBR },
121 { BUFFER_S2_NBR, BUFFER_L2_NBR }
124 static const int fore200e_rx_buf_size[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
125 { BUFFER_S1_SIZE, BUFFER_L1_SIZE },
126 { BUFFER_S2_SIZE, BUFFER_L2_SIZE }
130 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
131 static const char* fore200e_traffic_class[] = { "NONE", "UBR", "CBR", "VBR", "ABR", "ANY" };
135 #if 0 /* currently unused */
137 fore200e_fore2atm_aal(enum fore200e_aal aal)
140 case FORE200E_AAL0: return ATM_AAL0;
141 case FORE200E_AAL34: return ATM_AAL34;
142 case FORE200E_AAL5: return ATM_AAL5;
150 static enum fore200e_aal
151 fore200e_atm2fore_aal(int aal)
154 case ATM_AAL0: return FORE200E_AAL0;
155 case ATM_AAL34: return FORE200E_AAL34;
158 case ATM_AAL5: return FORE200E_AAL5;
166 fore200e_irq_itoa(int irq)
169 sprintf(str, "%d", irq);
174 /* allocate and align a chunk of memory intended to hold the data behing exchanged
175 between the driver and the adapter (using streaming DVMA) */
178 fore200e_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, int size, int alignment, int direction)
180 unsigned long offset = 0;
182 if (alignment <= sizeof(int))
185 chunk->alloc_size = size + alignment;
186 chunk->align_size = size;
187 chunk->direction = direction;
189 chunk->alloc_addr = kzalloc(chunk->alloc_size, GFP_KERNEL | GFP_DMA);
190 if (chunk->alloc_addr == NULL)
194 offset = FORE200E_ALIGN(chunk->alloc_addr, alignment);
196 chunk->align_addr = chunk->alloc_addr + offset;
198 chunk->dma_addr = fore200e->bus->dma_map(fore200e, chunk->align_addr, chunk->align_size, direction);
204 /* free a chunk of memory */
207 fore200e_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
209 fore200e->bus->dma_unmap(fore200e, chunk->dma_addr, chunk->dma_size, chunk->direction);
211 kfree(chunk->alloc_addr);
216 fore200e_spin(int msecs)
218 unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
219 while (time_before(jiffies, timeout));
224 fore200e_poll(struct fore200e* fore200e, volatile u32* addr, u32 val, int msecs)
226 unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
231 if ((ok = (*addr == val)) || (*addr & STATUS_ERROR))
234 } while (time_before(jiffies, timeout));
238 printk(FORE200E "cmd polling failed, got status 0x%08x, expected 0x%08x\n",
248 fore200e_io_poll(struct fore200e* fore200e, volatile u32 __iomem *addr, u32 val, int msecs)
250 unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
254 if ((ok = (fore200e->bus->read(addr) == val)))
257 } while (time_before(jiffies, timeout));
261 printk(FORE200E "I/O polling failed, got status 0x%08x, expected 0x%08x\n",
262 fore200e->bus->read(addr), val);
271 fore200e_free_rx_buf(struct fore200e* fore200e)
273 int scheme, magn, nbr;
274 struct buffer* buffer;
276 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
277 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
279 if ((buffer = fore200e->host_bsq[ scheme ][ magn ].buffer) != NULL) {
281 for (nbr = 0; nbr < fore200e_rx_buf_nbr[ scheme ][ magn ]; nbr++) {
283 struct chunk* data = &buffer[ nbr ].data;
285 if (data->alloc_addr != NULL)
286 fore200e_chunk_free(fore200e, data);
295 fore200e_uninit_bs_queue(struct fore200e* fore200e)
299 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
300 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
302 struct chunk* status = &fore200e->host_bsq[ scheme ][ magn ].status;
303 struct chunk* rbd_block = &fore200e->host_bsq[ scheme ][ magn ].rbd_block;
305 if (status->alloc_addr)
306 fore200e->bus->dma_chunk_free(fore200e, status);
308 if (rbd_block->alloc_addr)
309 fore200e->bus->dma_chunk_free(fore200e, rbd_block);
316 fore200e_reset(struct fore200e* fore200e, int diag)
320 fore200e->cp_monitor = fore200e->virt_base + FORE200E_CP_MONITOR_OFFSET;
322 fore200e->bus->write(BSTAT_COLD_START, &fore200e->cp_monitor->bstat);
324 fore200e->bus->reset(fore200e);
327 ok = fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_SELFTEST_OK, 1000);
330 printk(FORE200E "device %s self-test failed\n", fore200e->name);
334 printk(FORE200E "device %s self-test passed\n", fore200e->name);
336 fore200e->state = FORE200E_STATE_RESET;
344 fore200e_shutdown(struct fore200e* fore200e)
346 printk(FORE200E "removing device %s at 0x%lx, IRQ %s\n",
347 fore200e->name, fore200e->phys_base,
348 fore200e_irq_itoa(fore200e->irq));
350 if (fore200e->state > FORE200E_STATE_RESET) {
351 /* first, reset the board to prevent further interrupts or data transfers */
352 fore200e_reset(fore200e, 0);
355 /* then, release all allocated resources */
356 switch(fore200e->state) {
358 case FORE200E_STATE_COMPLETE:
359 kfree(fore200e->stats);
361 case FORE200E_STATE_IRQ:
362 free_irq(fore200e->irq, fore200e->atm_dev);
364 case FORE200E_STATE_ALLOC_BUF:
365 fore200e_free_rx_buf(fore200e);
367 case FORE200E_STATE_INIT_BSQ:
368 fore200e_uninit_bs_queue(fore200e);
370 case FORE200E_STATE_INIT_RXQ:
371 fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_rxq.status);
372 fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_rxq.rpd);
374 case FORE200E_STATE_INIT_TXQ:
375 fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_txq.status);
376 fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_txq.tpd);
378 case FORE200E_STATE_INIT_CMDQ:
379 fore200e->bus->dma_chunk_free(fore200e, &fore200e->host_cmdq.status);
381 case FORE200E_STATE_INITIALIZE:
382 /* nothing to do for that state */
384 case FORE200E_STATE_START_FW:
385 /* nothing to do for that state */
387 case FORE200E_STATE_RESET:
388 /* nothing to do for that state */
390 case FORE200E_STATE_MAP:
391 fore200e->bus->unmap(fore200e);
393 case FORE200E_STATE_CONFIGURE:
394 /* nothing to do for that state */
396 case FORE200E_STATE_REGISTER:
397 /* XXX shouldn't we *start* by deregistering the device? */
398 atm_dev_deregister(fore200e->atm_dev);
400 case FORE200E_STATE_BLANK:
401 /* nothing to do for that state */
409 static u32 fore200e_pca_read(volatile u32 __iomem *addr)
411 /* on big-endian hosts, the board is configured to convert
412 the endianess of slave RAM accesses */
413 return le32_to_cpu(readl(addr));
417 static void fore200e_pca_write(u32 val, volatile u32 __iomem *addr)
419 /* on big-endian hosts, the board is configured to convert
420 the endianess of slave RAM accesses */
421 writel(cpu_to_le32(val), addr);
426 fore200e_pca_dma_map(struct fore200e* fore200e, void* virt_addr, int size, int direction)
428 u32 dma_addr = dma_map_single(&((struct pci_dev *) fore200e->bus_dev)->dev, virt_addr, size, direction);
430 DPRINTK(3, "PCI DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d, --> dma_addr = 0x%08x\n",
431 virt_addr, size, direction, dma_addr);
438 fore200e_pca_dma_unmap(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
440 DPRINTK(3, "PCI DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d\n",
441 dma_addr, size, direction);
443 dma_unmap_single(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction);
448 fore200e_pca_dma_sync_for_cpu(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
450 DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
452 dma_sync_single_for_cpu(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction);
456 fore200e_pca_dma_sync_for_device(struct fore200e* fore200e, u32 dma_addr, int size, int direction)
458 DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
460 dma_sync_single_for_device(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction);
464 /* allocate a DMA consistent chunk of memory intended to act as a communication mechanism
465 (to hold descriptors, status, queues, etc.) shared by the driver and the adapter */
468 fore200e_pca_dma_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk,
469 int size, int nbr, int alignment)
471 /* returned chunks are page-aligned */
472 chunk->alloc_size = size * nbr;
473 chunk->alloc_addr = dma_alloc_coherent(&((struct pci_dev *) fore200e->bus_dev)->dev,
478 if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0))
481 chunk->align_addr = chunk->alloc_addr;
487 /* free a DMA consistent chunk of memory */
490 fore200e_pca_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
492 dma_free_coherent(&((struct pci_dev *) fore200e->bus_dev)->dev,
500 fore200e_pca_irq_check(struct fore200e* fore200e)
502 /* this is a 1 bit register */
503 int irq_posted = readl(fore200e->regs.pca.psr);
505 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG == 2)
506 if (irq_posted && (readl(fore200e->regs.pca.hcr) & PCA200E_HCR_OUTFULL)) {
507 DPRINTK(2,"FIFO OUT full, device %d\n", fore200e->atm_dev->number);
516 fore200e_pca_irq_ack(struct fore200e* fore200e)
518 writel(PCA200E_HCR_CLRINTR, fore200e->regs.pca.hcr);
523 fore200e_pca_reset(struct fore200e* fore200e)
525 writel(PCA200E_HCR_RESET, fore200e->regs.pca.hcr);
527 writel(0, fore200e->regs.pca.hcr);
531 static int fore200e_pca_map(struct fore200e* fore200e)
533 DPRINTK(2, "device %s being mapped in memory\n", fore200e->name);
535 fore200e->virt_base = ioremap(fore200e->phys_base, PCA200E_IOSPACE_LENGTH);
537 if (fore200e->virt_base == NULL) {
538 printk(FORE200E "can't map device %s\n", fore200e->name);
542 DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
544 /* gain access to the PCA specific registers */
545 fore200e->regs.pca.hcr = fore200e->virt_base + PCA200E_HCR_OFFSET;
546 fore200e->regs.pca.imr = fore200e->virt_base + PCA200E_IMR_OFFSET;
547 fore200e->regs.pca.psr = fore200e->virt_base + PCA200E_PSR_OFFSET;
549 fore200e->state = FORE200E_STATE_MAP;
555 fore200e_pca_unmap(struct fore200e* fore200e)
557 DPRINTK(2, "device %s being unmapped from memory\n", fore200e->name);
559 if (fore200e->virt_base != NULL)
560 iounmap(fore200e->virt_base);
564 static int fore200e_pca_configure(struct fore200e *fore200e)
566 struct pci_dev* pci_dev = (struct pci_dev*)fore200e->bus_dev;
567 u8 master_ctrl, latency;
569 DPRINTK(2, "device %s being configured\n", fore200e->name);
571 if ((pci_dev->irq == 0) || (pci_dev->irq == 0xFF)) {
572 printk(FORE200E "incorrect IRQ setting - misconfigured PCI-PCI bridge?\n");
576 pci_read_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, &master_ctrl);
578 master_ctrl = master_ctrl
579 #if defined(__BIG_ENDIAN)
580 /* request the PCA board to convert the endianess of slave RAM accesses */
581 | PCA200E_CTRL_CONVERT_ENDIAN
584 | PCA200E_CTRL_DIS_CACHE_RD
585 | PCA200E_CTRL_DIS_WRT_INVAL
586 | PCA200E_CTRL_ENA_CONT_REQ_MODE
587 | PCA200E_CTRL_2_CACHE_WRT_INVAL
589 | PCA200E_CTRL_LARGE_PCI_BURSTS;
591 pci_write_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, master_ctrl);
593 /* raise latency from 32 (default) to 192, as this seems to prevent NIC
594 lockups (under heavy rx loads) due to continuous 'FIFO OUT full' condition.
595 this may impact the performances of other PCI devices on the same bus, though */
597 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
599 fore200e->state = FORE200E_STATE_CONFIGURE;
605 fore200e_pca_prom_read(struct fore200e* fore200e, struct prom_data* prom)
607 struct host_cmdq* cmdq = &fore200e->host_cmdq;
608 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
609 struct prom_opcode opcode;
613 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
615 opcode.opcode = OPCODE_GET_PROM;
618 prom_dma = fore200e->bus->dma_map(fore200e, prom, sizeof(struct prom_data), DMA_FROM_DEVICE);
620 fore200e->bus->write(prom_dma, &entry->cp_entry->cmd.prom_block.prom_haddr);
622 *entry->status = STATUS_PENDING;
624 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.prom_block.opcode);
626 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
628 *entry->status = STATUS_FREE;
630 fore200e->bus->dma_unmap(fore200e, prom_dma, sizeof(struct prom_data), DMA_FROM_DEVICE);
633 printk(FORE200E "unable to get PROM data from device %s\n", fore200e->name);
637 #if defined(__BIG_ENDIAN)
639 #define swap_here(addr) (*((u32*)(addr)) = swab32( *((u32*)(addr)) ))
641 /* MAC address is stored as little-endian */
642 swap_here(&prom->mac_addr[0]);
643 swap_here(&prom->mac_addr[4]);
651 fore200e_pca_proc_read(struct fore200e* fore200e, char *page)
653 struct pci_dev* pci_dev = (struct pci_dev*)fore200e->bus_dev;
655 return sprintf(page, " PCI bus/slot/function:\t%d/%d/%d\n",
656 pci_dev->bus->number, PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
659 #endif /* CONFIG_PCI */
664 static u32 fore200e_sba_read(volatile u32 __iomem *addr)
666 return sbus_readl(addr);
669 static void fore200e_sba_write(u32 val, volatile u32 __iomem *addr)
671 sbus_writel(val, addr);
674 static u32 fore200e_sba_dma_map(struct fore200e *fore200e, void* virt_addr, int size, int direction)
676 struct platform_device *op = fore200e->bus_dev;
679 dma_addr = dma_map_single(&op->dev, virt_addr, size, direction);
681 DPRINTK(3, "SBUS DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d --> dma_addr = 0x%08x\n",
682 virt_addr, size, direction, dma_addr);
687 static void fore200e_sba_dma_unmap(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
689 struct platform_device *op = fore200e->bus_dev;
691 DPRINTK(3, "SBUS DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d,\n",
692 dma_addr, size, direction);
694 dma_unmap_single(&op->dev, dma_addr, size, direction);
697 static void fore200e_sba_dma_sync_for_cpu(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
699 struct platform_device *op = fore200e->bus_dev;
701 DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
703 dma_sync_single_for_cpu(&op->dev, dma_addr, size, direction);
706 static void fore200e_sba_dma_sync_for_device(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
708 struct platform_device *op = fore200e->bus_dev;
710 DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
712 dma_sync_single_for_device(&op->dev, dma_addr, size, direction);
715 /* Allocate a DVMA consistent chunk of memory intended to act as a communication mechanism
716 * (to hold descriptors, status, queues, etc.) shared by the driver and the adapter.
718 static int fore200e_sba_dma_chunk_alloc(struct fore200e *fore200e, struct chunk *chunk,
719 int size, int nbr, int alignment)
721 struct platform_device *op = fore200e->bus_dev;
723 chunk->alloc_size = chunk->align_size = size * nbr;
725 /* returned chunks are page-aligned */
726 chunk->alloc_addr = dma_alloc_coherent(&op->dev, chunk->alloc_size,
727 &chunk->dma_addr, GFP_ATOMIC);
729 if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0))
732 chunk->align_addr = chunk->alloc_addr;
737 /* free a DVMA consistent chunk of memory */
738 static void fore200e_sba_dma_chunk_free(struct fore200e *fore200e, struct chunk *chunk)
740 struct platform_device *op = fore200e->bus_dev;
742 dma_free_coherent(&op->dev, chunk->alloc_size,
743 chunk->alloc_addr, chunk->dma_addr);
746 static void fore200e_sba_irq_enable(struct fore200e *fore200e)
748 u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
749 fore200e->bus->write(hcr | SBA200E_HCR_INTR_ENA, fore200e->regs.sba.hcr);
752 static int fore200e_sba_irq_check(struct fore200e *fore200e)
754 return fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_INTR_REQ;
757 static void fore200e_sba_irq_ack(struct fore200e *fore200e)
759 u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
760 fore200e->bus->write(hcr | SBA200E_HCR_INTR_CLR, fore200e->regs.sba.hcr);
763 static void fore200e_sba_reset(struct fore200e *fore200e)
765 fore200e->bus->write(SBA200E_HCR_RESET, fore200e->regs.sba.hcr);
767 fore200e->bus->write(0, fore200e->regs.sba.hcr);
770 static int __init fore200e_sba_map(struct fore200e *fore200e)
772 struct platform_device *op = fore200e->bus_dev;
775 /* gain access to the SBA specific registers */
776 fore200e->regs.sba.hcr = of_ioremap(&op->resource[0], 0, SBA200E_HCR_LENGTH, "SBA HCR");
777 fore200e->regs.sba.bsr = of_ioremap(&op->resource[1], 0, SBA200E_BSR_LENGTH, "SBA BSR");
778 fore200e->regs.sba.isr = of_ioremap(&op->resource[2], 0, SBA200E_ISR_LENGTH, "SBA ISR");
779 fore200e->virt_base = of_ioremap(&op->resource[3], 0, SBA200E_RAM_LENGTH, "SBA RAM");
781 if (!fore200e->virt_base) {
782 printk(FORE200E "unable to map RAM of device %s\n", fore200e->name);
786 DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
788 fore200e->bus->write(0x02, fore200e->regs.sba.isr); /* XXX hardwired interrupt level */
790 /* get the supported DVMA burst sizes */
791 bursts = of_getintprop_default(op->dev.of_node->parent, "burst-sizes", 0x00);
793 if (sbus_can_dma_64bit())
794 sbus_set_sbus64(&op->dev, bursts);
796 fore200e->state = FORE200E_STATE_MAP;
800 static void fore200e_sba_unmap(struct fore200e *fore200e)
802 struct platform_device *op = fore200e->bus_dev;
804 of_iounmap(&op->resource[0], fore200e->regs.sba.hcr, SBA200E_HCR_LENGTH);
805 of_iounmap(&op->resource[1], fore200e->regs.sba.bsr, SBA200E_BSR_LENGTH);
806 of_iounmap(&op->resource[2], fore200e->regs.sba.isr, SBA200E_ISR_LENGTH);
807 of_iounmap(&op->resource[3], fore200e->virt_base, SBA200E_RAM_LENGTH);
810 static int __init fore200e_sba_configure(struct fore200e *fore200e)
812 fore200e->state = FORE200E_STATE_CONFIGURE;
816 static int __init fore200e_sba_prom_read(struct fore200e *fore200e, struct prom_data *prom)
818 struct platform_device *op = fore200e->bus_dev;
822 prop = of_get_property(op->dev.of_node, "madaddrlo2", &len);
825 memcpy(&prom->mac_addr[4], prop, 4);
827 prop = of_get_property(op->dev.of_node, "madaddrhi4", &len);
830 memcpy(&prom->mac_addr[2], prop, 4);
832 prom->serial_number = of_getintprop_default(op->dev.of_node,
834 prom->hw_revision = of_getintprop_default(op->dev.of_node,
840 static int fore200e_sba_proc_read(struct fore200e *fore200e, char *page)
842 struct platform_device *op = fore200e->bus_dev;
843 const struct linux_prom_registers *regs;
845 regs = of_get_property(op->dev.of_node, "reg", NULL);
847 return sprintf(page, " SBUS slot/device:\t\t%d/'%s'\n",
848 (regs ? regs->which_io : 0), op->dev.of_node->name);
850 #endif /* CONFIG_SBUS */
854 fore200e_tx_irq(struct fore200e* fore200e)
856 struct host_txq* txq = &fore200e->host_txq;
857 struct host_txq_entry* entry;
859 struct fore200e_vc_map* vc_map;
861 if (fore200e->host_txq.txing == 0)
866 entry = &txq->host_entry[ txq->tail ];
868 if ((*entry->status & STATUS_COMPLETE) == 0) {
872 DPRINTK(3, "TX COMPLETED: entry = %p [tail = %d], vc_map = %p, skb = %p\n",
873 entry, txq->tail, entry->vc_map, entry->skb);
875 /* free copy of misaligned data */
878 /* remove DMA mapping */
879 fore200e->bus->dma_unmap(fore200e, entry->tpd->tsd[ 0 ].buffer, entry->tpd->tsd[ 0 ].length,
882 vc_map = entry->vc_map;
884 /* vcc closed since the time the entry was submitted for tx? */
885 if ((vc_map->vcc == NULL) ||
886 (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
888 DPRINTK(1, "no ready vcc found for PDU sent on device %d\n",
889 fore200e->atm_dev->number);
891 dev_kfree_skb_any(entry->skb);
896 /* vcc closed then immediately re-opened? */
897 if (vc_map->incarn != entry->incarn) {
899 /* when a vcc is closed, some PDUs may be still pending in the tx queue.
900 if the same vcc is immediately re-opened, those pending PDUs must
901 not be popped after the completion of their emission, as they refer
902 to the prior incarnation of that vcc. otherwise, sk_atm(vcc)->sk_wmem_alloc
903 would be decremented by the size of the (unrelated) skb, possibly
904 leading to a negative sk->sk_wmem_alloc count, ultimately freezing the vcc.
905 we thus bind the tx entry to the current incarnation of the vcc
906 when the entry is submitted for tx. When the tx later completes,
907 if the incarnation number of the tx entry does not match the one
908 of the vcc, then this implies that the vcc has been closed then re-opened.
909 we thus just drop the skb here. */
911 DPRINTK(1, "vcc closed-then-re-opened; dropping PDU sent on device %d\n",
912 fore200e->atm_dev->number);
914 dev_kfree_skb_any(entry->skb);
920 /* notify tx completion */
922 vcc->pop(vcc, entry->skb);
925 dev_kfree_skb_any(entry->skb);
928 /* check error condition */
929 if (*entry->status & STATUS_ERROR)
930 atomic_inc(&vcc->stats->tx_err);
932 atomic_inc(&vcc->stats->tx);
936 *entry->status = STATUS_FREE;
938 fore200e->host_txq.txing--;
940 FORE200E_NEXT_ENTRY(txq->tail, QUEUE_SIZE_TX);
945 #ifdef FORE200E_BSQ_DEBUG
946 int bsq_audit(int where, struct host_bsq* bsq, int scheme, int magn)
948 struct buffer* buffer;
951 buffer = bsq->freebuf;
954 if (buffer->supplied) {
955 printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld supplied but in free list!\n",
956 where, scheme, magn, buffer->index);
959 if (buffer->magn != magn) {
960 printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected magn = %d\n",
961 where, scheme, magn, buffer->index, buffer->magn);
964 if (buffer->scheme != scheme) {
965 printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected scheme = %d\n",
966 where, scheme, magn, buffer->index, buffer->scheme);
969 if ((buffer->index < 0) || (buffer->index >= fore200e_rx_buf_nbr[ scheme ][ magn ])) {
970 printk(FORE200E "bsq_audit(%d): queue %d.%d, out of range buffer index = %ld !\n",
971 where, scheme, magn, buffer->index);
975 buffer = buffer->next;
978 if (count != bsq->freebuf_count) {
979 printk(FORE200E "bsq_audit(%d): queue %d.%d, %d bufs in free list, but freebuf_count = %d\n",
980 where, scheme, magn, count, bsq->freebuf_count);
988 fore200e_supply(struct fore200e* fore200e)
992 struct host_bsq* bsq;
993 struct host_bsq_entry* entry;
994 struct buffer* buffer;
996 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
997 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
999 bsq = &fore200e->host_bsq[ scheme ][ magn ];
1001 #ifdef FORE200E_BSQ_DEBUG
1002 bsq_audit(1, bsq, scheme, magn);
1004 while (bsq->freebuf_count >= RBD_BLK_SIZE) {
1006 DPRINTK(2, "supplying %d rx buffers to queue %d / %d, freebuf_count = %d\n",
1007 RBD_BLK_SIZE, scheme, magn, bsq->freebuf_count);
1009 entry = &bsq->host_entry[ bsq->head ];
1011 for (i = 0; i < RBD_BLK_SIZE; i++) {
1013 /* take the first buffer in the free buffer list */
1014 buffer = bsq->freebuf;
1016 printk(FORE200E "no more free bufs in queue %d.%d, but freebuf_count = %d\n",
1017 scheme, magn, bsq->freebuf_count);
1020 bsq->freebuf = buffer->next;
1022 #ifdef FORE200E_BSQ_DEBUG
1023 if (buffer->supplied)
1024 printk(FORE200E "queue %d.%d, buffer %lu already supplied\n",
1025 scheme, magn, buffer->index);
1026 buffer->supplied = 1;
1028 entry->rbd_block->rbd[ i ].buffer_haddr = buffer->data.dma_addr;
1029 entry->rbd_block->rbd[ i ].handle = FORE200E_BUF2HDL(buffer);
1032 FORE200E_NEXT_ENTRY(bsq->head, QUEUE_SIZE_BS);
1034 /* decrease accordingly the number of free rx buffers */
1035 bsq->freebuf_count -= RBD_BLK_SIZE;
1037 *entry->status = STATUS_PENDING;
1038 fore200e->bus->write(entry->rbd_block_dma, &entry->cp_entry->rbd_block_haddr);
1046 fore200e_push_rpd(struct fore200e* fore200e, struct atm_vcc* vcc, struct rpd* rpd)
1048 struct sk_buff* skb;
1049 struct buffer* buffer;
1050 struct fore200e_vcc* fore200e_vcc;
1052 #ifdef FORE200E_52BYTE_AAL0_SDU
1053 u32 cell_header = 0;
1058 fore200e_vcc = FORE200E_VCC(vcc);
1059 ASSERT(fore200e_vcc);
1061 #ifdef FORE200E_52BYTE_AAL0_SDU
1062 if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.rxtp.max_sdu == ATM_AAL0_SDU)) {
1064 cell_header = (rpd->atm_header.gfc << ATM_HDR_GFC_SHIFT) |
1065 (rpd->atm_header.vpi << ATM_HDR_VPI_SHIFT) |
1066 (rpd->atm_header.vci << ATM_HDR_VCI_SHIFT) |
1067 (rpd->atm_header.plt << ATM_HDR_PTI_SHIFT) |
1068 rpd->atm_header.clp;
1073 /* compute total PDU length */
1074 for (i = 0; i < rpd->nseg; i++)
1075 pdu_len += rpd->rsd[ i ].length;
1077 skb = alloc_skb(pdu_len, GFP_ATOMIC);
1079 DPRINTK(2, "unable to alloc new skb, rx PDU length = %d\n", pdu_len);
1081 atomic_inc(&vcc->stats->rx_drop);
1085 __net_timestamp(skb);
1087 #ifdef FORE200E_52BYTE_AAL0_SDU
1089 *((u32*)skb_put(skb, 4)) = cell_header;
1093 /* reassemble segments */
1094 for (i = 0; i < rpd->nseg; i++) {
1096 /* rebuild rx buffer address from rsd handle */
1097 buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1099 /* Make device DMA transfer visible to CPU. */
1100 fore200e->bus->dma_sync_for_cpu(fore200e, buffer->data.dma_addr, rpd->rsd[ i ].length, DMA_FROM_DEVICE);
1102 skb_put_data(skb, buffer->data.align_addr, rpd->rsd[i].length);
1104 /* Now let the device get at it again. */
1105 fore200e->bus->dma_sync_for_device(fore200e, buffer->data.dma_addr, rpd->rsd[ i ].length, DMA_FROM_DEVICE);
1108 DPRINTK(3, "rx skb: len = %d, truesize = %d\n", skb->len, skb->truesize);
1110 if (pdu_len < fore200e_vcc->rx_min_pdu)
1111 fore200e_vcc->rx_min_pdu = pdu_len;
1112 if (pdu_len > fore200e_vcc->rx_max_pdu)
1113 fore200e_vcc->rx_max_pdu = pdu_len;
1114 fore200e_vcc->rx_pdu++;
1117 if (atm_charge(vcc, skb->truesize) == 0) {
1119 DPRINTK(2, "receive buffers saturated for %d.%d.%d - PDU dropped\n",
1120 vcc->itf, vcc->vpi, vcc->vci);
1122 dev_kfree_skb_any(skb);
1124 atomic_inc(&vcc->stats->rx_drop);
1128 vcc->push(vcc, skb);
1129 atomic_inc(&vcc->stats->rx);
1136 fore200e_collect_rpd(struct fore200e* fore200e, struct rpd* rpd)
1138 struct host_bsq* bsq;
1139 struct buffer* buffer;
1142 for (i = 0; i < rpd->nseg; i++) {
1144 /* rebuild rx buffer address from rsd handle */
1145 buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1147 bsq = &fore200e->host_bsq[ buffer->scheme ][ buffer->magn ];
1149 #ifdef FORE200E_BSQ_DEBUG
1150 bsq_audit(2, bsq, buffer->scheme, buffer->magn);
1152 if (buffer->supplied == 0)
1153 printk(FORE200E "queue %d.%d, buffer %ld was not supplied\n",
1154 buffer->scheme, buffer->magn, buffer->index);
1155 buffer->supplied = 0;
1158 /* re-insert the buffer into the free buffer list */
1159 buffer->next = bsq->freebuf;
1160 bsq->freebuf = buffer;
1162 /* then increment the number of free rx buffers */
1163 bsq->freebuf_count++;
1169 fore200e_rx_irq(struct fore200e* fore200e)
1171 struct host_rxq* rxq = &fore200e->host_rxq;
1172 struct host_rxq_entry* entry;
1173 struct atm_vcc* vcc;
1174 struct fore200e_vc_map* vc_map;
1178 entry = &rxq->host_entry[ rxq->head ];
1180 /* no more received PDUs */
1181 if ((*entry->status & STATUS_COMPLETE) == 0)
1184 vc_map = FORE200E_VC_MAP(fore200e, entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1186 if ((vc_map->vcc == NULL) ||
1187 (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
1189 DPRINTK(1, "no ready VC found for PDU received on %d.%d.%d\n",
1190 fore200e->atm_dev->number,
1191 entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1197 if ((*entry->status & STATUS_ERROR) == 0) {
1199 fore200e_push_rpd(fore200e, vcc, entry->rpd);
1202 DPRINTK(2, "damaged PDU on %d.%d.%d\n",
1203 fore200e->atm_dev->number,
1204 entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1205 atomic_inc(&vcc->stats->rx_err);
1209 FORE200E_NEXT_ENTRY(rxq->head, QUEUE_SIZE_RX);
1211 fore200e_collect_rpd(fore200e, entry->rpd);
1213 /* rewrite the rpd address to ack the received PDU */
1214 fore200e->bus->write(entry->rpd_dma, &entry->cp_entry->rpd_haddr);
1215 *entry->status = STATUS_FREE;
1217 fore200e_supply(fore200e);
1222 #ifndef FORE200E_USE_TASKLET
1224 fore200e_irq(struct fore200e* fore200e)
1226 unsigned long flags;
1228 spin_lock_irqsave(&fore200e->q_lock, flags);
1229 fore200e_rx_irq(fore200e);
1230 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1232 spin_lock_irqsave(&fore200e->q_lock, flags);
1233 fore200e_tx_irq(fore200e);
1234 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1240 fore200e_interrupt(int irq, void* dev)
1242 struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev);
1244 if (fore200e->bus->irq_check(fore200e) == 0) {
1246 DPRINTK(3, "interrupt NOT triggered by device %d\n", fore200e->atm_dev->number);
1249 DPRINTK(3, "interrupt triggered by device %d\n", fore200e->atm_dev->number);
1251 #ifdef FORE200E_USE_TASKLET
1252 tasklet_schedule(&fore200e->tx_tasklet);
1253 tasklet_schedule(&fore200e->rx_tasklet);
1255 fore200e_irq(fore200e);
1258 fore200e->bus->irq_ack(fore200e);
1263 #ifdef FORE200E_USE_TASKLET
1265 fore200e_tx_tasklet(unsigned long data)
1267 struct fore200e* fore200e = (struct fore200e*) data;
1268 unsigned long flags;
1270 DPRINTK(3, "tx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1272 spin_lock_irqsave(&fore200e->q_lock, flags);
1273 fore200e_tx_irq(fore200e);
1274 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1279 fore200e_rx_tasklet(unsigned long data)
1281 struct fore200e* fore200e = (struct fore200e*) data;
1282 unsigned long flags;
1284 DPRINTK(3, "rx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1286 spin_lock_irqsave(&fore200e->q_lock, flags);
1287 fore200e_rx_irq((struct fore200e*) data);
1288 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1294 fore200e_select_scheme(struct atm_vcc* vcc)
1296 /* fairly balance the VCs over (identical) buffer schemes */
1297 int scheme = vcc->vci % 2 ? BUFFER_SCHEME_ONE : BUFFER_SCHEME_TWO;
1299 DPRINTK(1, "VC %d.%d.%d uses buffer scheme %d\n",
1300 vcc->itf, vcc->vpi, vcc->vci, scheme);
1307 fore200e_activate_vcin(struct fore200e* fore200e, int activate, struct atm_vcc* vcc, int mtu)
1309 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1310 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1311 struct activate_opcode activ_opcode;
1312 struct deactivate_opcode deactiv_opcode;
1315 enum fore200e_aal aal = fore200e_atm2fore_aal(vcc->qos.aal);
1317 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1320 FORE200E_VCC(vcc)->scheme = fore200e_select_scheme(vcc);
1322 activ_opcode.opcode = OPCODE_ACTIVATE_VCIN;
1323 activ_opcode.aal = aal;
1324 activ_opcode.scheme = FORE200E_VCC(vcc)->scheme;
1325 activ_opcode.pad = 0;
1328 deactiv_opcode.opcode = OPCODE_DEACTIVATE_VCIN;
1329 deactiv_opcode.pad = 0;
1332 vpvc.vci = vcc->vci;
1333 vpvc.vpi = vcc->vpi;
1335 *entry->status = STATUS_PENDING;
1339 #ifdef FORE200E_52BYTE_AAL0_SDU
1342 /* the MTU is not used by the cp, except in the case of AAL0 */
1343 fore200e->bus->write(mtu, &entry->cp_entry->cmd.activate_block.mtu);
1344 fore200e->bus->write(*(u32*)&vpvc, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.vpvc);
1345 fore200e->bus->write(*(u32*)&activ_opcode, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.opcode);
1348 fore200e->bus->write(*(u32*)&vpvc, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.vpvc);
1349 fore200e->bus->write(*(u32*)&deactiv_opcode, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.opcode);
1352 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1354 *entry->status = STATUS_FREE;
1357 printk(FORE200E "unable to %s VC %d.%d.%d\n",
1358 activate ? "open" : "close", vcc->itf, vcc->vpi, vcc->vci);
1362 DPRINTK(1, "VC %d.%d.%d %sed\n", vcc->itf, vcc->vpi, vcc->vci,
1363 activate ? "open" : "clos");
1369 #define FORE200E_MAX_BACK2BACK_CELLS 255 /* XXX depends on CDVT */
1372 fore200e_rate_ctrl(struct atm_qos* qos, struct tpd_rate* rate)
1374 if (qos->txtp.max_pcr < ATM_OC3_PCR) {
1376 /* compute the data cells to idle cells ratio from the tx PCR */
1377 rate->data_cells = qos->txtp.max_pcr * FORE200E_MAX_BACK2BACK_CELLS / ATM_OC3_PCR;
1378 rate->idle_cells = FORE200E_MAX_BACK2BACK_CELLS - rate->data_cells;
1381 /* disable rate control */
1382 rate->data_cells = rate->idle_cells = 0;
1388 fore200e_open(struct atm_vcc *vcc)
1390 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1391 struct fore200e_vcc* fore200e_vcc;
1392 struct fore200e_vc_map* vc_map;
1393 unsigned long flags;
1395 short vpi = vcc->vpi;
1397 ASSERT((vpi >= 0) && (vpi < 1<<FORE200E_VPI_BITS));
1398 ASSERT((vci >= 0) && (vci < 1<<FORE200E_VCI_BITS));
1400 spin_lock_irqsave(&fore200e->q_lock, flags);
1402 vc_map = FORE200E_VC_MAP(fore200e, vpi, vci);
1405 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1407 printk(FORE200E "VC %d.%d.%d already in use\n",
1408 fore200e->atm_dev->number, vpi, vci);
1415 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1417 fore200e_vcc = kzalloc(sizeof(struct fore200e_vcc), GFP_ATOMIC);
1418 if (fore200e_vcc == NULL) {
1423 DPRINTK(2, "opening %d.%d.%d:%d QoS = (tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1424 "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d)\n",
1425 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1426 fore200e_traffic_class[ vcc->qos.txtp.traffic_class ],
1427 vcc->qos.txtp.min_pcr, vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_cdv, vcc->qos.txtp.max_sdu,
1428 fore200e_traffic_class[ vcc->qos.rxtp.traffic_class ],
1429 vcc->qos.rxtp.min_pcr, vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_cdv, vcc->qos.rxtp.max_sdu);
1431 /* pseudo-CBR bandwidth requested? */
1432 if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1434 mutex_lock(&fore200e->rate_mtx);
1435 if (fore200e->available_cell_rate < vcc->qos.txtp.max_pcr) {
1436 mutex_unlock(&fore200e->rate_mtx);
1438 kfree(fore200e_vcc);
1443 /* reserve bandwidth */
1444 fore200e->available_cell_rate -= vcc->qos.txtp.max_pcr;
1445 mutex_unlock(&fore200e->rate_mtx);
1448 vcc->itf = vcc->dev->number;
1450 set_bit(ATM_VF_PARTIAL,&vcc->flags);
1451 set_bit(ATM_VF_ADDR, &vcc->flags);
1453 vcc->dev_data = fore200e_vcc;
1455 if (fore200e_activate_vcin(fore200e, 1, vcc, vcc->qos.rxtp.max_sdu) < 0) {
1459 clear_bit(ATM_VF_ADDR, &vcc->flags);
1460 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1462 vcc->dev_data = NULL;
1464 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1466 kfree(fore200e_vcc);
1470 /* compute rate control parameters */
1471 if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1473 fore200e_rate_ctrl(&vcc->qos, &fore200e_vcc->rate);
1474 set_bit(ATM_VF_HASQOS, &vcc->flags);
1476 DPRINTK(3, "tx on %d.%d.%d:%d, tx PCR = %d, rx PCR = %d, data_cells = %u, idle_cells = %u\n",
1477 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1478 vcc->qos.txtp.max_pcr, vcc->qos.rxtp.max_pcr,
1479 fore200e_vcc->rate.data_cells, fore200e_vcc->rate.idle_cells);
1482 fore200e_vcc->tx_min_pdu = fore200e_vcc->rx_min_pdu = MAX_PDU_SIZE + 1;
1483 fore200e_vcc->tx_max_pdu = fore200e_vcc->rx_max_pdu = 0;
1484 fore200e_vcc->tx_pdu = fore200e_vcc->rx_pdu = 0;
1486 /* new incarnation of the vcc */
1487 vc_map->incarn = ++fore200e->incarn_count;
1489 /* VC unusable before this flag is set */
1490 set_bit(ATM_VF_READY, &vcc->flags);
1497 fore200e_close(struct atm_vcc* vcc)
1499 struct fore200e_vcc* fore200e_vcc;
1500 struct fore200e* fore200e;
1501 struct fore200e_vc_map* vc_map;
1502 unsigned long flags;
1505 fore200e = FORE200E_DEV(vcc->dev);
1507 ASSERT((vcc->vpi >= 0) && (vcc->vpi < 1<<FORE200E_VPI_BITS));
1508 ASSERT((vcc->vci >= 0) && (vcc->vci < 1<<FORE200E_VCI_BITS));
1510 DPRINTK(2, "closing %d.%d.%d:%d\n", vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal));
1512 clear_bit(ATM_VF_READY, &vcc->flags);
1514 fore200e_activate_vcin(fore200e, 0, vcc, 0);
1516 spin_lock_irqsave(&fore200e->q_lock, flags);
1518 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1520 /* the vc is no longer considered as "in use" by fore200e_open() */
1523 vcc->itf = vcc->vci = vcc->vpi = 0;
1525 fore200e_vcc = FORE200E_VCC(vcc);
1526 vcc->dev_data = NULL;
1528 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1530 /* release reserved bandwidth, if any */
1531 if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1533 mutex_lock(&fore200e->rate_mtx);
1534 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1535 mutex_unlock(&fore200e->rate_mtx);
1537 clear_bit(ATM_VF_HASQOS, &vcc->flags);
1540 clear_bit(ATM_VF_ADDR, &vcc->flags);
1541 clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1543 ASSERT(fore200e_vcc);
1544 kfree(fore200e_vcc);
1549 fore200e_send(struct atm_vcc *vcc, struct sk_buff *skb)
1551 struct fore200e* fore200e;
1552 struct fore200e_vcc* fore200e_vcc;
1553 struct fore200e_vc_map* vc_map;
1554 struct host_txq* txq;
1555 struct host_txq_entry* entry;
1557 struct tpd_haddr tpd_haddr;
1558 int retry = CONFIG_ATM_FORE200E_TX_RETRY;
1560 int tx_len = skb->len;
1561 u32* cell_header = NULL;
1562 unsigned char* skb_data;
1564 unsigned char* data;
1565 unsigned long flags;
1570 fore200e = FORE200E_DEV(vcc->dev);
1571 fore200e_vcc = FORE200E_VCC(vcc);
1576 txq = &fore200e->host_txq;
1580 if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1581 DPRINTK(1, "VC %d.%d.%d not ready for tx\n", vcc->itf, vcc->vpi, vcc->vpi);
1582 dev_kfree_skb_any(skb);
1586 #ifdef FORE200E_52BYTE_AAL0_SDU
1587 if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.txtp.max_sdu == ATM_AAL0_SDU)) {
1588 cell_header = (u32*) skb->data;
1589 skb_data = skb->data + 4; /* skip 4-byte cell header */
1590 skb_len = tx_len = skb->len - 4;
1592 DPRINTK(3, "user-supplied cell header = 0x%08x\n", *cell_header);
1597 skb_data = skb->data;
1601 if (((unsigned long)skb_data) & 0x3) {
1603 DPRINTK(2, "misaligned tx PDU on device %s\n", fore200e->name);
1608 if ((vcc->qos.aal == ATM_AAL0) && (skb_len % ATM_CELL_PAYLOAD)) {
1610 /* this simply NUKES the PCA board */
1611 DPRINTK(2, "incomplete tx AAL0 PDU on device %s\n", fore200e->name);
1613 tx_len = ((skb_len / ATM_CELL_PAYLOAD) + 1) * ATM_CELL_PAYLOAD;
1617 data = kmalloc(tx_len, GFP_ATOMIC | GFP_DMA);
1623 dev_kfree_skb_any(skb);
1628 memcpy(data, skb_data, skb_len);
1629 if (skb_len < tx_len)
1630 memset(data + skb_len, 0x00, tx_len - skb_len);
1636 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1637 ASSERT(vc_map->vcc == vcc);
1641 spin_lock_irqsave(&fore200e->q_lock, flags);
1643 entry = &txq->host_entry[ txq->head ];
1645 if ((*entry->status != STATUS_FREE) || (txq->txing >= QUEUE_SIZE_TX - 2)) {
1647 /* try to free completed tx queue entries */
1648 fore200e_tx_irq(fore200e);
1650 if (*entry->status != STATUS_FREE) {
1652 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1654 /* retry once again? */
1660 atomic_inc(&vcc->stats->tx_err);
1663 DPRINTK(2, "tx queue of device %s is saturated, PDU dropped - heartbeat is %08x\n",
1664 fore200e->name, fore200e->cp_queues->heartbeat);
1669 dev_kfree_skb_any(skb);
1679 entry->incarn = vc_map->incarn;
1680 entry->vc_map = vc_map;
1682 entry->data = tx_copy ? data : NULL;
1685 tpd->tsd[ 0 ].buffer = fore200e->bus->dma_map(fore200e, data, tx_len, DMA_TO_DEVICE);
1686 tpd->tsd[ 0 ].length = tx_len;
1688 FORE200E_NEXT_ENTRY(txq->head, QUEUE_SIZE_TX);
1691 /* The dma_map call above implies a dma_sync so the device can use it,
1692 * thus no explicit dma_sync call is necessary here.
1695 DPRINTK(3, "tx on %d.%d.%d:%d, len = %u (%u)\n",
1696 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1697 tpd->tsd[0].length, skb_len);
1699 if (skb_len < fore200e_vcc->tx_min_pdu)
1700 fore200e_vcc->tx_min_pdu = skb_len;
1701 if (skb_len > fore200e_vcc->tx_max_pdu)
1702 fore200e_vcc->tx_max_pdu = skb_len;
1703 fore200e_vcc->tx_pdu++;
1705 /* set tx rate control information */
1706 tpd->rate.data_cells = fore200e_vcc->rate.data_cells;
1707 tpd->rate.idle_cells = fore200e_vcc->rate.idle_cells;
1710 tpd->atm_header.clp = (*cell_header & ATM_HDR_CLP);
1711 tpd->atm_header.plt = (*cell_header & ATM_HDR_PTI_MASK) >> ATM_HDR_PTI_SHIFT;
1712 tpd->atm_header.vci = (*cell_header & ATM_HDR_VCI_MASK) >> ATM_HDR_VCI_SHIFT;
1713 tpd->atm_header.vpi = (*cell_header & ATM_HDR_VPI_MASK) >> ATM_HDR_VPI_SHIFT;
1714 tpd->atm_header.gfc = (*cell_header & ATM_HDR_GFC_MASK) >> ATM_HDR_GFC_SHIFT;
1717 /* set the ATM header, common to all cells conveying the PDU */
1718 tpd->atm_header.clp = 0;
1719 tpd->atm_header.plt = 0;
1720 tpd->atm_header.vci = vcc->vci;
1721 tpd->atm_header.vpi = vcc->vpi;
1722 tpd->atm_header.gfc = 0;
1725 tpd->spec.length = tx_len;
1727 tpd->spec.aal = fore200e_atm2fore_aal(vcc->qos.aal);
1730 tpd_haddr.size = sizeof(struct tpd) / (1<<TPD_HADDR_SHIFT); /* size is expressed in 32 byte blocks */
1732 tpd_haddr.haddr = entry->tpd_dma >> TPD_HADDR_SHIFT; /* shift the address, as we are in a bitfield */
1734 *entry->status = STATUS_PENDING;
1735 fore200e->bus->write(*(u32*)&tpd_haddr, (u32 __iomem *)&entry->cp_entry->tpd_haddr);
1737 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1744 fore200e_getstats(struct fore200e* fore200e)
1746 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1747 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1748 struct stats_opcode opcode;
1752 if (fore200e->stats == NULL) {
1753 fore200e->stats = kzalloc(sizeof(struct stats), GFP_KERNEL | GFP_DMA);
1754 if (fore200e->stats == NULL)
1758 stats_dma_addr = fore200e->bus->dma_map(fore200e, fore200e->stats,
1759 sizeof(struct stats), DMA_FROM_DEVICE);
1761 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1763 opcode.opcode = OPCODE_GET_STATS;
1766 fore200e->bus->write(stats_dma_addr, &entry->cp_entry->cmd.stats_block.stats_haddr);
1768 *entry->status = STATUS_PENDING;
1770 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.stats_block.opcode);
1772 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1774 *entry->status = STATUS_FREE;
1776 fore200e->bus->dma_unmap(fore200e, stats_dma_addr, sizeof(struct stats), DMA_FROM_DEVICE);
1779 printk(FORE200E "unable to get statistics from device %s\n", fore200e->name);
1788 fore200e_getsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, int optlen)
1790 /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1792 DPRINTK(2, "getsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1793 vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1800 fore200e_setsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, unsigned int optlen)
1802 /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1804 DPRINTK(2, "setsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1805 vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1811 #if 0 /* currently unused */
1813 fore200e_get_oc3(struct fore200e* fore200e, struct oc3_regs* regs)
1815 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1816 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1817 struct oc3_opcode opcode;
1819 u32 oc3_regs_dma_addr;
1821 oc3_regs_dma_addr = fore200e->bus->dma_map(fore200e, regs, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1823 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1825 opcode.opcode = OPCODE_GET_OC3;
1830 fore200e->bus->write(oc3_regs_dma_addr, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1832 *entry->status = STATUS_PENDING;
1834 fore200e->bus->write(*(u32*)&opcode, (u32*)&entry->cp_entry->cmd.oc3_block.opcode);
1836 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1838 *entry->status = STATUS_FREE;
1840 fore200e->bus->dma_unmap(fore200e, oc3_regs_dma_addr, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1843 printk(FORE200E "unable to get OC-3 regs of device %s\n", fore200e->name);
1853 fore200e_set_oc3(struct fore200e* fore200e, u32 reg, u32 value, u32 mask)
1855 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1856 struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1857 struct oc3_opcode opcode;
1860 DPRINTK(2, "set OC-3 reg = 0x%02x, value = 0x%02x, mask = 0x%02x\n", reg, value, mask);
1862 FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1864 opcode.opcode = OPCODE_SET_OC3;
1866 opcode.value = value;
1869 fore200e->bus->write(0, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1871 *entry->status = STATUS_PENDING;
1873 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.oc3_block.opcode);
1875 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1877 *entry->status = STATUS_FREE;
1880 printk(FORE200E "unable to set OC-3 reg 0x%02x of device %s\n", reg, fore200e->name);
1889 fore200e_setloop(struct fore200e* fore200e, int loop_mode)
1891 u32 mct_value, mct_mask;
1894 if (!capable(CAP_NET_ADMIN))
1897 switch (loop_mode) {
1901 mct_mask = SUNI_MCT_DLE | SUNI_MCT_LLE;
1904 case ATM_LM_LOC_PHY:
1905 mct_value = mct_mask = SUNI_MCT_DLE;
1908 case ATM_LM_RMT_PHY:
1909 mct_value = mct_mask = SUNI_MCT_LLE;
1916 error = fore200e_set_oc3(fore200e, SUNI_MCT, mct_value, mct_mask);
1918 fore200e->loop_mode = loop_mode;
1925 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
1927 struct sonet_stats tmp;
1929 if (fore200e_getstats(fore200e) < 0)
1932 tmp.section_bip = be32_to_cpu(fore200e->stats->oc3.section_bip8_errors);
1933 tmp.line_bip = be32_to_cpu(fore200e->stats->oc3.line_bip24_errors);
1934 tmp.path_bip = be32_to_cpu(fore200e->stats->oc3.path_bip8_errors);
1935 tmp.line_febe = be32_to_cpu(fore200e->stats->oc3.line_febe_errors);
1936 tmp.path_febe = be32_to_cpu(fore200e->stats->oc3.path_febe_errors);
1937 tmp.corr_hcs = be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors);
1938 tmp.uncorr_hcs = be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors);
1939 tmp.tx_cells = be32_to_cpu(fore200e->stats->aal0.cells_transmitted) +
1940 be32_to_cpu(fore200e->stats->aal34.cells_transmitted) +
1941 be32_to_cpu(fore200e->stats->aal5.cells_transmitted);
1942 tmp.rx_cells = be32_to_cpu(fore200e->stats->aal0.cells_received) +
1943 be32_to_cpu(fore200e->stats->aal34.cells_received) +
1944 be32_to_cpu(fore200e->stats->aal5.cells_received);
1947 return copy_to_user(arg, &tmp, sizeof(struct sonet_stats)) ? -EFAULT : 0;
1954 fore200e_ioctl(struct atm_dev* dev, unsigned int cmd, void __user * arg)
1956 struct fore200e* fore200e = FORE200E_DEV(dev);
1958 DPRINTK(2, "ioctl cmd = 0x%x (%u), arg = 0x%p (%lu)\n", cmd, cmd, arg, (unsigned long)arg);
1963 return fore200e_fetch_stats(fore200e, (struct sonet_stats __user *)arg);
1966 return put_user(0, (int __user *)arg) ? -EFAULT : 0;
1969 return fore200e_setloop(fore200e, (int)(unsigned long)arg);
1972 return put_user(fore200e->loop_mode, (int __user *)arg) ? -EFAULT : 0;
1975 return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY, (int __user *)arg) ? -EFAULT : 0;
1978 return -ENOSYS; /* not implemented */
1983 fore200e_change_qos(struct atm_vcc* vcc,struct atm_qos* qos, int flags)
1985 struct fore200e_vcc* fore200e_vcc = FORE200E_VCC(vcc);
1986 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1988 if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1989 DPRINTK(1, "VC %d.%d.%d not ready for QoS change\n", vcc->itf, vcc->vpi, vcc->vpi);
1993 DPRINTK(2, "change_qos %d.%d.%d, "
1994 "(tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1995 "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d), flags = 0x%x\n"
1996 "available_cell_rate = %u",
1997 vcc->itf, vcc->vpi, vcc->vci,
1998 fore200e_traffic_class[ qos->txtp.traffic_class ],
1999 qos->txtp.min_pcr, qos->txtp.max_pcr, qos->txtp.max_cdv, qos->txtp.max_sdu,
2000 fore200e_traffic_class[ qos->rxtp.traffic_class ],
2001 qos->rxtp.min_pcr, qos->rxtp.max_pcr, qos->rxtp.max_cdv, qos->rxtp.max_sdu,
2002 flags, fore200e->available_cell_rate);
2004 if ((qos->txtp.traffic_class == ATM_CBR) && (qos->txtp.max_pcr > 0)) {
2006 mutex_lock(&fore200e->rate_mtx);
2007 if (fore200e->available_cell_rate + vcc->qos.txtp.max_pcr < qos->txtp.max_pcr) {
2008 mutex_unlock(&fore200e->rate_mtx);
2012 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
2013 fore200e->available_cell_rate -= qos->txtp.max_pcr;
2015 mutex_unlock(&fore200e->rate_mtx);
2017 memcpy(&vcc->qos, qos, sizeof(struct atm_qos));
2019 /* update rate control parameters */
2020 fore200e_rate_ctrl(qos, &fore200e_vcc->rate);
2022 set_bit(ATM_VF_HASQOS, &vcc->flags);
2031 static int fore200e_irq_request(struct fore200e *fore200e)
2033 if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
2035 printk(FORE200E "unable to reserve IRQ %s for device %s\n",
2036 fore200e_irq_itoa(fore200e->irq), fore200e->name);
2040 printk(FORE200E "IRQ %s reserved for device %s\n",
2041 fore200e_irq_itoa(fore200e->irq), fore200e->name);
2043 #ifdef FORE200E_USE_TASKLET
2044 tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
2045 tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
2048 fore200e->state = FORE200E_STATE_IRQ;
2053 static int fore200e_get_esi(struct fore200e *fore200e)
2055 struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL | GFP_DMA);
2061 ok = fore200e->bus->prom_read(fore200e, prom);
2067 printk(FORE200E "device %s, rev. %c, S/N: %d, ESI: %pM\n",
2069 (prom->hw_revision & 0xFF) + '@', /* probably meaningless with SBA boards */
2070 prom->serial_number & 0xFFFF, &prom->mac_addr[2]);
2072 for (i = 0; i < ESI_LEN; i++) {
2073 fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
2082 static int fore200e_alloc_rx_buf(struct fore200e *fore200e)
2084 int scheme, magn, nbr, size, i;
2086 struct host_bsq* bsq;
2087 struct buffer* buffer;
2089 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2090 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2092 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2094 nbr = fore200e_rx_buf_nbr[ scheme ][ magn ];
2095 size = fore200e_rx_buf_size[ scheme ][ magn ];
2097 DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
2099 /* allocate the array of receive buffers */
2100 buffer = bsq->buffer = kzalloc(nbr * sizeof(struct buffer), GFP_KERNEL);
2105 bsq->freebuf = NULL;
2107 for (i = 0; i < nbr; i++) {
2109 buffer[ i ].scheme = scheme;
2110 buffer[ i ].magn = magn;
2111 #ifdef FORE200E_BSQ_DEBUG
2112 buffer[ i ].index = i;
2113 buffer[ i ].supplied = 0;
2116 /* allocate the receive buffer body */
2117 if (fore200e_chunk_alloc(fore200e,
2118 &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2119 DMA_FROM_DEVICE) < 0) {
2122 fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2128 /* insert the buffer into the free buffer list */
2129 buffer[ i ].next = bsq->freebuf;
2130 bsq->freebuf = &buffer[ i ];
2132 /* all the buffers are free, initially */
2133 bsq->freebuf_count = nbr;
2135 #ifdef FORE200E_BSQ_DEBUG
2136 bsq_audit(3, bsq, scheme, magn);
2141 fore200e->state = FORE200E_STATE_ALLOC_BUF;
2146 static int fore200e_init_bs_queue(struct fore200e *fore200e)
2148 int scheme, magn, i;
2150 struct host_bsq* bsq;
2151 struct cp_bsq_entry __iomem * cp_entry;
2153 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2154 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2156 DPRINTK(2, "buffer supply queue %d / %d is being initialized\n", scheme, magn);
2158 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2160 /* allocate and align the array of status words */
2161 if (fore200e->bus->dma_chunk_alloc(fore200e,
2163 sizeof(enum status),
2165 fore200e->bus->status_alignment) < 0) {
2169 /* allocate and align the array of receive buffer descriptors */
2170 if (fore200e->bus->dma_chunk_alloc(fore200e,
2172 sizeof(struct rbd_block),
2174 fore200e->bus->descr_alignment) < 0) {
2176 fore200e->bus->dma_chunk_free(fore200e, &bsq->status);
2180 /* get the base address of the cp resident buffer supply queue entries */
2181 cp_entry = fore200e->virt_base +
2182 fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2184 /* fill the host resident and cp resident buffer supply queue entries */
2185 for (i = 0; i < QUEUE_SIZE_BS; i++) {
2187 bsq->host_entry[ i ].status =
2188 FORE200E_INDEX(bsq->status.align_addr, enum status, i);
2189 bsq->host_entry[ i ].rbd_block =
2190 FORE200E_INDEX(bsq->rbd_block.align_addr, struct rbd_block, i);
2191 bsq->host_entry[ i ].rbd_block_dma =
2192 FORE200E_DMA_INDEX(bsq->rbd_block.dma_addr, struct rbd_block, i);
2193 bsq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2195 *bsq->host_entry[ i ].status = STATUS_FREE;
2197 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i),
2198 &cp_entry[ i ].status_haddr);
2203 fore200e->state = FORE200E_STATE_INIT_BSQ;
2208 static int fore200e_init_rx_queue(struct fore200e *fore200e)
2210 struct host_rxq* rxq = &fore200e->host_rxq;
2211 struct cp_rxq_entry __iomem * cp_entry;
2214 DPRINTK(2, "receive queue is being initialized\n");
2216 /* allocate and align the array of status words */
2217 if (fore200e->bus->dma_chunk_alloc(fore200e,
2219 sizeof(enum status),
2221 fore200e->bus->status_alignment) < 0) {
2225 /* allocate and align the array of receive PDU descriptors */
2226 if (fore200e->bus->dma_chunk_alloc(fore200e,
2230 fore200e->bus->descr_alignment) < 0) {
2232 fore200e->bus->dma_chunk_free(fore200e, &rxq->status);
2236 /* get the base address of the cp resident rx queue entries */
2237 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2239 /* fill the host resident and cp resident rx entries */
2240 for (i=0; i < QUEUE_SIZE_RX; i++) {
2242 rxq->host_entry[ i ].status =
2243 FORE200E_INDEX(rxq->status.align_addr, enum status, i);
2244 rxq->host_entry[ i ].rpd =
2245 FORE200E_INDEX(rxq->rpd.align_addr, struct rpd, i);
2246 rxq->host_entry[ i ].rpd_dma =
2247 FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i);
2248 rxq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2250 *rxq->host_entry[ i ].status = STATUS_FREE;
2252 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i),
2253 &cp_entry[ i ].status_haddr);
2255 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2256 &cp_entry[ i ].rpd_haddr);
2259 /* set the head entry of the queue */
2262 fore200e->state = FORE200E_STATE_INIT_RXQ;
2267 static int fore200e_init_tx_queue(struct fore200e *fore200e)
2269 struct host_txq* txq = &fore200e->host_txq;
2270 struct cp_txq_entry __iomem * cp_entry;
2273 DPRINTK(2, "transmit queue is being initialized\n");
2275 /* allocate and align the array of status words */
2276 if (fore200e->bus->dma_chunk_alloc(fore200e,
2278 sizeof(enum status),
2280 fore200e->bus->status_alignment) < 0) {
2284 /* allocate and align the array of transmit PDU descriptors */
2285 if (fore200e->bus->dma_chunk_alloc(fore200e,
2289 fore200e->bus->descr_alignment) < 0) {
2291 fore200e->bus->dma_chunk_free(fore200e, &txq->status);
2295 /* get the base address of the cp resident tx queue entries */
2296 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2298 /* fill the host resident and cp resident tx entries */
2299 for (i=0; i < QUEUE_SIZE_TX; i++) {
2301 txq->host_entry[ i ].status =
2302 FORE200E_INDEX(txq->status.align_addr, enum status, i);
2303 txq->host_entry[ i ].tpd =
2304 FORE200E_INDEX(txq->tpd.align_addr, struct tpd, i);
2305 txq->host_entry[ i ].tpd_dma =
2306 FORE200E_DMA_INDEX(txq->tpd.dma_addr, struct tpd, i);
2307 txq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2309 *txq->host_entry[ i ].status = STATUS_FREE;
2311 fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i),
2312 &cp_entry[ i ].status_haddr);
2314 /* although there is a one-to-one mapping of tx queue entries and tpds,
2315 we do not write here the DMA (physical) base address of each tpd into
2316 the related cp resident entry, because the cp relies on this write
2317 operation to detect that a new pdu has been submitted for tx */
2320 /* set the head and tail entries of the queue */
2324 fore200e->state = FORE200E_STATE_INIT_TXQ;
2329 static int fore200e_init_cmd_queue(struct fore200e *fore200e)
2331 struct host_cmdq* cmdq = &fore200e->host_cmdq;
2332 struct cp_cmdq_entry __iomem * cp_entry;
2335 DPRINTK(2, "command queue is being initialized\n");
2337 /* allocate and align the array of status words */
2338 if (fore200e->bus->dma_chunk_alloc(fore200e,
2340 sizeof(enum status),
2342 fore200e->bus->status_alignment) < 0) {
2346 /* get the base address of the cp resident cmd queue entries */
2347 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2349 /* fill the host resident and cp resident cmd entries */
2350 for (i=0; i < QUEUE_SIZE_CMD; i++) {
2352 cmdq->host_entry[ i ].status =
2353 FORE200E_INDEX(cmdq->status.align_addr, enum status, i);
2354 cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2356 *cmdq->host_entry[ i ].status = STATUS_FREE;
2358 fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),
2359 &cp_entry[ i ].status_haddr);
2362 /* set the head entry of the queue */
2365 fore200e->state = FORE200E_STATE_INIT_CMDQ;
2370 static void fore200e_param_bs_queue(struct fore200e *fore200e,
2371 enum buffer_scheme scheme,
2372 enum buffer_magn magn, int queue_length,
2373 int pool_size, int supply_blksize)
2375 struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2377 fore200e->bus->write(queue_length, &bs_spec->queue_length);
2378 fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2379 fore200e->bus->write(pool_size, &bs_spec->pool_size);
2380 fore200e->bus->write(supply_blksize, &bs_spec->supply_blksize);
2384 static int fore200e_initialize(struct fore200e *fore200e)
2386 struct cp_queues __iomem * cpq;
2387 int ok, scheme, magn;
2389 DPRINTK(2, "device %s being initialized\n", fore200e->name);
2391 mutex_init(&fore200e->rate_mtx);
2392 spin_lock_init(&fore200e->q_lock);
2394 cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2396 /* enable cp to host interrupts */
2397 fore200e->bus->write(1, &cpq->imask);
2399 if (fore200e->bus->irq_enable)
2400 fore200e->bus->irq_enable(fore200e);
2402 fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2404 fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2405 fore200e->bus->write(QUEUE_SIZE_RX, &cpq->init.rx_queue_len);
2406 fore200e->bus->write(QUEUE_SIZE_TX, &cpq->init.tx_queue_len);
2408 fore200e->bus->write(RSD_EXTENSION, &cpq->init.rsd_extension);
2409 fore200e->bus->write(TSD_EXTENSION, &cpq->init.tsd_extension);
2411 for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++)
2412 for (magn = 0; magn < BUFFER_MAGN_NBR; magn++)
2413 fore200e_param_bs_queue(fore200e, scheme, magn,
2415 fore200e_rx_buf_nbr[ scheme ][ magn ],
2418 /* issue the initialize command */
2419 fore200e->bus->write(STATUS_PENDING, &cpq->init.status);
2420 fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2422 ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2424 printk(FORE200E "device %s initialization failed\n", fore200e->name);
2428 printk(FORE200E "device %s initialized\n", fore200e->name);
2430 fore200e->state = FORE200E_STATE_INITIALIZE;
2435 static void fore200e_monitor_putc(struct fore200e *fore200e, char c)
2437 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2442 fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2446 static int fore200e_monitor_getc(struct fore200e *fore200e)
2448 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2449 unsigned long timeout = jiffies + msecs_to_jiffies(50);
2452 while (time_before(jiffies, timeout)) {
2454 c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2456 if (c & FORE200E_CP_MONITOR_UART_AVAIL) {
2458 fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2460 printk("%c", c & 0xFF);
2470 static void fore200e_monitor_puts(struct fore200e *fore200e, char *str)
2474 /* the i960 monitor doesn't accept any new character if it has something to say */
2475 while (fore200e_monitor_getc(fore200e) >= 0);
2477 fore200e_monitor_putc(fore200e, *str++);
2480 while (fore200e_monitor_getc(fore200e) >= 0);
2485 static int fore200e_load_and_start_fw(struct fore200e *fore200e)
2487 const struct firmware *firmware;
2488 struct device *device;
2489 const struct fw_header *fw_header;
2490 const __le32 *fw_data;
2492 u32 __iomem *load_addr;
2496 if (strcmp(fore200e->bus->model_name, "PCA-200E") == 0)
2497 device = &((struct pci_dev *) fore200e->bus_dev)->dev;
2499 else if (strcmp(fore200e->bus->model_name, "SBA-200E") == 0)
2500 device = &((struct platform_device *) fore200e->bus_dev)->dev;
2506 if ((err = reject_firmware(&firmware, buf, device)) < 0) {
2507 printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
2511 fw_data = (const __le32 *)firmware->data;
2512 fw_size = firmware->size / sizeof(u32);
2513 fw_header = (const struct fw_header *)firmware->data;
2514 load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2516 DPRINTK(2, "device %s firmware being loaded at 0x%p (%d words)\n",
2517 fore200e->name, load_addr, fw_size);
2519 if (le32_to_cpu(fw_header->magic) != FW_HEADER_MAGIC) {
2520 printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2524 for (; fw_size--; fw_data++, load_addr++)
2525 fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2527 DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2529 #if defined(__sparc_v9__)
2530 /* reported to be required by SBA cards on some sparc64 hosts */
2534 sprintf(buf, "\rgo %x\r", le32_to_cpu(fw_header->start_offset));
2535 fore200e_monitor_puts(fore200e, buf);
2537 if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2538 printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2542 printk(FORE200E "device %s firmware started\n", fore200e->name);
2544 fore200e->state = FORE200E_STATE_START_FW;
2548 release_firmware(firmware);
2553 static int fore200e_register(struct fore200e *fore200e, struct device *parent)
2555 struct atm_dev* atm_dev;
2557 DPRINTK(2, "device %s being registered\n", fore200e->name);
2559 atm_dev = atm_dev_register(fore200e->bus->proc_name, parent, &fore200e_ops,
2561 if (atm_dev == NULL) {
2562 printk(FORE200E "unable to register device %s\n", fore200e->name);
2566 atm_dev->dev_data = fore200e;
2567 fore200e->atm_dev = atm_dev;
2569 atm_dev->ci_range.vpi_bits = FORE200E_VPI_BITS;
2570 atm_dev->ci_range.vci_bits = FORE200E_VCI_BITS;
2572 fore200e->available_cell_rate = ATM_OC3_PCR;
2574 fore200e->state = FORE200E_STATE_REGISTER;
2579 static int fore200e_init(struct fore200e *fore200e, struct device *parent)
2581 if (fore200e_register(fore200e, parent) < 0)
2584 if (fore200e->bus->configure(fore200e) < 0)
2587 if (fore200e->bus->map(fore200e) < 0)
2590 if (fore200e_reset(fore200e, 1) < 0)
2593 if (fore200e_load_and_start_fw(fore200e) < 0)
2596 if (fore200e_initialize(fore200e) < 0)
2599 if (fore200e_init_cmd_queue(fore200e) < 0)
2602 if (fore200e_init_tx_queue(fore200e) < 0)
2605 if (fore200e_init_rx_queue(fore200e) < 0)
2608 if (fore200e_init_bs_queue(fore200e) < 0)
2611 if (fore200e_alloc_rx_buf(fore200e) < 0)
2614 if (fore200e_get_esi(fore200e) < 0)
2617 if (fore200e_irq_request(fore200e) < 0)
2620 fore200e_supply(fore200e);
2622 /* all done, board initialization is now complete */
2623 fore200e->state = FORE200E_STATE_COMPLETE;
2628 static const struct of_device_id fore200e_sba_match[];
2629 static int fore200e_sba_probe(struct platform_device *op)
2631 const struct of_device_id *match;
2632 const struct fore200e_bus *bus;
2633 struct fore200e *fore200e;
2634 static int index = 0;
2637 match = of_match_device(fore200e_sba_match, &op->dev);
2642 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2646 fore200e->bus = bus;
2647 fore200e->bus_dev = op;
2648 fore200e->irq = op->archdata.irqs[0];
2649 fore200e->phys_base = op->resource[0].start;
2651 sprintf(fore200e->name, "%s-%d", bus->model_name, index);
2653 err = fore200e_init(fore200e, &op->dev);
2655 fore200e_shutdown(fore200e);
2661 dev_set_drvdata(&op->dev, fore200e);
2666 static int fore200e_sba_remove(struct platform_device *op)
2668 struct fore200e *fore200e = dev_get_drvdata(&op->dev);
2670 fore200e_shutdown(fore200e);
2676 static const struct of_device_id fore200e_sba_match[] = {
2678 .name = SBA200E_PROM_NAME,
2679 .data = (void *) &fore200e_bus[1],
2683 MODULE_DEVICE_TABLE(of, fore200e_sba_match);
2685 static struct platform_driver fore200e_sba_driver = {
2687 .name = "fore_200e",
2688 .of_match_table = fore200e_sba_match,
2690 .probe = fore200e_sba_probe,
2691 .remove = fore200e_sba_remove,
2696 static int fore200e_pca_detect(struct pci_dev *pci_dev,
2697 const struct pci_device_id *pci_ent)
2699 const struct fore200e_bus* bus = (struct fore200e_bus*) pci_ent->driver_data;
2700 struct fore200e* fore200e;
2702 static int index = 0;
2704 if (pci_enable_device(pci_dev)) {
2709 if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) {
2714 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2715 if (fore200e == NULL) {
2720 fore200e->bus = bus;
2721 fore200e->bus_dev = pci_dev;
2722 fore200e->irq = pci_dev->irq;
2723 fore200e->phys_base = pci_resource_start(pci_dev, 0);
2725 sprintf(fore200e->name, "%s-%d", bus->model_name, index - 1);
2727 pci_set_master(pci_dev);
2729 printk(FORE200E "device %s found at 0x%lx, IRQ %s\n",
2730 fore200e->bus->model_name,
2731 fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2733 sprintf(fore200e->name, "%s-%d", bus->model_name, index);
2735 err = fore200e_init(fore200e, &pci_dev->dev);
2737 fore200e_shutdown(fore200e);
2742 pci_set_drvdata(pci_dev, fore200e);
2750 pci_disable_device(pci_dev);
2755 static void fore200e_pca_remove_one(struct pci_dev *pci_dev)
2757 struct fore200e *fore200e;
2759 fore200e = pci_get_drvdata(pci_dev);
2761 fore200e_shutdown(fore200e);
2763 pci_disable_device(pci_dev);
2767 static const struct pci_device_id fore200e_pca_tbl[] = {
2768 { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_PCA200E, PCI_ANY_ID, PCI_ANY_ID,
2769 0, 0, (unsigned long) &fore200e_bus[0] },
2773 MODULE_DEVICE_TABLE(pci, fore200e_pca_tbl);
2775 static struct pci_driver fore200e_pca_driver = {
2776 .name = "fore_200e",
2777 .probe = fore200e_pca_detect,
2778 .remove = fore200e_pca_remove_one,
2779 .id_table = fore200e_pca_tbl,
2783 static int __init fore200e_module_init(void)
2787 printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
2790 err = platform_driver_register(&fore200e_sba_driver);
2796 err = pci_register_driver(&fore200e_pca_driver);
2801 platform_driver_unregister(&fore200e_sba_driver);
2807 static void __exit fore200e_module_cleanup(void)
2810 pci_unregister_driver(&fore200e_pca_driver);
2813 platform_driver_unregister(&fore200e_sba_driver);
2818 fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
2820 struct fore200e* fore200e = FORE200E_DEV(dev);
2821 struct fore200e_vcc* fore200e_vcc;
2822 struct atm_vcc* vcc;
2823 int i, len, left = *pos;
2824 unsigned long flags;
2828 if (fore200e_getstats(fore200e) < 0)
2831 len = sprintf(page,"\n"
2833 " internal name:\t\t%s\n", fore200e->name);
2835 /* print bus-specific information */
2836 if (fore200e->bus->proc_read)
2837 len += fore200e->bus->proc_read(fore200e, page + len);
2839 len += sprintf(page + len,
2840 " interrupt line:\t\t%s\n"
2841 " physical base address:\t0x%p\n"
2842 " virtual base address:\t0x%p\n"
2843 " factory address (ESI):\t%pM\n"
2844 " board serial number:\t\t%d\n\n",
2845 fore200e_irq_itoa(fore200e->irq),
2846 (void*)fore200e->phys_base,
2847 fore200e->virt_base,
2849 fore200e->esi[4] * 256 + fore200e->esi[5]);
2855 return sprintf(page,
2856 " free small bufs, scheme 1:\t%d\n"
2857 " free large bufs, scheme 1:\t%d\n"
2858 " free small bufs, scheme 2:\t%d\n"
2859 " free large bufs, scheme 2:\t%d\n",
2860 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2861 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2862 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2863 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2866 u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2868 len = sprintf(page,"\n\n"
2869 " cell processor:\n"
2870 " heartbeat state:\t\t");
2872 if (hb >> 16 != 0xDEAD)
2873 len += sprintf(page + len, "0x%08x\n", hb);
2875 len += sprintf(page + len, "*** FATAL ERROR %04x ***\n", hb & 0xFFFF);
2881 static const char* media_name[] = {
2882 "unshielded twisted pair",
2883 "multimode optical fiber ST",
2884 "multimode optical fiber SC",
2885 "single-mode optical fiber ST",
2886 "single-mode optical fiber SC",
2890 static const char* oc3_mode[] = {
2892 "diagnostic loopback",
2897 u32 fw_release = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2898 u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2899 u32 oc3_revision = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2900 u32 media_index = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2903 if (media_index > 4)
2906 switch (fore200e->loop_mode) {
2907 case ATM_LM_NONE: oc3_index = 0;
2909 case ATM_LM_LOC_PHY: oc3_index = 1;
2911 case ATM_LM_RMT_PHY: oc3_index = 2;
2913 default: oc3_index = 3;
2916 return sprintf(page,
2917 " firmware release:\t\t%d.%d.%d\n"
2918 " monitor release:\t\t%d.%d\n"
2919 " media type:\t\t\t%s\n"
2920 " OC-3 revision:\t\t0x%x\n"
2921 " OC-3 mode:\t\t\t%s",
2922 fw_release >> 16, fw_release << 16 >> 24, fw_release << 24 >> 24,
2923 mon960_release >> 16, mon960_release << 16 >> 16,
2924 media_name[ media_index ],
2926 oc3_mode[ oc3_index ]);
2930 struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2932 return sprintf(page,
2935 " version number:\t\t%d\n"
2936 " boot status word:\t\t0x%08x\n",
2937 fore200e->bus->read(&cp_monitor->mon_version),
2938 fore200e->bus->read(&cp_monitor->bstat));
2942 return sprintf(page,
2944 " device statistics:\n"
2946 " crc_header_errors:\t\t%10u\n"
2947 " framing_errors:\t\t%10u\n",
2948 be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2949 be32_to_cpu(fore200e->stats->phy.framing_errors));
2952 return sprintf(page, "\n"
2954 " section_bip8_errors:\t%10u\n"
2955 " path_bip8_errors:\t\t%10u\n"
2956 " line_bip24_errors:\t\t%10u\n"
2957 " line_febe_errors:\t\t%10u\n"
2958 " path_febe_errors:\t\t%10u\n"
2959 " corr_hcs_errors:\t\t%10u\n"
2960 " ucorr_hcs_errors:\t\t%10u\n",
2961 be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2962 be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2963 be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2964 be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2965 be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2966 be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2967 be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
2970 return sprintf(page,"\n"
2971 " ATM:\t\t\t\t cells\n"
2974 " vpi out of range:\t\t%10u\n"
2975 " vpi no conn:\t\t%10u\n"
2976 " vci out of range:\t\t%10u\n"
2977 " vci no conn:\t\t%10u\n",
2978 be32_to_cpu(fore200e->stats->atm.cells_transmitted),
2979 be32_to_cpu(fore200e->stats->atm.cells_received),
2980 be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
2981 be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
2982 be32_to_cpu(fore200e->stats->atm.vci_bad_range),
2983 be32_to_cpu(fore200e->stats->atm.vci_no_conn));
2986 return sprintf(page,"\n"
2987 " AAL0:\t\t\t cells\n"
2990 " dropped:\t\t\t%10u\n",
2991 be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
2992 be32_to_cpu(fore200e->stats->aal0.cells_received),
2993 be32_to_cpu(fore200e->stats->aal0.cells_dropped));
2996 return sprintf(page,"\n"
2998 " SAR sublayer:\t\t cells\n"
3001 " dropped:\t\t\t%10u\n"
3002 " CRC errors:\t\t%10u\n"
3003 " protocol errors:\t\t%10u\n\n"
3004 " CS sublayer:\t\t PDUs\n"
3007 " dropped:\t\t\t%10u\n"
3008 " protocol errors:\t\t%10u\n",
3009 be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
3010 be32_to_cpu(fore200e->stats->aal34.cells_received),
3011 be32_to_cpu(fore200e->stats->aal34.cells_dropped),
3012 be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
3013 be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
3014 be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
3015 be32_to_cpu(fore200e->stats->aal34.cspdus_received),
3016 be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
3017 be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
3020 return sprintf(page,"\n"
3022 " SAR sublayer:\t\t cells\n"
3025 " dropped:\t\t\t%10u\n"
3026 " congestions:\t\t%10u\n\n"
3027 " CS sublayer:\t\t PDUs\n"
3030 " dropped:\t\t\t%10u\n"
3031 " CRC errors:\t\t%10u\n"
3032 " protocol errors:\t\t%10u\n",
3033 be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
3034 be32_to_cpu(fore200e->stats->aal5.cells_received),
3035 be32_to_cpu(fore200e->stats->aal5.cells_dropped),
3036 be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
3037 be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
3038 be32_to_cpu(fore200e->stats->aal5.cspdus_received),
3039 be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
3040 be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
3041 be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
3044 return sprintf(page,"\n"
3045 " AUX:\t\t allocation failures\n"
3046 " small b1:\t\t\t%10u\n"
3047 " large b1:\t\t\t%10u\n"
3048 " small b2:\t\t\t%10u\n"
3049 " large b2:\t\t\t%10u\n"
3050 " RX PDUs:\t\t\t%10u\n"
3051 " TX PDUs:\t\t\t%10lu\n",
3052 be32_to_cpu(fore200e->stats->aux.small_b1_failed),
3053 be32_to_cpu(fore200e->stats->aux.large_b1_failed),
3054 be32_to_cpu(fore200e->stats->aux.small_b2_failed),
3055 be32_to_cpu(fore200e->stats->aux.large_b2_failed),
3056 be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
3060 return sprintf(page,"\n"
3061 " receive carrier:\t\t\t%s\n",
3062 fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
3065 return sprintf(page,"\n"
3066 " VCCs:\n address VPI VCI AAL "
3067 "TX PDUs TX min/max size RX PDUs RX min/max size\n");
3070 for (i = 0; i < NBR_CONNECT; i++) {
3072 vcc = fore200e->vc_map[i].vcc;
3077 spin_lock_irqsave(&fore200e->q_lock, flags);
3079 if (vcc && test_bit(ATM_VF_READY, &vcc->flags) && !left--) {
3081 fore200e_vcc = FORE200E_VCC(vcc);
3082 ASSERT(fore200e_vcc);
3085 " %08x %03d %05d %1d %09lu %05d/%05d %09lu %05d/%05d\n",
3086 (u32)(unsigned long)vcc,
3087 vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
3088 fore200e_vcc->tx_pdu,
3089 fore200e_vcc->tx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->tx_min_pdu,
3090 fore200e_vcc->tx_max_pdu,
3091 fore200e_vcc->rx_pdu,
3092 fore200e_vcc->rx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->rx_min_pdu,
3093 fore200e_vcc->rx_max_pdu);
3095 spin_unlock_irqrestore(&fore200e->q_lock, flags);
3099 spin_unlock_irqrestore(&fore200e->q_lock, flags);
3105 module_init(fore200e_module_init);
3106 module_exit(fore200e_module_cleanup);
3109 static const struct atmdev_ops fore200e_ops =
3111 .open = fore200e_open,
3112 .close = fore200e_close,
3113 .ioctl = fore200e_ioctl,
3114 .getsockopt = fore200e_getsockopt,
3115 .setsockopt = fore200e_setsockopt,
3116 .send = fore200e_send,
3117 .change_qos = fore200e_change_qos,
3118 .proc_read = fore200e_proc_read,
3119 .owner = THIS_MODULE
3123 static const struct fore200e_bus fore200e_bus[] = {
3125 { "PCA-200E", "pca200e", 32, 4, 32,
3128 fore200e_pca_dma_map,
3129 fore200e_pca_dma_unmap,
3130 fore200e_pca_dma_sync_for_cpu,
3131 fore200e_pca_dma_sync_for_device,
3132 fore200e_pca_dma_chunk_alloc,
3133 fore200e_pca_dma_chunk_free,
3134 fore200e_pca_configure,
3137 fore200e_pca_prom_read,
3140 fore200e_pca_irq_check,
3141 fore200e_pca_irq_ack,
3142 fore200e_pca_proc_read,
3146 { "SBA-200E", "sba200e", 32, 64, 32,
3149 fore200e_sba_dma_map,
3150 fore200e_sba_dma_unmap,
3151 fore200e_sba_dma_sync_for_cpu,
3152 fore200e_sba_dma_sync_for_device,
3153 fore200e_sba_dma_chunk_alloc,
3154 fore200e_sba_dma_chunk_free,
3155 fore200e_sba_configure,
3158 fore200e_sba_prom_read,
3160 fore200e_sba_irq_enable,
3161 fore200e_sba_irq_check,
3162 fore200e_sba_irq_ack,
3163 fore200e_sba_proc_read,
3169 MODULE_LICENSE("GPL");
3171 #ifdef __LITTLE_ENDIAN__
3176 #endif /* CONFIG_PCI */