Lines Matching defs:fore200e
57 #include "fore200e.h"
62 #define FORE200E "fore200e: "
162 fore200e_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, int size, int alignment, int direction)
181 chunk->dma_addr = dma_map_single(fore200e->dev, chunk->align_addr,
183 if (dma_mapping_error(fore200e->dev, chunk->dma_addr)) {
194 fore200e_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
196 dma_unmap_single(fore200e->dev, chunk->dma_addr, chunk->dma_size,
207 fore200e_dma_chunk_alloc(struct fore200e *fore200e, struct chunk *chunk,
212 chunk->alloc_addr = dma_alloc_coherent(fore200e->dev, chunk->alloc_size,
224 fore200e_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
226 dma_free_coherent(fore200e->dev, chunk->alloc_size, chunk->alloc_addr,
239 fore200e_poll(struct fore200e* fore200e, volatile u32* addr, u32 val, int msecs)
263 fore200e_io_poll(struct fore200e* fore200e, volatile u32 __iomem *addr, u32 val, int msecs)
269 if ((ok = (fore200e->bus->read(addr) == val)))
277 fore200e->bus->read(addr), val);
286 fore200e_free_rx_buf(struct fore200e* fore200e)
294 if ((buffer = fore200e->host_bsq[ scheme ][ magn ].buffer) != NULL) {
301 fore200e_chunk_free(fore200e, data);
310 fore200e_uninit_bs_queue(struct fore200e* fore200e)
317 struct chunk* status = &fore200e->host_bsq[ scheme ][ magn ].status;
318 struct chunk* rbd_block = &fore200e->host_bsq[ scheme ][ magn ].rbd_block;
321 fore200e_dma_chunk_free(fore200e, status);
324 fore200e_dma_chunk_free(fore200e, rbd_block);
331 fore200e_reset(struct fore200e* fore200e, int diag)
335 fore200e->cp_monitor = fore200e->virt_base + FORE200E_CP_MONITOR_OFFSET;
337 fore200e->bus->write(BSTAT_COLD_START, &fore200e->cp_monitor->bstat);
339 fore200e->bus->reset(fore200e);
342 ok = fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_SELFTEST_OK, 1000);
345 printk(FORE200E "device %s self-test failed\n", fore200e->name);
349 printk(FORE200E "device %s self-test passed\n", fore200e->name);
351 fore200e->state = FORE200E_STATE_RESET;
359 fore200e_shutdown(struct fore200e* fore200e)
362 fore200e->name, fore200e->phys_base,
363 fore200e_irq_itoa(fore200e->irq));
365 if (fore200e->state > FORE200E_STATE_RESET) {
367 fore200e_reset(fore200e, 0);
371 switch(fore200e->state) {
374 kfree(fore200e->stats);
378 free_irq(fore200e->irq, fore200e->atm_dev);
382 fore200e_free_rx_buf(fore200e);
386 fore200e_uninit_bs_queue(fore200e);
390 fore200e_dma_chunk_free(fore200e, &fore200e->host_rxq.status);
391 fore200e_dma_chunk_free(fore200e, &fore200e->host_rxq.rpd);
395 fore200e_dma_chunk_free(fore200e, &fore200e->host_txq.status);
396 fore200e_dma_chunk_free(fore200e, &fore200e->host_txq.tpd);
400 fore200e_dma_chunk_free(fore200e, &fore200e->host_cmdq.status);
413 fore200e->bus->unmap(fore200e);
421 atm_dev_deregister(fore200e->atm_dev);
449 fore200e_pca_irq_check(struct fore200e* fore200e)
452 int irq_posted = readl(fore200e->regs.pca.psr);
455 if (irq_posted && (readl(fore200e->regs.pca.hcr) & PCA200E_HCR_OUTFULL)) {
456 DPRINTK(2,"FIFO OUT full, device %d\n", fore200e->atm_dev->number);
465 fore200e_pca_irq_ack(struct fore200e* fore200e)
467 writel(PCA200E_HCR_CLRINTR, fore200e->regs.pca.hcr);
472 fore200e_pca_reset(struct fore200e* fore200e)
474 writel(PCA200E_HCR_RESET, fore200e->regs.pca.hcr);
476 writel(0, fore200e->regs.pca.hcr);
480 static int fore200e_pca_map(struct fore200e* fore200e)
482 DPRINTK(2, "device %s being mapped in memory\n", fore200e->name);
484 fore200e->virt_base = ioremap(fore200e->phys_base, PCA200E_IOSPACE_LENGTH);
486 if (fore200e->virt_base == NULL) {
487 printk(FORE200E "can't map device %s\n", fore200e->name);
491 DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
494 fore200e->regs.pca.hcr = fore200e->virt_base + PCA200E_HCR_OFFSET;
495 fore200e->regs.pca.imr = fore200e->virt_base + PCA200E_IMR_OFFSET;
496 fore200e->regs.pca.psr = fore200e->virt_base + PCA200E_PSR_OFFSET;
498 fore200e->state = FORE200E_STATE_MAP;
504 fore200e_pca_unmap(struct fore200e* fore200e)
506 DPRINTK(2, "device %s being unmapped from memory\n", fore200e->name);
508 if (fore200e->virt_base != NULL)
509 iounmap(fore200e->virt_base);
513 static int fore200e_pca_configure(struct fore200e *fore200e)
515 struct pci_dev *pci_dev = to_pci_dev(fore200e->dev);
518 DPRINTK(2, "device %s being configured\n", fore200e->name);
548 fore200e->state = FORE200E_STATE_CONFIGURE;
554 fore200e_pca_prom_read(struct fore200e* fore200e, struct prom_data* prom)
556 struct host_cmdq* cmdq = &fore200e->host_cmdq;
567 prom_dma = dma_map_single(fore200e->dev, prom, sizeof(struct prom_data),
569 if (dma_mapping_error(fore200e->dev, prom_dma))
572 fore200e->bus->write(prom_dma, &entry->cp_entry->cmd.prom_block.prom_haddr);
576 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.prom_block.opcode);
578 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
582 dma_unmap_single(fore200e->dev, prom_dma, sizeof(struct prom_data), DMA_FROM_DEVICE);
585 printk(FORE200E "unable to get PROM data from device %s\n", fore200e->name);
603 fore200e_pca_proc_read(struct fore200e* fore200e, char *page)
605 struct pci_dev *pci_dev = to_pci_dev(fore200e->dev);
642 static void fore200e_sba_irq_enable(struct fore200e *fore200e)
644 u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
645 fore200e->bus->write(hcr | SBA200E_HCR_INTR_ENA, fore200e->regs.sba.hcr);
648 static int fore200e_sba_irq_check(struct fore200e *fore200e)
650 return fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_INTR_REQ;
653 static void fore200e_sba_irq_ack(struct fore200e *fore200e)
655 u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
656 fore200e->bus->write(hcr | SBA200E_HCR_INTR_CLR, fore200e->regs.sba.hcr);
659 static void fore200e_sba_reset(struct fore200e *fore200e)
661 fore200e->bus->write(SBA200E_HCR_RESET, fore200e->regs.sba.hcr);
663 fore200e->bus->write(0, fore200e->regs.sba.hcr);
666 static int __init fore200e_sba_map(struct fore200e *fore200e)
668 struct platform_device *op = to_platform_device(fore200e->dev);
672 fore200e->regs.sba.hcr = of_ioremap(&op->resource[0], 0, SBA200E_HCR_LENGTH, "SBA HCR");
673 fore200e->regs.sba.bsr = of_ioremap(&op->resource[1], 0, SBA200E_BSR_LENGTH, "SBA BSR");
674 fore200e->regs.sba.isr = of_ioremap(&op->resource[2], 0, SBA200E_ISR_LENGTH, "SBA ISR");
675 fore200e->virt_base = of_ioremap(&op->resource[3], 0, SBA200E_RAM_LENGTH, "SBA RAM");
677 if (!fore200e->virt_base) {
678 printk(FORE200E "unable to map RAM of device %s\n", fore200e->name);
682 DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
684 fore200e->bus->write(0x02, fore200e->regs.sba.isr); /* XXX hardwired interrupt level */
692 fore200e->state = FORE200E_STATE_MAP;
696 static void fore200e_sba_unmap(struct fore200e *fore200e)
698 struct platform_device *op = to_platform_device(fore200e->dev);
700 of_iounmap(&op->resource[0], fore200e->regs.sba.hcr, SBA200E_HCR_LENGTH);
701 of_iounmap(&op->resource[1], fore200e->regs.sba.bsr, SBA200E_BSR_LENGTH);
702 of_iounmap(&op->resource[2], fore200e->regs.sba.isr, SBA200E_ISR_LENGTH);
703 of_iounmap(&op->resource[3], fore200e->virt_base, SBA200E_RAM_LENGTH);
706 static int __init fore200e_sba_configure(struct fore200e *fore200e)
708 fore200e->state = FORE200E_STATE_CONFIGURE;
712 static int __init fore200e_sba_prom_read(struct fore200e *fore200e, struct prom_data *prom)
714 struct platform_device *op = to_platform_device(fore200e->dev);
736 static int fore200e_sba_proc_read(struct fore200e *fore200e, char *page)
738 struct platform_device *op = to_platform_device(fore200e->dev);
768 fore200e_tx_irq(struct fore200e* fore200e)
770 struct host_txq* txq = &fore200e->host_txq;
775 if (fore200e->host_txq.txing == 0)
793 dma_unmap_single(fore200e->dev, entry->tpd->tsd[ 0 ].buffer, entry->tpd->tsd[ 0 ].length,
803 fore200e->atm_dev->number);
826 fore200e->atm_dev->number);
852 fore200e->host_txq.txing--;
902 fore200e_supply(struct fore200e* fore200e)
913 bsq = &fore200e->host_bsq[ scheme ][ magn ];
952 fore200e->bus->write(entry->rbd_block_dma, &entry->cp_entry->rbd_block_haddr);
960 fore200e_push_rpd(struct fore200e* fore200e, struct atm_vcc* vcc, struct rpd* rpd)
1014 dma_sync_single_for_cpu(fore200e->dev, buffer->data.dma_addr,
1020 dma_sync_single_for_device(fore200e->dev, buffer->data.dma_addr,
1052 fore200e_collect_rpd(struct fore200e* fore200e, struct rpd* rpd)
1063 bsq = &fore200e->host_bsq[ buffer->scheme ][ buffer->magn ];
1085 fore200e_rx_irq(struct fore200e* fore200e)
1087 struct host_rxq* rxq = &fore200e->host_rxq;
1100 vc_map = FORE200E_VC_MAP(fore200e, entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1106 fore200e->atm_dev->number,
1115 fore200e_push_rpd(fore200e, vcc, entry->rpd);
1119 fore200e->atm_dev->number,
1127 fore200e_collect_rpd(fore200e, entry->rpd);
1130 fore200e->bus->write(entry->rpd_dma, &entry->cp_entry->rpd_haddr);
1133 fore200e_supply(fore200e);
1140 fore200e_irq(struct fore200e* fore200e)
1144 spin_lock_irqsave(&fore200e->q_lock, flags);
1145 fore200e_rx_irq(fore200e);
1146 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1148 spin_lock_irqsave(&fore200e->q_lock, flags);
1149 fore200e_tx_irq(fore200e);
1150 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1158 struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev);
1160 if (fore200e->bus->irq_check(fore200e) == 0) {
1162 DPRINTK(3, "interrupt NOT triggered by device %d\n", fore200e->atm_dev->number);
1165 DPRINTK(3, "interrupt triggered by device %d\n", fore200e->atm_dev->number);
1168 tasklet_schedule(&fore200e->tx_tasklet);
1169 tasklet_schedule(&fore200e->rx_tasklet);
1171 fore200e_irq(fore200e);
1174 fore200e->bus->irq_ack(fore200e);
1183 struct fore200e* fore200e = (struct fore200e*) data;
1186 DPRINTK(3, "tx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1188 spin_lock_irqsave(&fore200e->q_lock, flags);
1189 fore200e_tx_irq(fore200e);
1190 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1197 struct fore200e* fore200e = (struct fore200e*) data;
1200 DPRINTK(3, "rx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1202 spin_lock_irqsave(&fore200e->q_lock, flags);
1203 fore200e_rx_irq((struct fore200e*) data);
1204 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1223 fore200e_activate_vcin(struct fore200e* fore200e, int activate, struct atm_vcc* vcc, int mtu)
1225 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1259 fore200e->bus->write(mtu, &entry->cp_entry->cmd.activate_block.mtu);
1260 fore200e->bus->write(*(u32*)&vpvc, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.vpvc);
1261 fore200e->bus->write(*(u32*)&activ_opcode, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.opcode);
1264 fore200e->bus->write(*(u32*)&vpvc, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.vpvc);
1265 fore200e->bus->write(*(u32*)&deactiv_opcode, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.opcode);
1268 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1306 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1316 spin_lock_irqsave(&fore200e->q_lock, flags);
1318 vc_map = FORE200E_VC_MAP(fore200e, vpi, vci);
1321 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1324 fore200e->atm_dev->number, vpi, vci);
1331 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1350 mutex_lock(&fore200e->rate_mtx);
1351 if (fore200e->available_cell_rate < vcc->qos.txtp.max_pcr) {
1352 mutex_unlock(&fore200e->rate_mtx);
1360 fore200e->available_cell_rate -= vcc->qos.txtp.max_pcr;
1361 mutex_unlock(&fore200e->rate_mtx);
1371 if (fore200e_activate_vcin(fore200e, 1, vcc, vcc->qos.rxtp.max_sdu) < 0) {
1380 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1403 vc_map->incarn = ++fore200e->incarn_count;
1416 struct fore200e* fore200e;
1421 fore200e = FORE200E_DEV(vcc->dev);
1430 fore200e_activate_vcin(fore200e, 0, vcc, 0);
1432 spin_lock_irqsave(&fore200e->q_lock, flags);
1434 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1444 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1449 mutex_lock(&fore200e->rate_mtx);
1450 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1451 mutex_unlock(&fore200e->rate_mtx);
1467 struct fore200e* fore200e;
1486 fore200e = FORE200E_DEV(vcc->dev);
1489 if (!fore200e)
1492 txq = &fore200e->host_txq;
1519 DPRINTK(2, "misaligned tx PDU on device %s\n", fore200e->name);
1527 DPRINTK(2, "incomplete tx AAL0 PDU on device %s\n", fore200e->name);
1552 vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1557 spin_lock_irqsave(&fore200e->q_lock, flags);
1564 fore200e_tx_irq(fore200e);
1568 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1578 fore200e->tx_sat++;
1580 fore200e->name, fore200e->cp_queues->heartbeat);
1601 tpd->tsd[ 0 ].buffer = dma_map_single(fore200e->dev, data, tx_len,
1603 if (dma_mapping_error(fore200e->dev, tpd->tsd[0].buffer)) {
1606 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1658 fore200e->bus->write(*(u32*)&tpd_haddr, (u32 __iomem *)&entry->cp_entry->tpd_haddr);
1660 spin_unlock_irqrestore(&fore200e->q_lock, flags);
1667 fore200e_getstats(struct fore200e* fore200e)
1669 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1675 if (fore200e->stats == NULL) {
1676 fore200e->stats = kzalloc(sizeof(struct stats), GFP_KERNEL);
1677 if (fore200e->stats == NULL)
1681 stats_dma_addr = dma_map_single(fore200e->dev, fore200e->stats,
1683 if (dma_mapping_error(fore200e->dev, stats_dma_addr))
1691 fore200e->bus->write(stats_dma_addr, &entry->cp_entry->cmd.stats_block.stats_haddr);
1695 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.stats_block.opcode);
1697 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1701 dma_unmap_single(fore200e->dev, stats_dma_addr, sizeof(struct stats), DMA_FROM_DEVICE);
1704 printk(FORE200E "unable to get statistics from device %s\n", fore200e->name);
1713 fore200e_get_oc3(struct fore200e* fore200e, struct oc3_regs* regs)
1715 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1721 oc3_regs_dma_addr = fore200e->bus->dma_map(fore200e, regs, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1730 fore200e->bus->write(oc3_regs_dma_addr, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1734 fore200e->bus->write(*(u32*)&opcode, (u32*)&entry->cp_entry->cmd.oc3_block.opcode);
1736 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1740 fore200e->bus->dma_unmap(fore200e, oc3_regs_dma_addr, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1743 printk(FORE200E "unable to get OC-3 regs of device %s\n", fore200e->name);
1753 fore200e_set_oc3(struct fore200e* fore200e, u32 reg, u32 value, u32 mask)
1755 struct host_cmdq* cmdq = &fore200e->host_cmdq;
1769 fore200e->bus->write(0, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1773 fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.oc3_block.opcode);
1775 ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1780 printk(FORE200E "unable to set OC-3 reg 0x%02x of device %s\n", reg, fore200e->name);
1789 fore200e_setloop(struct fore200e* fore200e, int loop_mode)
1816 error = fore200e_set_oc3(fore200e, SUNI_MCT, mct_value, mct_mask);
1818 fore200e->loop_mode = loop_mode;
1825 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
1829 if (fore200e_getstats(fore200e) < 0)
1832 tmp.section_bip = be32_to_cpu(fore200e->stats->oc3.section_bip8_errors);
1833 tmp.line_bip = be32_to_cpu(fore200e->stats->oc3.line_bip24_errors);
1834 tmp.path_bip = be32_to_cpu(fore200e->stats->oc3.path_bip8_errors);
1835 tmp.line_febe = be32_to_cpu(fore200e->stats->oc3.line_febe_errors);
1836 tmp.path_febe = be32_to_cpu(fore200e->stats->oc3.path_febe_errors);
1837 tmp.corr_hcs = be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors);
1838 tmp.uncorr_hcs = be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors);
1839 tmp.tx_cells = be32_to_cpu(fore200e->stats->aal0.cells_transmitted) +
1840 be32_to_cpu(fore200e->stats->aal34.cells_transmitted) +
1841 be32_to_cpu(fore200e->stats->aal5.cells_transmitted);
1842 tmp.rx_cells = be32_to_cpu(fore200e->stats->aal0.cells_received) +
1843 be32_to_cpu(fore200e->stats->aal34.cells_received) +
1844 be32_to_cpu(fore200e->stats->aal5.cells_received);
1856 struct fore200e* fore200e = FORE200E_DEV(dev);
1863 return fore200e_fetch_stats(fore200e, (struct sonet_stats __user *)arg);
1869 return fore200e_setloop(fore200e, (int)(unsigned long)arg);
1872 return put_user(fore200e->loop_mode, (int __user *)arg) ? -EFAULT : 0;
1886 struct fore200e* fore200e = FORE200E_DEV(vcc->dev);
1902 flags, fore200e->available_cell_rate);
1906 mutex_lock(&fore200e->rate_mtx);
1907 if (fore200e->available_cell_rate + vcc->qos.txtp.max_pcr < qos->txtp.max_pcr) {
1908 mutex_unlock(&fore200e->rate_mtx);
1912 fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1913 fore200e->available_cell_rate -= qos->txtp.max_pcr;
1915 mutex_unlock(&fore200e->rate_mtx);
1931 static int fore200e_irq_request(struct fore200e *fore200e)
1933 if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
1936 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1941 fore200e_irq_itoa(fore200e->irq), fore200e->name);
1944 tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
1945 tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
1948 fore200e->state = FORE200E_STATE_IRQ;
1953 static int fore200e_get_esi(struct fore200e *fore200e)
1961 ok = fore200e->bus->prom_read(fore200e, prom);
1968 fore200e->name,
1973 fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
1982 static int fore200e_alloc_rx_buf(struct fore200e *fore200e)
1992 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2018 if (fore200e_chunk_alloc(fore200e,
2019 &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2023 fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2042 fore200e->state = FORE200E_STATE_ALLOC_BUF;
2047 static int fore200e_init_bs_queue(struct fore200e *fore200e)
2059 bsq = &fore200e->host_bsq[ scheme ][ magn ];
2062 if (fore200e_dma_chunk_alloc(fore200e,
2066 fore200e->bus->status_alignment) < 0) {
2071 if (fore200e_dma_chunk_alloc(fore200e,
2075 fore200e->bus->descr_alignment) < 0) {
2077 fore200e_dma_chunk_free(fore200e, &bsq->status);
2082 cp_entry = fore200e->virt_base +
2083 fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2098 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i),
2104 fore200e->state = FORE200E_STATE_INIT_BSQ;
2109 static int fore200e_init_rx_queue(struct fore200e *fore200e)
2111 struct host_rxq* rxq = &fore200e->host_rxq;
2118 if (fore200e_dma_chunk_alloc(fore200e,
2122 fore200e->bus->status_alignment) < 0) {
2127 if (fore200e_dma_chunk_alloc(fore200e,
2131 fore200e->bus->descr_alignment) < 0) {
2133 fore200e_dma_chunk_free(fore200e, &rxq->status);
2138 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2153 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i),
2156 fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2163 fore200e->state = FORE200E_STATE_INIT_RXQ;
2168 static int fore200e_init_tx_queue(struct fore200e *fore200e)
2170 struct host_txq* txq = &fore200e->host_txq;
2177 if (fore200e_dma_chunk_alloc(fore200e,
2181 fore200e->bus->status_alignment) < 0) {
2186 if (fore200e_dma_chunk_alloc(fore200e,
2190 fore200e->bus->descr_alignment) < 0) {
2192 fore200e_dma_chunk_free(fore200e, &txq->status);
2197 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2212 fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i),
2225 fore200e->state = FORE200E_STATE_INIT_TXQ;
2230 static int fore200e_init_cmd_queue(struct fore200e *fore200e)
2232 struct host_cmdq* cmdq = &fore200e->host_cmdq;
2239 if (fore200e_dma_chunk_alloc(fore200e,
2243 fore200e->bus->status_alignment) < 0) {
2248 cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2259 fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),
2266 fore200e->state = FORE200E_STATE_INIT_CMDQ;
2271 static void fore200e_param_bs_queue(struct fore200e *fore200e,
2276 struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2278 fore200e->bus->write(queue_length, &bs_spec->queue_length);
2279 fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2280 fore200e->bus->write(pool_size, &bs_spec->pool_size);
2281 fore200e->bus->write(supply_blksize, &bs_spec->supply_blksize);
2285 static int fore200e_initialize(struct fore200e *fore200e)
2290 DPRINTK(2, "device %s being initialized\n", fore200e->name);
2292 mutex_init(&fore200e->rate_mtx);
2293 spin_lock_init(&fore200e->q_lock);
2295 cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2298 fore200e->bus->write(1, &cpq->imask);
2300 if (fore200e->bus->irq_enable)
2301 fore200e->bus->irq_enable(fore200e);
2303 fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2305 fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2306 fore200e->bus->write(QUEUE_SIZE_RX, &cpq->init.rx_queue_len);
2307 fore200e->bus->write(QUEUE_SIZE_TX, &cpq->init.tx_queue_len);
2309 fore200e->bus->write(RSD_EXTENSION, &cpq->init.rsd_extension);
2310 fore200e->bus->write(TSD_EXTENSION, &cpq->init.tsd_extension);
2314 fore200e_param_bs_queue(fore200e, scheme, magn,
2320 fore200e->bus->write(STATUS_PENDING, &cpq->init.status);
2321 fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2323 ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2325 printk(FORE200E "device %s initialization failed\n", fore200e->name);
2329 printk(FORE200E "device %s initialized\n", fore200e->name);
2331 fore200e->state = FORE200E_STATE_INITIALIZE;
2336 static void fore200e_monitor_putc(struct fore200e *fore200e, char c)
2338 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2343 fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2347 static int fore200e_monitor_getc(struct fore200e *fore200e)
2349 struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2355 c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2359 fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2371 static void fore200e_monitor_puts(struct fore200e *fore200e, char *str)
2376 while (fore200e_monitor_getc(fore200e) >= 0);
2378 fore200e_monitor_putc(fore200e, *str++);
2381 while (fore200e_monitor_getc(fore200e) >= 0);
2390 static int fore200e_load_and_start_fw(struct fore200e *fore200e)
2400 sprintf(buf, "%s%s", fore200e->bus->proc_name, FW_EXT);
2401 if ((err = request_firmware(&firmware, buf, fore200e->dev)) < 0) {
2402 printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
2409 load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2412 fore200e->name, load_addr, fw_size);
2415 printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2420 fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2422 DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2430 fore200e_monitor_puts(fore200e, buf);
2432 if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2433 printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2437 printk(FORE200E "device %s firmware started\n", fore200e->name);
2439 fore200e->state = FORE200E_STATE_START_FW;
2448 static int fore200e_register(struct fore200e *fore200e, struct device *parent)
2452 DPRINTK(2, "device %s being registered\n", fore200e->name);
2454 atm_dev = atm_dev_register(fore200e->bus->proc_name, parent, &fore200e_ops,
2457 printk(FORE200E "unable to register device %s\n", fore200e->name);
2461 atm_dev->dev_data = fore200e;
2462 fore200e->atm_dev = atm_dev;
2467 fore200e->available_cell_rate = ATM_OC3_PCR;
2469 fore200e->state = FORE200E_STATE_REGISTER;
2474 static int fore200e_init(struct fore200e *fore200e, struct device *parent)
2476 if (fore200e_register(fore200e, parent) < 0)
2479 if (fore200e->bus->configure(fore200e) < 0)
2482 if (fore200e->bus->map(fore200e) < 0)
2485 if (fore200e_reset(fore200e, 1) < 0)
2488 if (fore200e_load_and_start_fw(fore200e) < 0)
2491 if (fore200e_initialize(fore200e) < 0)
2494 if (fore200e_init_cmd_queue(fore200e) < 0)
2497 if (fore200e_init_tx_queue(fore200e) < 0)
2500 if (fore200e_init_rx_queue(fore200e) < 0)
2503 if (fore200e_init_bs_queue(fore200e) < 0)
2506 if (fore200e_alloc_rx_buf(fore200e) < 0)
2509 if (fore200e_get_esi(fore200e) < 0)
2512 if (fore200e_irq_request(fore200e) < 0)
2515 fore200e_supply(fore200e);
2518 fore200e->state = FORE200E_STATE_COMPLETE;
2527 struct fore200e *fore200e;
2535 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2536 if (!fore200e)
2539 fore200e->bus = &fore200e_sbus_ops;
2540 fore200e->dev = &op->dev;
2541 fore200e->irq = op->archdata.irqs[0];
2542 fore200e->phys_base = op->resource[0].start;
2544 sprintf(fore200e->name, "SBA-200E-%d", index);
2546 err = fore200e_init(fore200e, &op->dev);
2548 fore200e_shutdown(fore200e);
2549 kfree(fore200e);
2554 dev_set_drvdata(&op->dev, fore200e);
2561 struct fore200e *fore200e = dev_get_drvdata(&op->dev);
2563 fore200e_shutdown(fore200e);
2564 kfree(fore200e);
2591 struct fore200e* fore200e;
2605 fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2606 if (fore200e == NULL) {
2611 fore200e->bus = &fore200e_pci_ops;
2612 fore200e->dev = &pci_dev->dev;
2613 fore200e->irq = pci_dev->irq;
2614 fore200e->phys_base = pci_resource_start(pci_dev, 0);
2616 sprintf(fore200e->name, "PCA-200E-%d", index - 1);
2621 fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2623 sprintf(fore200e->name, "PCA-200E-%d", index);
2625 err = fore200e_init(fore200e, &pci_dev->dev);
2627 fore200e_shutdown(fore200e);
2632 pci_set_drvdata(pci_dev, fore200e);
2638 kfree(fore200e);
2647 struct fore200e *fore200e;
2649 fore200e = pci_get_drvdata(pci_dev);
2651 fore200e_shutdown(fore200e);
2652 kfree(fore200e);
2709 struct fore200e* fore200e = FORE200E_DEV(dev);
2717 if (fore200e_getstats(fore200e) < 0)
2722 " internal name:\t\t%s\n", fore200e->name);
2725 if (fore200e->bus->proc_read)
2726 len += fore200e->bus->proc_read(fore200e, page + len);
2734 fore200e_irq_itoa(fore200e->irq),
2735 (void*)fore200e->phys_base,
2736 fore200e->virt_base,
2737 fore200e->esi,
2738 fore200e->esi[4] * 256 + fore200e->esi[5]);
2749 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2750 fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2751 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2752 fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2755 u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2786 u32 fw_release = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2787 u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2788 u32 oc3_revision = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2789 u32 media_index = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2795 switch (fore200e->loop_mode) {
2819 struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2826 fore200e->bus->read(&cp_monitor->mon_version),
2827 fore200e->bus->read(&cp_monitor->bstat));
2837 be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2838 be32_to_cpu(fore200e->stats->phy.framing_errors));
2850 be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2851 be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2852 be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2853 be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2854 be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2855 be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2856 be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
2867 be32_to_cpu(fore200e->stats->atm.cells_transmitted),
2868 be32_to_cpu(fore200e->stats->atm.cells_received),
2869 be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
2870 be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
2871 be32_to_cpu(fore200e->stats->atm.vci_bad_range),
2872 be32_to_cpu(fore200e->stats->atm.vci_no_conn));
2880 be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
2881 be32_to_cpu(fore200e->stats->aal0.cells_received),
2882 be32_to_cpu(fore200e->stats->aal0.cells_dropped));
2898 be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
2899 be32_to_cpu(fore200e->stats->aal34.cells_received),
2900 be32_to_cpu(fore200e->stats->aal34.cells_dropped),
2901 be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
2902 be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
2903 be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
2904 be32_to_cpu(fore200e->stats->aal34.cspdus_received),
2905 be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
2906 be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
2922 be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
2923 be32_to_cpu(fore200e->stats->aal5.cells_received),
2924 be32_to_cpu(fore200e->stats->aal5.cells_dropped),
2925 be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
2926 be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
2927 be32_to_cpu(fore200e->stats->aal5.cspdus_received),
2928 be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
2929 be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
2930 be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
2941 be32_to_cpu(fore200e->stats->aux.small_b1_failed),
2942 be32_to_cpu(fore200e->stats->aux.large_b1_failed),
2943 be32_to_cpu(fore200e->stats->aux.small_b2_failed),
2944 be32_to_cpu(fore200e->stats->aux.large_b2_failed),
2945 be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
2946 fore200e->tx_sat);
2951 fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
2961 vcc = fore200e->vc_map[i].vcc;
2966 spin_lock_irqsave(&fore200e->q_lock, flags);
2984 spin_unlock_irqrestore(&fore200e->q_lock, flags);
2988 spin_unlock_irqrestore(&fore200e->q_lock, flags);