drivers/atm/fore200e.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3   A FORE Systems 200E-series driver for ATM on Linux.
   4   Christophe Lizzi (lizzi@cnam.fr), October 1999-March 2003.
   5
   6   Based on the PCA-200E driver from Uwe Dannowski (Uwe.Dannowski@inf.tu-dresden.de).
   7
   8   This driver simultaneously supports PCA-200E and SBA-200E adapters
   9   on i386, alpha (untested), powerpc, sparc and sparc64 architectures.
  10
  11 */
  12
  13
  14 #include <linux/kernel.h>
  15 #include <linux/slab.h>
  16 #include <linux/init.h>
  17 #include <linux/capability.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/bitops.h>
  20 #include <linux/pci.h>
  21 #include <linux/module.h>
  22 #include <linux/atmdev.h>
  23 #include <linux/sonet.h>
  24 #include <linux/atm_suni.h>
  25 #include <linux/dma-mapping.h>
  26 #include <linux/delay.h>
  27 #include <linux/firmware.h>
  28 #include <asm/io.h>
  29 #include <asm/string.h>
  30 #include <asm/page.h>
  31 #include <asm/irq.h>
  32 #include <asm/dma.h>
  33 #include <asm/byteorder.h>
  34 #include <linux/uaccess.h>
  35 #include <linux/atomic.h>
  36
  37 #ifdef CONFIG_SBUS
  38 #include <linux/of.h>
  39 #include <linux/of_device.h>
  40 #include <asm/idprom.h>
  41 #include <asm/openprom.h>
  42 #include <asm/oplib.h>
  43 #include <linux/pgtable.h>
  44 #endif
  45
  46 #if defined(CONFIG_ATM_FORE200E_USE_TASKLET) /* defer interrupt work to a tasklet */
  47 #define FORE200E_USE_TASKLET
  48 #endif
  49
  50 #if 0 /* enable the debugging code of the buffer supply queues */
  51 #define FORE200E_BSQ_DEBUG
  52 #endif
  53
  54 #if 1 /* ensure correct handling of 52-byte AAL0 SDUs expected by atmdump-like apps */
  55 #define FORE200E_52BYTE_AAL0_SDU
  56 #endif
  57
  58 #include "fore200e.h"
  59 #include "suni.h"
  60
  61 #define FORE200E_VERSION "0.3e"
  62
  63 #define FORE200E         "fore200e: "
  64
  65 #if 0 /* override .config */
  66 #define CONFIG_ATM_FORE200E_DEBUG 1
  67 #endif
  68 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
  69 #define DPRINTK(level, format, args...)  do { if (CONFIG_ATM_FORE200E_DEBUG >= (level)) \
  70                                                   printk(FORE200E format, ##args); } while (0)
  71 #else
  72 #define DPRINTK(level, format, args...)  do {} while (0)
  73 #endif
  74
  75
  76 #define FORE200E_ALIGN(addr, alignment) \
  77         ((((unsigned long)(addr) + (alignment - 1)) & ~(alignment - 1)) - (unsigned long)(addr))
  78
  79 #define FORE200E_DMA_INDEX(dma_addr, type, index)  ((dma_addr) + (index) * sizeof(type))
  80
  81 #define FORE200E_INDEX(virt_addr, type, index)     (&((type *)(virt_addr))[ index ])
  82
  83 #define FORE200E_NEXT_ENTRY(index, modulo)         (index = ((index) + 1) % (modulo))
  84
  85 #if 1
  86 #define ASSERT(expr)     if (!(expr)) { \
  87                              printk(FORE200E "assertion failed! %s[%d]: %s\n", \
  88                                     __func__, __LINE__, #expr); \
  89                              panic(FORE200E "%s", __func__); \
  90                          }
  91 #else
  92 #define ASSERT(expr)     do {} while (0)
  93 #endif
  94
  95
  96 static const struct atmdev_ops   fore200e_ops;
  97
  98 static LIST_HEAD(fore200e_boards);
  99
 100
 101 MODULE_AUTHOR("Christophe Lizzi - credits to Uwe Dannowski and Heikki Vatiainen");
 102 MODULE_DESCRIPTION("FORE Systems 200E-series ATM driver - version " FORE200E_VERSION);
 103 MODULE_SUPPORTED_DEVICE("PCA-200E, SBA-200E");
 104
 105
 106 static const int fore200e_rx_buf_nbr[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
 107     { BUFFER_S1_NBR, BUFFER_L1_NBR },
 108     { BUFFER_S2_NBR, BUFFER_L2_NBR }
 109 };
 110
 111 static const int fore200e_rx_buf_size[ BUFFER_SCHEME_NBR ][ BUFFER_MAGN_NBR ] = {
 112     { BUFFER_S1_SIZE, BUFFER_L1_SIZE },
 113     { BUFFER_S2_SIZE, BUFFER_L2_SIZE }
 114 };
 115
 116
 117 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG > 0)
 118 static const char* fore200e_traffic_class[] = { "NONE", "UBR", "CBR", "VBR", "ABR", "ANY" };
 119 #endif
 120
 121
 122 #if 0 /* currently unused */
 123 static int
 124 fore200e_fore2atm_aal(enum fore200e_aal aal)
 125 {
 126     switch(aal) {
 127     case FORE200E_AAL0:  return ATM_AAL0;
 128     case FORE200E_AAL34: return ATM_AAL34;
 129     case FORE200E_AAL5:  return ATM_AAL5;
 130     }
 131
 132     return -EINVAL;
 133 }
 134 #endif
 135
 136
 137 static enum fore200e_aal
 138 fore200e_atm2fore_aal(int aal)
 139 {
 140     switch(aal) {
 141     case ATM_AAL0:  return FORE200E_AAL0;
 142     case ATM_AAL34: return FORE200E_AAL34;
 143     case ATM_AAL1:
 144     case ATM_AAL2:
 145     case ATM_AAL5:  return FORE200E_AAL5;
 146     }
 147
 148     return -EINVAL;
 149 }
 150
 151
 152 static char*
 153 fore200e_irq_itoa(int irq)
 154 {
 155     static char str[8];
 156     sprintf(str, "%d", irq);
 157     return str;
 158 }
 159
 160
 161 /* allocate and align a chunk of memory intended to hold the data behing exchanged
 162    between the driver and the adapter (using streaming DVMA) */
 163
 164 static int
 165 fore200e_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, int size, int alignment, int direction)
 166 {
 167     unsigned long offset = 0;
 168
 169     if (alignment <= sizeof(int))
 170         alignment = 0;
 171
 172     chunk->alloc_size = size + alignment;
 173     chunk->direction  = direction;
 174
 175     chunk->alloc_addr = kzalloc(chunk->alloc_size, GFP_KERNEL);
 176     if (chunk->alloc_addr == NULL)
 177         return -ENOMEM;
 178
 179     if (alignment > 0)
 180         offset = FORE200E_ALIGN(chunk->alloc_addr, alignment);
 181
 182     chunk->align_addr = chunk->alloc_addr + offset;
 183
 184     chunk->dma_addr = dma_map_single(fore200e->dev, chunk->align_addr,
 185                                      size, direction);
 186     if (dma_mapping_error(fore200e->dev, chunk->dma_addr)) {
 187         kfree(chunk->alloc_addr);
 188         return -ENOMEM;
 189     }
 190     return 0;
 191 }
 192
 193
 194 /* free a chunk of memory */
 195
 196 static void
 197 fore200e_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
 198 {
 199     dma_unmap_single(fore200e->dev, chunk->dma_addr, chunk->dma_size,
 200                      chunk->direction);
 201     kfree(chunk->alloc_addr);
 202 }
 203
 204 /*
 205  * Allocate a DMA consistent chunk of memory intended to act as a communication
 206  * mechanism (to hold descriptors, status, queues, etc.) shared by the driver
 207  * and the adapter.
 208  */
 209 static int
 210 fore200e_dma_chunk_alloc(struct fore200e *fore200e, struct chunk *chunk,
 211                 int size, int nbr, int alignment)
 212 {
 213         /* returned chunks are page-aligned */
 214         chunk->alloc_size = size * nbr;
 215         chunk->alloc_addr = dma_alloc_coherent(fore200e->dev, chunk->alloc_size,
 216                                                &chunk->dma_addr, GFP_KERNEL);
 217         if (!chunk->alloc_addr)
 218                 return -ENOMEM;
 219         chunk->align_addr = chunk->alloc_addr;
 220         return 0;
 221 }
 222
 223 /*
 224  * Free a DMA consistent chunk of memory.
 225  */
 226 static void
 227 fore200e_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk)
 228 {
 229         dma_free_coherent(fore200e->dev, chunk->alloc_size, chunk->alloc_addr,
 230                           chunk->dma_addr);
 231 }
 232
 233 static void
 234 fore200e_spin(int msecs)
 235 {
 236     unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
 237     while (time_before(jiffies, timeout));
 238 }
 239
 240
 241 static int
 242 fore200e_poll(struct fore200e* fore200e, volatile u32* addr, u32 val, int msecs)
 243 {
 244     unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
 245     int           ok;
 246
 247     mb();
 248     do {
 249         if ((ok = (*addr == val)) || (*addr & STATUS_ERROR))
 250             break;
 251
 252     } while (time_before(jiffies, timeout));
 253
 254 #if 1
 255     if (!ok) {
 256         printk(FORE200E "cmd polling failed, got status 0x%08x, expected 0x%08x\n",
 257                *addr, val);
 258     }
 259 #endif
 260
 261     return ok;
 262 }
 263
 264
 265 static int
 266 fore200e_io_poll(struct fore200e* fore200e, volatile u32 __iomem *addr, u32 val, int msecs)
 267 {
 268     unsigned long timeout = jiffies + msecs_to_jiffies(msecs);
 269     int           ok;
 270
 271     do {
 272         if ((ok = (fore200e->bus->read(addr) == val)))
 273             break;
 274
 275     } while (time_before(jiffies, timeout));
 276
 277 #if 1
 278     if (!ok) {
 279         printk(FORE200E "I/O polling failed, got status 0x%08x, expected 0x%08x\n",
 280                fore200e->bus->read(addr), val);
 281     }
 282 #endif
 283
 284     return ok;
 285 }
 286
 287
 288 static void
 289 fore200e_free_rx_buf(struct fore200e* fore200e)
 290 {
 291     int scheme, magn, nbr;
 292     struct buffer* buffer;
 293
 294     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
 295         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
 296
 297             if ((buffer = fore200e->host_bsq[ scheme ][ magn ].buffer) != NULL) {
 298
 299                 for (nbr = 0; nbr < fore200e_rx_buf_nbr[ scheme ][ magn ]; nbr++) {
 300
 301                     struct chunk* data = &buffer[ nbr ].data;
 302
 303                     if (data->alloc_addr != NULL)
 304                         fore200e_chunk_free(fore200e, data);
 305                 }
 306             }
 307         }
 308     }
 309 }
 310
 311
 312 static void
 313 fore200e_uninit_bs_queue(struct fore200e* fore200e)
 314 {
 315     int scheme, magn;
 316
 317     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
 318         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
 319
 320             struct chunk* status    = &fore200e->host_bsq[ scheme ][ magn ].status;
 321             struct chunk* rbd_block = &fore200e->host_bsq[ scheme ][ magn ].rbd_block;
 322
 323             if (status->alloc_addr)
 324                 fore200e_dma_chunk_free(fore200e, status);
 325
 326             if (rbd_block->alloc_addr)
 327                 fore200e_dma_chunk_free(fore200e, rbd_block);
 328         }
 329     }
 330 }
 331
 332
 333 static int
 334 fore200e_reset(struct fore200e* fore200e, int diag)
 335 {
 336     int ok;
 337
 338     fore200e->cp_monitor = fore200e->virt_base + FORE200E_CP_MONITOR_OFFSET;
 339
 340     fore200e->bus->write(BSTAT_COLD_START, &fore200e->cp_monitor->bstat);
 341
 342     fore200e->bus->reset(fore200e);
 343
 344     if (diag) {
 345         ok = fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_SELFTEST_OK, 1000);
 346         if (ok == 0) {
 347
 348             printk(FORE200E "device %s self-test failed\n", fore200e->name);
 349             return -ENODEV;
 350         }
 351
 352         printk(FORE200E "device %s self-test passed\n", fore200e->name);
 353
 354         fore200e->state = FORE200E_STATE_RESET;
 355     }
 356
 357     return 0;
 358 }
 359
 360
 361 static void
 362 fore200e_shutdown(struct fore200e* fore200e)
 363 {
 364     printk(FORE200E "removing device %s at 0x%lx, IRQ %s\n",
 365            fore200e->name, fore200e->phys_base,
 366            fore200e_irq_itoa(fore200e->irq));
 367
 368     if (fore200e->state > FORE200E_STATE_RESET) {
 369         /* first, reset the board to prevent further interrupts or data transfers */
 370         fore200e_reset(fore200e, 0);
 371     }
 372
 373     /* then, release all allocated resources */
 374     switch(fore200e->state) {
 375
 376     case FORE200E_STATE_COMPLETE:
 377         kfree(fore200e->stats);
 378
 379         /* fall through */
 380     case FORE200E_STATE_IRQ:
 381         free_irq(fore200e->irq, fore200e->atm_dev);
 382
 383         /* fall through */
 384     case FORE200E_STATE_ALLOC_BUF:
 385         fore200e_free_rx_buf(fore200e);
 386
 387         /* fall through */
 388     case FORE200E_STATE_INIT_BSQ:
 389         fore200e_uninit_bs_queue(fore200e);
 390
 391         /* fall through */
 392     case FORE200E_STATE_INIT_RXQ:
 393         fore200e_dma_chunk_free(fore200e, &fore200e->host_rxq.status);
 394         fore200e_dma_chunk_free(fore200e, &fore200e->host_rxq.rpd);
 395
 396         /* fall through */
 397     case FORE200E_STATE_INIT_TXQ:
 398         fore200e_dma_chunk_free(fore200e, &fore200e->host_txq.status);
 399         fore200e_dma_chunk_free(fore200e, &fore200e->host_txq.tpd);
 400
 401         /* fall through */
 402     case FORE200E_STATE_INIT_CMDQ:
 403         fore200e_dma_chunk_free(fore200e, &fore200e->host_cmdq.status);
 404
 405         /* fall through */
 406     case FORE200E_STATE_INITIALIZE:
 407         /* nothing to do for that state */
 408
 409     case FORE200E_STATE_START_FW:
 410         /* nothing to do for that state */
 411
 412     case FORE200E_STATE_RESET:
 413         /* nothing to do for that state */
 414
 415     case FORE200E_STATE_MAP:
 416         fore200e->bus->unmap(fore200e);
 417
 418         /* fall through */
 419     case FORE200E_STATE_CONFIGURE:
 420         /* nothing to do for that state */
 421
 422     case FORE200E_STATE_REGISTER:
 423         /* XXX shouldn't we *start* by deregistering the device? */
 424         atm_dev_deregister(fore200e->atm_dev);
 425
 426     case FORE200E_STATE_BLANK:
 427         /* nothing to do for that state */
 428         break;
 429     }
 430 }
 431
 432
 433 #ifdef CONFIG_PCI
 434
 435 static u32 fore200e_pca_read(volatile u32 __iomem *addr)
 436 {
 437     /* on big-endian hosts, the board is configured to convert
 438        the endianess of slave RAM accesses  */
 439     return le32_to_cpu(readl(addr));
 440 }
 441
 442
 443 static void fore200e_pca_write(u32 val, volatile u32 __iomem *addr)
 444 {
 445     /* on big-endian hosts, the board is configured to convert
 446        the endianess of slave RAM accesses  */
 447     writel(cpu_to_le32(val), addr);
 448 }
 449
 450 static int
 451 fore200e_pca_irq_check(struct fore200e* fore200e)
 452 {
 453     /* this is a 1 bit register */
 454     int irq_posted = readl(fore200e->regs.pca.psr);
 455
 456 #if defined(CONFIG_ATM_FORE200E_DEBUG) && (CONFIG_ATM_FORE200E_DEBUG == 2)
 457     if (irq_posted && (readl(fore200e->regs.pca.hcr) & PCA200E_HCR_OUTFULL)) {
 458         DPRINTK(2,"FIFO OUT full, device %d\n", fore200e->atm_dev->number);
 459     }
 460 #endif
 461
 462     return irq_posted;
 463 }
 464
 465
 466 static void
 467 fore200e_pca_irq_ack(struct fore200e* fore200e)
 468 {
 469     writel(PCA200E_HCR_CLRINTR, fore200e->regs.pca.hcr);
 470 }
 471
 472
 473 static void
 474 fore200e_pca_reset(struct fore200e* fore200e)
 475 {
 476     writel(PCA200E_HCR_RESET, fore200e->regs.pca.hcr);
 477     fore200e_spin(10);
 478     writel(0, fore200e->regs.pca.hcr);
 479 }
 480
 481
 482 static int fore200e_pca_map(struct fore200e* fore200e)
 483 {
 484     DPRINTK(2, "device %s being mapped in memory\n", fore200e->name);
 485
 486     fore200e->virt_base = ioremap(fore200e->phys_base, PCA200E_IOSPACE_LENGTH);
 487
 488     if (fore200e->virt_base == NULL) {
 489         printk(FORE200E "can't map device %s\n", fore200e->name);
 490         return -EFAULT;
 491     }
 492
 493     DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
 494
 495     /* gain access to the PCA specific registers  */
 496     fore200e->regs.pca.hcr = fore200e->virt_base + PCA200E_HCR_OFFSET;
 497     fore200e->regs.pca.imr = fore200e->virt_base + PCA200E_IMR_OFFSET;
 498     fore200e->regs.pca.psr = fore200e->virt_base + PCA200E_PSR_OFFSET;
 499
 500     fore200e->state = FORE200E_STATE_MAP;
 501     return 0;
 502 }
 503
 504
 505 static void
 506 fore200e_pca_unmap(struct fore200e* fore200e)
 507 {
 508     DPRINTK(2, "device %s being unmapped from memory\n", fore200e->name);
 509
 510     if (fore200e->virt_base != NULL)
 511         iounmap(fore200e->virt_base);
 512 }
 513
 514
 515 static int fore200e_pca_configure(struct fore200e *fore200e)
 516 {
 517     struct pci_dev *pci_dev = to_pci_dev(fore200e->dev);
 518     u8              master_ctrl, latency;
 519
 520     DPRINTK(2, "device %s being configured\n", fore200e->name);
 521
 522     if ((pci_dev->irq == 0) || (pci_dev->irq == 0xFF)) {
 523         printk(FORE200E "incorrect IRQ setting - misconfigured PCI-PCI bridge?\n");
 524         return -EIO;
 525     }
 526
 527     pci_read_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, &master_ctrl);
 528
 529     master_ctrl = master_ctrl
 530 #if defined(__BIG_ENDIAN)
 531         /* request the PCA board to convert the endianess of slave RAM accesses */
 532         | PCA200E_CTRL_CONVERT_ENDIAN
 533 #endif
 534 #if 0
 535         | PCA200E_CTRL_DIS_CACHE_RD
 536         | PCA200E_CTRL_DIS_WRT_INVAL
 537         | PCA200E_CTRL_ENA_CONT_REQ_MODE
 538         | PCA200E_CTRL_2_CACHE_WRT_INVAL
 539 #endif
 540         | PCA200E_CTRL_LARGE_PCI_BURSTS;
 541
 542     pci_write_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, master_ctrl);
 543
 544     /* raise latency from 32 (default) to 192, as this seems to prevent NIC
 545        lockups (under heavy rx loads) due to continuous 'FIFO OUT full' condition.
 546        this may impact the performances of other PCI devices on the same bus, though */
 547     latency = 192;
 548     pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
 549
 550     fore200e->state = FORE200E_STATE_CONFIGURE;
 551     return 0;
 552 }
 553
 554
 555 static int __init
 556 fore200e_pca_prom_read(struct fore200e* fore200e, struct prom_data* prom)
 557 {
 558     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
 559     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
 560     struct prom_opcode      opcode;
 561     int                     ok;
 562     u32                     prom_dma;
 563
 564     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
 565
 566     opcode.opcode = OPCODE_GET_PROM;
 567     opcode.pad    = 0;
 568
 569     prom_dma = dma_map_single(fore200e->dev, prom, sizeof(struct prom_data),
 570                               DMA_FROM_DEVICE);
 571     if (dma_mapping_error(fore200e->dev, prom_dma))
 572         return -ENOMEM;
 573
 574     fore200e->bus->write(prom_dma, &entry->cp_entry->cmd.prom_block.prom_haddr);
 575
 576     *entry->status = STATUS_PENDING;
 577
 578     fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.prom_block.opcode);
 579
 580     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
 581
 582     *entry->status = STATUS_FREE;
 583
 584     dma_unmap_single(fore200e->dev, prom_dma, sizeof(struct prom_data), DMA_FROM_DEVICE);
 585
 586     if (ok == 0) {
 587         printk(FORE200E "unable to get PROM data from device %s\n", fore200e->name);
 588         return -EIO;
 589     }
 590
 591 #if defined(__BIG_ENDIAN)
 592
 593 #define swap_here(addr) (*((u32*)(addr)) = swab32( *((u32*)(addr)) ))
 594
 595     /* MAC address is stored as little-endian */
 596     swap_here(&prom->mac_addr[0]);
 597     swap_here(&prom->mac_addr[4]);
 598 #endif
 599
 600     return 0;
 601 }
 602
 603
 604 static int
 605 fore200e_pca_proc_read(struct fore200e* fore200e, char *page)
 606 {
 607     struct pci_dev *pci_dev = to_pci_dev(fore200e->dev);
 608
 609     return sprintf(page, "   PCI bus/slot/function:\t%d/%d/%d\n",
 610                    pci_dev->bus->number, PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
 611 }
 612
 613 static const struct fore200e_bus fore200e_pci_ops = {
 614         .model_name             = "PCA-200E",
 615         .proc_name              = "pca200e",
 616         .descr_alignment        = 32,
 617         .buffer_alignment       = 4,
 618         .status_alignment       = 32,
 619         .read                   = fore200e_pca_read,
 620         .write                  = fore200e_pca_write,
 621         .configure              = fore200e_pca_configure,
 622         .map                    = fore200e_pca_map,
 623         .reset                  = fore200e_pca_reset,
 624         .prom_read              = fore200e_pca_prom_read,
 625         .unmap                  = fore200e_pca_unmap,
 626         .irq_check              = fore200e_pca_irq_check,
 627         .irq_ack                = fore200e_pca_irq_ack,
 628         .proc_read              = fore200e_pca_proc_read,
 629 };
 630 #endif /* CONFIG_PCI */
 631
 632 #ifdef CONFIG_SBUS
 633
 634 static u32 fore200e_sba_read(volatile u32 __iomem *addr)
 635 {
 636     return sbus_readl(addr);
 637 }
 638
 639 static void fore200e_sba_write(u32 val, volatile u32 __iomem *addr)
 640 {
 641     sbus_writel(val, addr);
 642 }
 643
 644 static void fore200e_sba_irq_enable(struct fore200e *fore200e)
 645 {
 646         u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
 647         fore200e->bus->write(hcr | SBA200E_HCR_INTR_ENA, fore200e->regs.sba.hcr);
 648 }
 649
 650 static int fore200e_sba_irq_check(struct fore200e *fore200e)
 651 {
 652         return fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_INTR_REQ;
 653 }
 654
 655 static void fore200e_sba_irq_ack(struct fore200e *fore200e)
 656 {
 657         u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
 658         fore200e->bus->write(hcr | SBA200E_HCR_INTR_CLR, fore200e->regs.sba.hcr);
 659 }
 660
 661 static void fore200e_sba_reset(struct fore200e *fore200e)
 662 {
 663         fore200e->bus->write(SBA200E_HCR_RESET, fore200e->regs.sba.hcr);
 664         fore200e_spin(10);
 665         fore200e->bus->write(0, fore200e->regs.sba.hcr);
 666 }
 667
 668 static int __init fore200e_sba_map(struct fore200e *fore200e)
 669 {
 670         struct platform_device *op = to_platform_device(fore200e->dev);
 671         unsigned int bursts;
 672
 673         /* gain access to the SBA specific registers  */
 674         fore200e->regs.sba.hcr = of_ioremap(&op->resource[0], 0, SBA200E_HCR_LENGTH, "SBA HCR");
 675         fore200e->regs.sba.bsr = of_ioremap(&op->resource[1], 0, SBA200E_BSR_LENGTH, "SBA BSR");
 676         fore200e->regs.sba.isr = of_ioremap(&op->resource[2], 0, SBA200E_ISR_LENGTH, "SBA ISR");
 677         fore200e->virt_base    = of_ioremap(&op->resource[3], 0, SBA200E_RAM_LENGTH, "SBA RAM");
 678
 679         if (!fore200e->virt_base) {
 680                 printk(FORE200E "unable to map RAM of device %s\n", fore200e->name);
 681                 return -EFAULT;
 682         }
 683
 684         DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
 685
 686         fore200e->bus->write(0x02, fore200e->regs.sba.isr); /* XXX hardwired interrupt level */
 687
 688         /* get the supported DVMA burst sizes */
 689         bursts = of_getintprop_default(op->dev.of_node->parent, "burst-sizes", 0x00);
 690
 691         if (sbus_can_dma_64bit())
 692                 sbus_set_sbus64(&op->dev, bursts);
 693
 694         fore200e->state = FORE200E_STATE_MAP;
 695         return 0;
 696 }
 697
 698 static void fore200e_sba_unmap(struct fore200e *fore200e)
 699 {
 700         struct platform_device *op = to_platform_device(fore200e->dev);
 701
 702         of_iounmap(&op->resource[0], fore200e->regs.sba.hcr, SBA200E_HCR_LENGTH);
 703         of_iounmap(&op->resource[1], fore200e->regs.sba.bsr, SBA200E_BSR_LENGTH);
 704         of_iounmap(&op->resource[2], fore200e->regs.sba.isr, SBA200E_ISR_LENGTH);
 705         of_iounmap(&op->resource[3], fore200e->virt_base,    SBA200E_RAM_LENGTH);
 706 }
 707
 708 static int __init fore200e_sba_configure(struct fore200e *fore200e)
 709 {
 710         fore200e->state = FORE200E_STATE_CONFIGURE;
 711         return 0;
 712 }
 713
 714 static int __init fore200e_sba_prom_read(struct fore200e *fore200e, struct prom_data *prom)
 715 {
 716         struct platform_device *op = to_platform_device(fore200e->dev);
 717         const u8 *prop;
 718         int len;
 719
 720         prop = of_get_property(op->dev.of_node, "madaddrlo2", &len);
 721         if (!prop)
 722                 return -ENODEV;
 723         memcpy(&prom->mac_addr[4], prop, 4);
 724
 725         prop = of_get_property(op->dev.of_node, "madaddrhi4", &len);
 726         if (!prop)
 727                 return -ENODEV;
 728         memcpy(&prom->mac_addr[2], prop, 4);
 729
 730         prom->serial_number = of_getintprop_default(op->dev.of_node,
 731                                                     "serialnumber", 0);
 732         prom->hw_revision = of_getintprop_default(op->dev.of_node,
 733                                                   "promversion", 0);
 734
 735         return 0;
 736 }
 737
 738 static int fore200e_sba_proc_read(struct fore200e *fore200e, char *page)
 739 {
 740         struct platform_device *op = to_platform_device(fore200e->dev);
 741         const struct linux_prom_registers *regs;
 742
 743         regs = of_get_property(op->dev.of_node, "reg", NULL);
 744
 745         return sprintf(page, "   SBUS slot/device:\t\t%d/'%pOFn'\n",
 746                        (regs ? regs->which_io : 0), op->dev.of_node);
 747 }
 748
 749 static const struct fore200e_bus fore200e_sbus_ops = {
 750         .model_name             = "SBA-200E",
 751         .proc_name              = "sba200e",
 752         .descr_alignment        = 32,
 753         .buffer_alignment       = 64,
 754         .status_alignment       = 32,
 755         .read                   = fore200e_sba_read,
 756         .write                  = fore200e_sba_write,
 757         .configure              = fore200e_sba_configure,
 758         .map                    = fore200e_sba_map,
 759         .reset                  = fore200e_sba_reset,
 760         .prom_read              = fore200e_sba_prom_read,
 761         .unmap                  = fore200e_sba_unmap,
 762         .irq_enable             = fore200e_sba_irq_enable,
 763         .irq_check              = fore200e_sba_irq_check,
 764         .irq_ack                = fore200e_sba_irq_ack,
 765         .proc_read              = fore200e_sba_proc_read,
 766 };
 767 #endif /* CONFIG_SBUS */
 768
 769 static void
 770 fore200e_tx_irq(struct fore200e* fore200e)
 771 {
 772     struct host_txq*        txq = &fore200e->host_txq;
 773     struct host_txq_entry*  entry;
 774     struct atm_vcc*         vcc;
 775     struct fore200e_vc_map* vc_map;
 776
 777     if (fore200e->host_txq.txing == 0)
 778         return;
 779
 780     for (;;) {
 781
 782         entry = &txq->host_entry[ txq->tail ];
 783
 784         if ((*entry->status & STATUS_COMPLETE) == 0) {
 785             break;
 786         }
 787
 788         DPRINTK(3, "TX COMPLETED: entry = %p [tail = %d], vc_map = %p, skb = %p\n",
 789                 entry, txq->tail, entry->vc_map, entry->skb);
 790
 791         /* free copy of misaligned data */
 792         kfree(entry->data);
 793
 794         /* remove DMA mapping */
 795         dma_unmap_single(fore200e->dev, entry->tpd->tsd[ 0 ].buffer, entry->tpd->tsd[ 0 ].length,
 796                                  DMA_TO_DEVICE);
 797
 798         vc_map = entry->vc_map;
 799
 800         /* vcc closed since the time the entry was submitted for tx? */
 801         if ((vc_map->vcc == NULL) ||
 802             (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
 803
 804             DPRINTK(1, "no ready vcc found for PDU sent on device %d\n",
 805                     fore200e->atm_dev->number);
 806
 807             dev_kfree_skb_any(entry->skb);
 808         }
 809         else {
 810             ASSERT(vc_map->vcc);
 811
 812             /* vcc closed then immediately re-opened? */
 813             if (vc_map->incarn != entry->incarn) {
 814
 815                 /* when a vcc is closed, some PDUs may be still pending in the tx queue.
 816                    if the same vcc is immediately re-opened, those pending PDUs must
 817                    not be popped after the completion of their emission, as they refer
 818                    to the prior incarnation of that vcc. otherwise, sk_atm(vcc)->sk_wmem_alloc
 819                    would be decremented by the size of the (unrelated) skb, possibly
 820                    leading to a negative sk->sk_wmem_alloc count, ultimately freezing the vcc.
 821                    we thus bind the tx entry to the current incarnation of the vcc
 822                    when the entry is submitted for tx. When the tx later completes,
 823                    if the incarnation number of the tx entry does not match the one
 824                    of the vcc, then this implies that the vcc has been closed then re-opened.
 825                    we thus just drop the skb here. */
 826
 827                 DPRINTK(1, "vcc closed-then-re-opened; dropping PDU sent on device %d\n",
 828                         fore200e->atm_dev->number);
 829
 830                 dev_kfree_skb_any(entry->skb);
 831             }
 832             else {
 833                 vcc = vc_map->vcc;
 834                 ASSERT(vcc);
 835
 836                 /* notify tx completion */
 837                 if (vcc->pop) {
 838                     vcc->pop(vcc, entry->skb);
 839                 }
 840                 else {
 841                     dev_kfree_skb_any(entry->skb);
 842                 }
 843
 844                 /* check error condition */
 845                 if (*entry->status & STATUS_ERROR)
 846                     atomic_inc(&vcc->stats->tx_err);
 847                 else
 848                     atomic_inc(&vcc->stats->tx);
 849             }
 850         }
 851
 852         *entry->status = STATUS_FREE;
 853
 854         fore200e->host_txq.txing--;
 855
 856         FORE200E_NEXT_ENTRY(txq->tail, QUEUE_SIZE_TX);
 857     }
 858 }
 859
 860
 861 #ifdef FORE200E_BSQ_DEBUG
 862 int bsq_audit(int where, struct host_bsq* bsq, int scheme, int magn)
 863 {
 864     struct buffer* buffer;
 865     int count = 0;
 866
 867     buffer = bsq->freebuf;
 868     while (buffer) {
 869
 870         if (buffer->supplied) {
 871             printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld supplied but in free list!\n",
 872                    where, scheme, magn, buffer->index);
 873         }
 874
 875         if (buffer->magn != magn) {
 876             printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected magn = %d\n",
 877                    where, scheme, magn, buffer->index, buffer->magn);
 878         }
 879
 880         if (buffer->scheme != scheme) {
 881             printk(FORE200E "bsq_audit(%d): queue %d.%d, buffer %ld, unexpected scheme = %d\n",
 882                    where, scheme, magn, buffer->index, buffer->scheme);
 883         }
 884
 885         if ((buffer->index < 0) || (buffer->index >= fore200e_rx_buf_nbr[ scheme ][ magn ])) {
 886             printk(FORE200E "bsq_audit(%d): queue %d.%d, out of range buffer index = %ld !\n",
 887                    where, scheme, magn, buffer->index);
 888         }
 889
 890         count++;
 891         buffer = buffer->next;
 892     }
 893
 894     if (count != bsq->freebuf_count) {
 895         printk(FORE200E "bsq_audit(%d): queue %d.%d, %d bufs in free list, but freebuf_count = %d\n",
 896                where, scheme, magn, count, bsq->freebuf_count);
 897     }
 898     return 0;
 899 }
 900 #endif
 901
 902
 903 static void
 904 fore200e_supply(struct fore200e* fore200e)
 905 {
 906     int  scheme, magn, i;
 907
 908     struct host_bsq*       bsq;
 909     struct host_bsq_entry* entry;
 910     struct buffer*         buffer;
 911
 912     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
 913         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
 914
 915             bsq = &fore200e->host_bsq[ scheme ][ magn ];
 916
 917 #ifdef FORE200E_BSQ_DEBUG
 918             bsq_audit(1, bsq, scheme, magn);
 919 #endif
 920             while (bsq->freebuf_count >= RBD_BLK_SIZE) {
 921
 922                 DPRINTK(2, "supplying %d rx buffers to queue %d / %d, freebuf_count = %d\n",
 923                         RBD_BLK_SIZE, scheme, magn, bsq->freebuf_count);
 924
 925                 entry = &bsq->host_entry[ bsq->head ];
 926
 927                 for (i = 0; i < RBD_BLK_SIZE; i++) {
 928
 929                     /* take the first buffer in the free buffer list */
 930                     buffer = bsq->freebuf;
 931                     if (!buffer) {
 932                         printk(FORE200E "no more free bufs in queue %d.%d, but freebuf_count = %d\n",
 933                                scheme, magn, bsq->freebuf_count);
 934                         return;
 935                     }
 936                     bsq->freebuf = buffer->next;
 937
 938 #ifdef FORE200E_BSQ_DEBUG
 939                     if (buffer->supplied)
 940                         printk(FORE200E "queue %d.%d, buffer %lu already supplied\n",
 941                                scheme, magn, buffer->index);
 942                     buffer->supplied = 1;
 943 #endif
 944                     entry->rbd_block->rbd[ i ].buffer_haddr = buffer->data.dma_addr;
 945                     entry->rbd_block->rbd[ i ].handle       = FORE200E_BUF2HDL(buffer);
 946                 }
 947
 948                 FORE200E_NEXT_ENTRY(bsq->head, QUEUE_SIZE_BS);
 949
 950                 /* decrease accordingly the number of free rx buffers */
 951                 bsq->freebuf_count -= RBD_BLK_SIZE;
 952
 953                 *entry->status = STATUS_PENDING;
 954                 fore200e->bus->write(entry->rbd_block_dma, &entry->cp_entry->rbd_block_haddr);
 955             }
 956         }
 957     }
 958 }
 959
 960
 961 static int
 962 fore200e_push_rpd(struct fore200e* fore200e, struct atm_vcc* vcc, struct rpd* rpd)
 963 {
 964     struct sk_buff*      skb;
 965     struct buffer*       buffer;
 966     struct fore200e_vcc* fore200e_vcc;
 967     int                  i, pdu_len = 0;
 968 #ifdef FORE200E_52BYTE_AAL0_SDU
 969     u32                  cell_header = 0;
 970 #endif
 971
 972     ASSERT(vcc);
 973
 974     fore200e_vcc = FORE200E_VCC(vcc);
 975     ASSERT(fore200e_vcc);
 976
 977 #ifdef FORE200E_52BYTE_AAL0_SDU
 978     if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.rxtp.max_sdu == ATM_AAL0_SDU)) {
 979
 980         cell_header = (rpd->atm_header.gfc << ATM_HDR_GFC_SHIFT) |
 981                       (rpd->atm_header.vpi << ATM_HDR_VPI_SHIFT) |
 982                       (rpd->atm_header.vci << ATM_HDR_VCI_SHIFT) |
 983                       (rpd->atm_header.plt << ATM_HDR_PTI_SHIFT) |
 984                        rpd->atm_header.clp;
 985         pdu_len = 4;
 986     }
 987 #endif
 988
 989     /* compute total PDU length */
 990     for (i = 0; i < rpd->nseg; i++)
 991         pdu_len += rpd->rsd[ i ].length;
 992
 993     skb = alloc_skb(pdu_len, GFP_ATOMIC);
 994     if (skb == NULL) {
 995         DPRINTK(2, "unable to alloc new skb, rx PDU length = %d\n", pdu_len);
 996
 997         atomic_inc(&vcc->stats->rx_drop);
 998         return -ENOMEM;
 999     }
1000
1001     __net_timestamp(skb);
1002
1003 #ifdef FORE200E_52BYTE_AAL0_SDU
1004     if (cell_header) {
1005         *((u32*)skb_put(skb, 4)) = cell_header;
1006     }
1007 #endif
1008
1009     /* reassemble segments */
1010     for (i = 0; i < rpd->nseg; i++) {
1011
1012         /* rebuild rx buffer address from rsd handle */
1013         buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1014
1015         /* Make device DMA transfer visible to CPU.  */
1016         dma_sync_single_for_cpu(fore200e->dev, buffer->data.dma_addr,
1017                                 rpd->rsd[i].length, DMA_FROM_DEVICE);
1018
1019         skb_put_data(skb, buffer->data.align_addr, rpd->rsd[i].length);
1020
1021         /* Now let the device get at it again.  */
1022         dma_sync_single_for_device(fore200e->dev, buffer->data.dma_addr,
1023                                    rpd->rsd[i].length, DMA_FROM_DEVICE);
1024     }
1025
1026     DPRINTK(3, "rx skb: len = %d, truesize = %d\n", skb->len, skb->truesize);
1027
1028     if (pdu_len < fore200e_vcc->rx_min_pdu)
1029         fore200e_vcc->rx_min_pdu = pdu_len;
1030     if (pdu_len > fore200e_vcc->rx_max_pdu)
1031         fore200e_vcc->rx_max_pdu = pdu_len;
1032     fore200e_vcc->rx_pdu++;
1033
1034     /* push PDU */
1035     if (atm_charge(vcc, skb->truesize) == 0) {
1036
1037         DPRINTK(2, "receive buffers saturated for %d.%d.%d - PDU dropped\n",
1038                 vcc->itf, vcc->vpi, vcc->vci);
1039
1040         dev_kfree_skb_any(skb);
1041
1042         atomic_inc(&vcc->stats->rx_drop);
1043         return -ENOMEM;
1044     }
1045
1046     vcc->push(vcc, skb);
1047     atomic_inc(&vcc->stats->rx);
1048
1049     return 0;
1050 }
1051
1052
1053 static void
1054 fore200e_collect_rpd(struct fore200e* fore200e, struct rpd* rpd)
1055 {
1056     struct host_bsq* bsq;
1057     struct buffer*   buffer;
1058     int              i;
1059
1060     for (i = 0; i < rpd->nseg; i++) {
1061
1062         /* rebuild rx buffer address from rsd handle */
1063         buffer = FORE200E_HDL2BUF(rpd->rsd[ i ].handle);
1064
1065         bsq = &fore200e->host_bsq[ buffer->scheme ][ buffer->magn ];
1066
1067 #ifdef FORE200E_BSQ_DEBUG
1068         bsq_audit(2, bsq, buffer->scheme, buffer->magn);
1069
1070         if (buffer->supplied == 0)
1071             printk(FORE200E "queue %d.%d, buffer %ld was not supplied\n",
1072                    buffer->scheme, buffer->magn, buffer->index);
1073         buffer->supplied = 0;
1074 #endif
1075
1076         /* re-insert the buffer into the free buffer list */
1077         buffer->next = bsq->freebuf;
1078         bsq->freebuf = buffer;
1079
1080         /* then increment the number of free rx buffers */
1081         bsq->freebuf_count++;
1082     }
1083 }
1084
1085
1086 static void
1087 fore200e_rx_irq(struct fore200e* fore200e)
1088 {
1089     struct host_rxq*        rxq = &fore200e->host_rxq;
1090     struct host_rxq_entry*  entry;
1091     struct atm_vcc*         vcc;
1092     struct fore200e_vc_map* vc_map;
1093
1094     for (;;) {
1095
1096         entry = &rxq->host_entry[ rxq->head ];
1097
1098         /* no more received PDUs */
1099         if ((*entry->status & STATUS_COMPLETE) == 0)
1100             break;
1101
1102         vc_map = FORE200E_VC_MAP(fore200e, entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1103
1104         if ((vc_map->vcc == NULL) ||
1105             (test_bit(ATM_VF_READY, &vc_map->vcc->flags) == 0)) {
1106
1107             DPRINTK(1, "no ready VC found for PDU received on %d.%d.%d\n",
1108                     fore200e->atm_dev->number,
1109                     entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1110         }
1111         else {
1112             vcc = vc_map->vcc;
1113             ASSERT(vcc);
1114
1115             if ((*entry->status & STATUS_ERROR) == 0) {
1116
1117                 fore200e_push_rpd(fore200e, vcc, entry->rpd);
1118             }
1119             else {
1120                 DPRINTK(2, "damaged PDU on %d.%d.%d\n",
1121                         fore200e->atm_dev->number,
1122                         entry->rpd->atm_header.vpi, entry->rpd->atm_header.vci);
1123                 atomic_inc(&vcc->stats->rx_err);
1124             }
1125         }
1126
1127         FORE200E_NEXT_ENTRY(rxq->head, QUEUE_SIZE_RX);
1128
1129         fore200e_collect_rpd(fore200e, entry->rpd);
1130
1131         /* rewrite the rpd address to ack the received PDU */
1132         fore200e->bus->write(entry->rpd_dma, &entry->cp_entry->rpd_haddr);
1133         *entry->status = STATUS_FREE;
1134
1135         fore200e_supply(fore200e);
1136     }
1137 }
1138
1139
1140 #ifndef FORE200E_USE_TASKLET
1141 static void
1142 fore200e_irq(struct fore200e* fore200e)
1143 {
1144     unsigned long flags;
1145
1146     spin_lock_irqsave(&fore200e->q_lock, flags);
1147     fore200e_rx_irq(fore200e);
1148     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1149
1150     spin_lock_irqsave(&fore200e->q_lock, flags);
1151     fore200e_tx_irq(fore200e);
1152     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1153 }
1154 #endif
1155
1156
1157 static irqreturn_t
1158 fore200e_interrupt(int irq, void* dev)
1159 {
1160     struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev);
1161
1162     if (fore200e->bus->irq_check(fore200e) == 0) {
1163
1164         DPRINTK(3, "interrupt NOT triggered by device %d\n", fore200e->atm_dev->number);
1165         return IRQ_NONE;
1166     }
1167     DPRINTK(3, "interrupt triggered by device %d\n", fore200e->atm_dev->number);
1168
1169 #ifdef FORE200E_USE_TASKLET
1170     tasklet_schedule(&fore200e->tx_tasklet);
1171     tasklet_schedule(&fore200e->rx_tasklet);
1172 #else
1173     fore200e_irq(fore200e);
1174 #endif
1175
1176     fore200e->bus->irq_ack(fore200e);
1177     return IRQ_HANDLED;
1178 }
1179
1180
1181 #ifdef FORE200E_USE_TASKLET
1182 static void
1183 fore200e_tx_tasklet(unsigned long data)
1184 {
1185     struct fore200e* fore200e = (struct fore200e*) data;
1186     unsigned long flags;
1187
1188     DPRINTK(3, "tx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1189
1190     spin_lock_irqsave(&fore200e->q_lock, flags);
1191     fore200e_tx_irq(fore200e);
1192     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1193 }
1194
1195
1196 static void
1197 fore200e_rx_tasklet(unsigned long data)
1198 {
1199     struct fore200e* fore200e = (struct fore200e*) data;
1200     unsigned long    flags;
1201
1202     DPRINTK(3, "rx tasklet scheduled for device %d\n", fore200e->atm_dev->number);
1203
1204     spin_lock_irqsave(&fore200e->q_lock, flags);
1205     fore200e_rx_irq((struct fore200e*) data);
1206     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1207 }
1208 #endif
1209
1210
1211 static int
1212 fore200e_select_scheme(struct atm_vcc* vcc)
1213 {
1214     /* fairly balance the VCs over (identical) buffer schemes */
1215     int scheme = vcc->vci % 2 ? BUFFER_SCHEME_ONE : BUFFER_SCHEME_TWO;
1216
1217     DPRINTK(1, "VC %d.%d.%d uses buffer scheme %d\n",
1218             vcc->itf, vcc->vpi, vcc->vci, scheme);
1219
1220     return scheme;
1221 }
1222
1223
1224 static int
1225 fore200e_activate_vcin(struct fore200e* fore200e, int activate, struct atm_vcc* vcc, int mtu)
1226 {
1227     struct host_cmdq*        cmdq  = &fore200e->host_cmdq;
1228     struct host_cmdq_entry*  entry = &cmdq->host_entry[ cmdq->head ];
1229     struct activate_opcode   activ_opcode;
1230     struct deactivate_opcode deactiv_opcode;
1231     struct vpvc              vpvc;
1232     int                      ok;
1233     enum fore200e_aal        aal = fore200e_atm2fore_aal(vcc->qos.aal);
1234
1235     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1236
1237     if (activate) {
1238         FORE200E_VCC(vcc)->scheme = fore200e_select_scheme(vcc);
1239
1240         activ_opcode.opcode = OPCODE_ACTIVATE_VCIN;
1241         activ_opcode.aal    = aal;
1242         activ_opcode.scheme = FORE200E_VCC(vcc)->scheme;
1243         activ_opcode.pad    = 0;
1244     }
1245     else {
1246         deactiv_opcode.opcode = OPCODE_DEACTIVATE_VCIN;
1247         deactiv_opcode.pad    = 0;
1248     }
1249
1250     vpvc.vci = vcc->vci;
1251     vpvc.vpi = vcc->vpi;
1252
1253     *entry->status = STATUS_PENDING;
1254
1255     if (activate) {
1256
1257 #ifdef FORE200E_52BYTE_AAL0_SDU
1258         mtu = 48;
1259 #endif
1260         /* the MTU is not used by the cp, except in the case of AAL0 */
1261         fore200e->bus->write(mtu,                        &entry->cp_entry->cmd.activate_block.mtu);
1262         fore200e->bus->write(*(u32*)&vpvc,         (u32 __iomem *)&entry->cp_entry->cmd.activate_block.vpvc);
1263         fore200e->bus->write(*(u32*)&activ_opcode, (u32 __iomem *)&entry->cp_entry->cmd.activate_block.opcode);
1264     }
1265     else {
1266         fore200e->bus->write(*(u32*)&vpvc,         (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.vpvc);
1267         fore200e->bus->write(*(u32*)&deactiv_opcode, (u32 __iomem *)&entry->cp_entry->cmd.deactivate_block.opcode);
1268     }
1269
1270     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1271
1272     *entry->status = STATUS_FREE;
1273
1274     if (ok == 0) {
1275         printk(FORE200E "unable to %s VC %d.%d.%d\n",
1276                activate ? "open" : "close", vcc->itf, vcc->vpi, vcc->vci);
1277         return -EIO;
1278     }
1279
1280     DPRINTK(1, "VC %d.%d.%d %sed\n", vcc->itf, vcc->vpi, vcc->vci,
1281             activate ? "open" : "clos");
1282
1283     return 0;
1284 }
1285
1286
1287 #define FORE200E_MAX_BACK2BACK_CELLS 255    /* XXX depends on CDVT */
1288
1289 static void
1290 fore200e_rate_ctrl(struct atm_qos* qos, struct tpd_rate* rate)
1291 {
1292     if (qos->txtp.max_pcr < ATM_OC3_PCR) {
1293
1294         /* compute the data cells to idle cells ratio from the tx PCR */
1295         rate->data_cells = qos->txtp.max_pcr * FORE200E_MAX_BACK2BACK_CELLS / ATM_OC3_PCR;
1296         rate->idle_cells = FORE200E_MAX_BACK2BACK_CELLS - rate->data_cells;
1297     }
1298     else {
1299         /* disable rate control */
1300         rate->data_cells = rate->idle_cells = 0;
1301     }
1302 }
1303
1304
1305 static int
1306 fore200e_open(struct atm_vcc *vcc)
1307 {
1308     struct fore200e*        fore200e = FORE200E_DEV(vcc->dev);
1309     struct fore200e_vcc*    fore200e_vcc;
1310     struct fore200e_vc_map* vc_map;
1311     unsigned long           flags;
1312     int                     vci = vcc->vci;
1313     short                   vpi = vcc->vpi;
1314
1315     ASSERT((vpi >= 0) && (vpi < 1<<FORE200E_VPI_BITS));
1316     ASSERT((vci >= 0) && (vci < 1<<FORE200E_VCI_BITS));
1317
1318     spin_lock_irqsave(&fore200e->q_lock, flags);
1319
1320     vc_map = FORE200E_VC_MAP(fore200e, vpi, vci);
1321     if (vc_map->vcc) {
1322
1323         spin_unlock_irqrestore(&fore200e->q_lock, flags);
1324
1325         printk(FORE200E "VC %d.%d.%d already in use\n",
1326                fore200e->atm_dev->number, vpi, vci);
1327
1328         return -EINVAL;
1329     }
1330
1331     vc_map->vcc = vcc;
1332
1333     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1334
1335     fore200e_vcc = kzalloc(sizeof(struct fore200e_vcc), GFP_ATOMIC);
1336     if (fore200e_vcc == NULL) {
1337         vc_map->vcc = NULL;
1338         return -ENOMEM;
1339     }
1340
1341     DPRINTK(2, "opening %d.%d.%d:%d QoS = (tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1342             "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d)\n",
1343             vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1344             fore200e_traffic_class[ vcc->qos.txtp.traffic_class ],
1345             vcc->qos.txtp.min_pcr, vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_cdv, vcc->qos.txtp.max_sdu,
1346             fore200e_traffic_class[ vcc->qos.rxtp.traffic_class ],
1347             vcc->qos.rxtp.min_pcr, vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_cdv, vcc->qos.rxtp.max_sdu);
1348
1349     /* pseudo-CBR bandwidth requested? */
1350     if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1351
1352         mutex_lock(&fore200e->rate_mtx);
1353         if (fore200e->available_cell_rate < vcc->qos.txtp.max_pcr) {
1354             mutex_unlock(&fore200e->rate_mtx);
1355
1356             kfree(fore200e_vcc);
1357             vc_map->vcc = NULL;
1358             return -EAGAIN;
1359         }
1360
1361         /* reserve bandwidth */
1362         fore200e->available_cell_rate -= vcc->qos.txtp.max_pcr;
1363         mutex_unlock(&fore200e->rate_mtx);
1364     }
1365
1366     vcc->itf = vcc->dev->number;
1367
1368     set_bit(ATM_VF_PARTIAL,&vcc->flags);
1369     set_bit(ATM_VF_ADDR, &vcc->flags);
1370
1371     vcc->dev_data = fore200e_vcc;
1372
1373     if (fore200e_activate_vcin(fore200e, 1, vcc, vcc->qos.rxtp.max_sdu) < 0) {
1374
1375         vc_map->vcc = NULL;
1376
1377         clear_bit(ATM_VF_ADDR, &vcc->flags);
1378         clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1379
1380         vcc->dev_data = NULL;
1381
1382         fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1383
1384         kfree(fore200e_vcc);
1385         return -EINVAL;
1386     }
1387
1388     /* compute rate control parameters */
1389     if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1390
1391         fore200e_rate_ctrl(&vcc->qos, &fore200e_vcc->rate);
1392         set_bit(ATM_VF_HASQOS, &vcc->flags);
1393
1394         DPRINTK(3, "tx on %d.%d.%d:%d, tx PCR = %d, rx PCR = %d, data_cells = %u, idle_cells = %u\n",
1395                 vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1396                 vcc->qos.txtp.max_pcr, vcc->qos.rxtp.max_pcr,
1397                 fore200e_vcc->rate.data_cells, fore200e_vcc->rate.idle_cells);
1398     }
1399
1400     fore200e_vcc->tx_min_pdu = fore200e_vcc->rx_min_pdu = MAX_PDU_SIZE + 1;
1401     fore200e_vcc->tx_max_pdu = fore200e_vcc->rx_max_pdu = 0;
1402     fore200e_vcc->tx_pdu     = fore200e_vcc->rx_pdu     = 0;
1403
1404     /* new incarnation of the vcc */
1405     vc_map->incarn = ++fore200e->incarn_count;
1406
1407     /* VC unusable before this flag is set */
1408     set_bit(ATM_VF_READY, &vcc->flags);
1409
1410     return 0;
1411 }
1412
1413
1414 static void
1415 fore200e_close(struct atm_vcc* vcc)
1416 {
1417     struct fore200e_vcc*    fore200e_vcc;
1418     struct fore200e*        fore200e;
1419     struct fore200e_vc_map* vc_map;
1420     unsigned long           flags;
1421
1422     ASSERT(vcc);
1423     fore200e = FORE200E_DEV(vcc->dev);
1424
1425     ASSERT((vcc->vpi >= 0) && (vcc->vpi < 1<<FORE200E_VPI_BITS));
1426     ASSERT((vcc->vci >= 0) && (vcc->vci < 1<<FORE200E_VCI_BITS));
1427
1428     DPRINTK(2, "closing %d.%d.%d:%d\n", vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal));
1429
1430     clear_bit(ATM_VF_READY, &vcc->flags);
1431
1432     fore200e_activate_vcin(fore200e, 0, vcc, 0);
1433
1434     spin_lock_irqsave(&fore200e->q_lock, flags);
1435
1436     vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1437
1438     /* the vc is no longer considered as "in use" by fore200e_open() */
1439     vc_map->vcc = NULL;
1440
1441     vcc->itf = vcc->vci = vcc->vpi = 0;
1442
1443     fore200e_vcc = FORE200E_VCC(vcc);
1444     vcc->dev_data = NULL;
1445
1446     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1447
1448     /* release reserved bandwidth, if any */
1449     if ((vcc->qos.txtp.traffic_class == ATM_CBR) && (vcc->qos.txtp.max_pcr > 0)) {
1450
1451         mutex_lock(&fore200e->rate_mtx);
1452         fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1453         mutex_unlock(&fore200e->rate_mtx);
1454
1455         clear_bit(ATM_VF_HASQOS, &vcc->flags);
1456     }
1457
1458     clear_bit(ATM_VF_ADDR, &vcc->flags);
1459     clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1460
1461     ASSERT(fore200e_vcc);
1462     kfree(fore200e_vcc);
1463 }
1464
1465
1466 static int
1467 fore200e_send(struct atm_vcc *vcc, struct sk_buff *skb)
1468 {
1469     struct fore200e*        fore200e;
1470     struct fore200e_vcc*    fore200e_vcc;
1471     struct fore200e_vc_map* vc_map;
1472     struct host_txq*        txq;
1473     struct host_txq_entry*  entry;
1474     struct tpd*             tpd;
1475     struct tpd_haddr        tpd_haddr;
1476     int                     retry        = CONFIG_ATM_FORE200E_TX_RETRY;
1477     int                     tx_copy      = 0;
1478     int                     tx_len       = skb->len;
1479     u32*                    cell_header  = NULL;
1480     unsigned char*          skb_data;
1481     int                     skb_len;
1482     unsigned char*          data;
1483     unsigned long           flags;
1484
1485     if (!vcc)
1486         return -EINVAL;
1487
1488     fore200e = FORE200E_DEV(vcc->dev);
1489     fore200e_vcc = FORE200E_VCC(vcc);
1490
1491     if (!fore200e)
1492         return -EINVAL;
1493
1494     txq = &fore200e->host_txq;
1495     if (!fore200e_vcc)
1496         return -EINVAL;
1497
1498     if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1499         DPRINTK(1, "VC %d.%d.%d not ready for tx\n", vcc->itf, vcc->vpi, vcc->vpi);
1500         dev_kfree_skb_any(skb);
1501         return -EINVAL;
1502     }
1503
1504 #ifdef FORE200E_52BYTE_AAL0_SDU
1505     if ((vcc->qos.aal == ATM_AAL0) && (vcc->qos.txtp.max_sdu == ATM_AAL0_SDU)) {
1506         cell_header = (u32*) skb->data;
1507         skb_data    = skb->data + 4;    /* skip 4-byte cell header */
1508         skb_len     = tx_len = skb->len  - 4;
1509
1510         DPRINTK(3, "user-supplied cell header = 0x%08x\n", *cell_header);
1511     }
1512     else
1513 #endif
1514     {
1515         skb_data = skb->data;
1516         skb_len  = skb->len;
1517     }
1518
1519     if (((unsigned long)skb_data) & 0x3) {
1520
1521         DPRINTK(2, "misaligned tx PDU on device %s\n", fore200e->name);
1522         tx_copy = 1;
1523         tx_len  = skb_len;
1524     }
1525
1526     if ((vcc->qos.aal == ATM_AAL0) && (skb_len % ATM_CELL_PAYLOAD)) {
1527
1528         /* this simply NUKES the PCA board */
1529         DPRINTK(2, "incomplete tx AAL0 PDU on device %s\n", fore200e->name);
1530         tx_copy = 1;
1531         tx_len  = ((skb_len / ATM_CELL_PAYLOAD) + 1) * ATM_CELL_PAYLOAD;
1532     }
1533
1534     if (tx_copy) {
1535         data = kmalloc(tx_len, GFP_ATOMIC);
1536         if (data == NULL) {
1537             if (vcc->pop) {
1538                 vcc->pop(vcc, skb);
1539             }
1540             else {
1541                 dev_kfree_skb_any(skb);
1542             }
1543             return -ENOMEM;
1544         }
1545
1546         memcpy(data, skb_data, skb_len);
1547         if (skb_len < tx_len)
1548             memset(data + skb_len, 0x00, tx_len - skb_len);
1549     }
1550     else {
1551         data = skb_data;
1552     }
1553
1554     vc_map = FORE200E_VC_MAP(fore200e, vcc->vpi, vcc->vci);
1555     ASSERT(vc_map->vcc == vcc);
1556
1557   retry_here:
1558
1559     spin_lock_irqsave(&fore200e->q_lock, flags);
1560
1561     entry = &txq->host_entry[ txq->head ];
1562
1563     if ((*entry->status != STATUS_FREE) || (txq->txing >= QUEUE_SIZE_TX - 2)) {
1564
1565         /* try to free completed tx queue entries */
1566         fore200e_tx_irq(fore200e);
1567
1568         if (*entry->status != STATUS_FREE) {
1569
1570             spin_unlock_irqrestore(&fore200e->q_lock, flags);
1571
1572             /* retry once again? */
1573             if (--retry > 0) {
1574                 udelay(50);
1575                 goto retry_here;
1576             }
1577
1578             atomic_inc(&vcc->stats->tx_err);
1579
1580             fore200e->tx_sat++;
1581             DPRINTK(2, "tx queue of device %s is saturated, PDU dropped - heartbeat is %08x\n",
1582                     fore200e->name, fore200e->cp_queues->heartbeat);
1583             if (vcc->pop) {
1584                 vcc->pop(vcc, skb);
1585             }
1586             else {
1587                 dev_kfree_skb_any(skb);
1588             }
1589
1590             if (tx_copy)
1591                 kfree(data);
1592
1593             return -ENOBUFS;
1594         }
1595     }
1596
1597     entry->incarn = vc_map->incarn;
1598     entry->vc_map = vc_map;
1599     entry->skb    = skb;
1600     entry->data   = tx_copy ? data : NULL;
1601
1602     tpd = entry->tpd;
1603     tpd->tsd[ 0 ].buffer = dma_map_single(fore200e->dev, data, tx_len,
1604                                           DMA_TO_DEVICE);
1605     if (dma_mapping_error(fore200e->dev, tpd->tsd[0].buffer)) {
1606         if (tx_copy)
1607             kfree(data);
1608         spin_unlock_irqrestore(&fore200e->q_lock, flags);
1609         return -ENOMEM;
1610     }
1611     tpd->tsd[ 0 ].length = tx_len;
1612
1613     FORE200E_NEXT_ENTRY(txq->head, QUEUE_SIZE_TX);
1614     txq->txing++;
1615
1616     /* The dma_map call above implies a dma_sync so the device can use it,
1617      * thus no explicit dma_sync call is necessary here.
1618      */
1619
1620     DPRINTK(3, "tx on %d.%d.%d:%d, len = %u (%u)\n",
1621             vcc->itf, vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
1622             tpd->tsd[0].length, skb_len);
1623
1624     if (skb_len < fore200e_vcc->tx_min_pdu)
1625         fore200e_vcc->tx_min_pdu = skb_len;
1626     if (skb_len > fore200e_vcc->tx_max_pdu)
1627         fore200e_vcc->tx_max_pdu = skb_len;
1628     fore200e_vcc->tx_pdu++;
1629
1630     /* set tx rate control information */
1631     tpd->rate.data_cells = fore200e_vcc->rate.data_cells;
1632     tpd->rate.idle_cells = fore200e_vcc->rate.idle_cells;
1633
1634     if (cell_header) {
1635         tpd->atm_header.clp = (*cell_header & ATM_HDR_CLP);
1636         tpd->atm_header.plt = (*cell_header & ATM_HDR_PTI_MASK) >> ATM_HDR_PTI_SHIFT;
1637         tpd->atm_header.vci = (*cell_header & ATM_HDR_VCI_MASK) >> ATM_HDR_VCI_SHIFT;
1638         tpd->atm_header.vpi = (*cell_header & ATM_HDR_VPI_MASK) >> ATM_HDR_VPI_SHIFT;
1639         tpd->atm_header.gfc = (*cell_header & ATM_HDR_GFC_MASK) >> ATM_HDR_GFC_SHIFT;
1640     }
1641     else {
1642         /* set the ATM header, common to all cells conveying the PDU */
1643         tpd->atm_header.clp = 0;
1644         tpd->atm_header.plt = 0;
1645         tpd->atm_header.vci = vcc->vci;
1646         tpd->atm_header.vpi = vcc->vpi;
1647         tpd->atm_header.gfc = 0;
1648     }
1649
1650     tpd->spec.length = tx_len;
1651     tpd->spec.nseg   = 1;
1652     tpd->spec.aal    = fore200e_atm2fore_aal(vcc->qos.aal);
1653     tpd->spec.intr   = 1;
1654
1655     tpd_haddr.size  = sizeof(struct tpd) / (1<<TPD_HADDR_SHIFT);  /* size is expressed in 32 byte blocks */
1656     tpd_haddr.pad   = 0;
1657     tpd_haddr.haddr = entry->tpd_dma >> TPD_HADDR_SHIFT;          /* shift the address, as we are in a bitfield */
1658
1659     *entry->status = STATUS_PENDING;
1660     fore200e->bus->write(*(u32*)&tpd_haddr, (u32 __iomem *)&entry->cp_entry->tpd_haddr);
1661
1662     spin_unlock_irqrestore(&fore200e->q_lock, flags);
1663
1664     return 0;
1665 }
1666
1667
1668 static int
1669 fore200e_getstats(struct fore200e* fore200e)
1670 {
1671     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
1672     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1673     struct stats_opcode     opcode;
1674     int                     ok;
1675     u32                     stats_dma_addr;
1676
1677     if (fore200e->stats == NULL) {
1678         fore200e->stats = kzalloc(sizeof(struct stats), GFP_KERNEL);
1679         if (fore200e->stats == NULL)
1680             return -ENOMEM;
1681     }
1682
1683     stats_dma_addr = dma_map_single(fore200e->dev, fore200e->stats,
1684                                     sizeof(struct stats), DMA_FROM_DEVICE);
1685     if (dma_mapping_error(fore200e->dev, stats_dma_addr))
1686         return -ENOMEM;
1687
1688     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1689
1690     opcode.opcode = OPCODE_GET_STATS;
1691     opcode.pad    = 0;
1692
1693     fore200e->bus->write(stats_dma_addr, &entry->cp_entry->cmd.stats_block.stats_haddr);
1694
1695     *entry->status = STATUS_PENDING;
1696
1697     fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.stats_block.opcode);
1698
1699     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1700
1701     *entry->status = STATUS_FREE;
1702
1703     dma_unmap_single(fore200e->dev, stats_dma_addr, sizeof(struct stats), DMA_FROM_DEVICE);
1704
1705     if (ok == 0) {
1706         printk(FORE200E "unable to get statistics from device %s\n", fore200e->name);
1707         return -EIO;
1708     }
1709
1710     return 0;
1711 }
1712
1713
1714 static int
1715 fore200e_getsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, int optlen)
1716 {
1717     /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1718
1719     DPRINTK(2, "getsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1720             vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1721
1722     return -EINVAL;
1723 }
1724
1725
1726 static int
1727 fore200e_setsockopt(struct atm_vcc* vcc, int level, int optname, void __user *optval, unsigned int optlen)
1728 {
1729     /* struct fore200e* fore200e = FORE200E_DEV(vcc->dev); */
1730
1731     DPRINTK(2, "setsockopt %d.%d.%d, level = %d, optname = 0x%x, optval = 0x%p, optlen = %d\n",
1732             vcc->itf, vcc->vpi, vcc->vci, level, optname, optval, optlen);
1733
1734     return -EINVAL;
1735 }
1736
1737
1738 #if 0 /* currently unused */
1739 static int
1740 fore200e_get_oc3(struct fore200e* fore200e, struct oc3_regs* regs)
1741 {
1742     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
1743     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1744     struct oc3_opcode       opcode;
1745     int                     ok;
1746     u32                     oc3_regs_dma_addr;
1747
1748     oc3_regs_dma_addr = fore200e->bus->dma_map(fore200e, regs, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1749
1750     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1751
1752     opcode.opcode = OPCODE_GET_OC3;
1753     opcode.reg    = 0;
1754     opcode.value  = 0;
1755     opcode.mask   = 0;
1756
1757     fore200e->bus->write(oc3_regs_dma_addr, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1758
1759     *entry->status = STATUS_PENDING;
1760
1761     fore200e->bus->write(*(u32*)&opcode, (u32*)&entry->cp_entry->cmd.oc3_block.opcode);
1762
1763     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1764
1765     *entry->status = STATUS_FREE;
1766
1767     fore200e->bus->dma_unmap(fore200e, oc3_regs_dma_addr, sizeof(struct oc3_regs), DMA_FROM_DEVICE);
1768
1769     if (ok == 0) {
1770         printk(FORE200E "unable to get OC-3 regs of device %s\n", fore200e->name);
1771         return -EIO;
1772     }
1773
1774     return 0;
1775 }
1776 #endif
1777
1778
1779 static int
1780 fore200e_set_oc3(struct fore200e* fore200e, u32 reg, u32 value, u32 mask)
1781 {
1782     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
1783     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
1784     struct oc3_opcode       opcode;
1785     int                     ok;
1786
1787     DPRINTK(2, "set OC-3 reg = 0x%02x, value = 0x%02x, mask = 0x%02x\n", reg, value, mask);
1788
1789     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
1790
1791     opcode.opcode = OPCODE_SET_OC3;
1792     opcode.reg    = reg;
1793     opcode.value  = value;
1794     opcode.mask   = mask;
1795
1796     fore200e->bus->write(0, &entry->cp_entry->cmd.oc3_block.regs_haddr);
1797
1798     *entry->status = STATUS_PENDING;
1799
1800     fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.oc3_block.opcode);
1801
1802     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
1803
1804     *entry->status = STATUS_FREE;
1805
1806     if (ok == 0) {
1807         printk(FORE200E "unable to set OC-3 reg 0x%02x of device %s\n", reg, fore200e->name);
1808         return -EIO;
1809     }
1810
1811     return 0;
1812 }
1813
1814
1815 static int
1816 fore200e_setloop(struct fore200e* fore200e, int loop_mode)
1817 {
1818     u32 mct_value, mct_mask;
1819     int error;
1820
1821     if (!capable(CAP_NET_ADMIN))
1822         return -EPERM;
1823
1824     switch (loop_mode) {
1825
1826     case ATM_LM_NONE:
1827         mct_value = 0;
1828         mct_mask  = SUNI_MCT_DLE | SUNI_MCT_LLE;
1829         break;
1830
1831     case ATM_LM_LOC_PHY:
1832         mct_value = mct_mask = SUNI_MCT_DLE;
1833         break;
1834
1835     case ATM_LM_RMT_PHY:
1836         mct_value = mct_mask = SUNI_MCT_LLE;
1837         break;
1838
1839     default:
1840         return -EINVAL;
1841     }
1842
1843     error = fore200e_set_oc3(fore200e, SUNI_MCT, mct_value, mct_mask);
1844     if (error == 0)
1845         fore200e->loop_mode = loop_mode;
1846
1847     return error;
1848 }
1849
1850
1851 static int
1852 fore200e_fetch_stats(struct fore200e* fore200e, struct sonet_stats __user *arg)
1853 {
1854     struct sonet_stats tmp;
1855
1856     if (fore200e_getstats(fore200e) < 0)
1857         return -EIO;
1858
1859     tmp.section_bip = be32_to_cpu(fore200e->stats->oc3.section_bip8_errors);
1860     tmp.line_bip    = be32_to_cpu(fore200e->stats->oc3.line_bip24_errors);
1861     tmp.path_bip    = be32_to_cpu(fore200e->stats->oc3.path_bip8_errors);
1862     tmp.line_febe   = be32_to_cpu(fore200e->stats->oc3.line_febe_errors);
1863     tmp.path_febe   = be32_to_cpu(fore200e->stats->oc3.path_febe_errors);
1864     tmp.corr_hcs    = be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors);
1865     tmp.uncorr_hcs  = be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors);
1866     tmp.tx_cells    = be32_to_cpu(fore200e->stats->aal0.cells_transmitted)  +
1867                       be32_to_cpu(fore200e->stats->aal34.cells_transmitted) +
1868                       be32_to_cpu(fore200e->stats->aal5.cells_transmitted);
1869     tmp.rx_cells    = be32_to_cpu(fore200e->stats->aal0.cells_received)     +
1870                       be32_to_cpu(fore200e->stats->aal34.cells_received)    +
1871                       be32_to_cpu(fore200e->stats->aal5.cells_received);
1872
1873     if (arg)
1874         return copy_to_user(arg, &tmp, sizeof(struct sonet_stats)) ? -EFAULT : 0;
1875
1876     return 0;
1877 }
1878
1879
1880 static int
1881 fore200e_ioctl(struct atm_dev* dev, unsigned int cmd, void __user * arg)
1882 {
1883     struct fore200e* fore200e = FORE200E_DEV(dev);
1884
1885     DPRINTK(2, "ioctl cmd = 0x%x (%u), arg = 0x%p (%lu)\n", cmd, cmd, arg, (unsigned long)arg);
1886
1887     switch (cmd) {
1888
1889     case SONET_GETSTAT:
1890         return fore200e_fetch_stats(fore200e, (struct sonet_stats __user *)arg);
1891
1892     case SONET_GETDIAG:
1893         return put_user(0, (int __user *)arg) ? -EFAULT : 0;
1894
1895     case ATM_SETLOOP:
1896         return fore200e_setloop(fore200e, (int)(unsigned long)arg);
1897
1898     case ATM_GETLOOP:
1899         return put_user(fore200e->loop_mode, (int __user *)arg) ? -EFAULT : 0;
1900
1901     case ATM_QUERYLOOP:
1902         return put_user(ATM_LM_LOC_PHY | ATM_LM_RMT_PHY, (int __user *)arg) ? -EFAULT : 0;
1903     }
1904
1905     return -ENOSYS; /* not implemented */
1906 }
1907
1908
1909 static int
1910 fore200e_change_qos(struct atm_vcc* vcc,struct atm_qos* qos, int flags)
1911 {
1912     struct fore200e_vcc* fore200e_vcc = FORE200E_VCC(vcc);
1913     struct fore200e*     fore200e     = FORE200E_DEV(vcc->dev);
1914
1915     if (!test_bit(ATM_VF_READY, &vcc->flags)) {
1916         DPRINTK(1, "VC %d.%d.%d not ready for QoS change\n", vcc->itf, vcc->vpi, vcc->vpi);
1917         return -EINVAL;
1918     }
1919
1920     DPRINTK(2, "change_qos %d.%d.%d, "
1921             "(tx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d; "
1922             "rx: cl=%s, pcr=%d-%d, cdv=%d, max_sdu=%d), flags = 0x%x\n"
1923             "available_cell_rate = %u",
1924             vcc->itf, vcc->vpi, vcc->vci,
1925             fore200e_traffic_class[ qos->txtp.traffic_class ],
1926             qos->txtp.min_pcr, qos->txtp.max_pcr, qos->txtp.max_cdv, qos->txtp.max_sdu,
1927             fore200e_traffic_class[ qos->rxtp.traffic_class ],
1928             qos->rxtp.min_pcr, qos->rxtp.max_pcr, qos->rxtp.max_cdv, qos->rxtp.max_sdu,
1929             flags, fore200e->available_cell_rate);
1930
1931     if ((qos->txtp.traffic_class == ATM_CBR) && (qos->txtp.max_pcr > 0)) {
1932
1933         mutex_lock(&fore200e->rate_mtx);
1934         if (fore200e->available_cell_rate + vcc->qos.txtp.max_pcr < qos->txtp.max_pcr) {
1935             mutex_unlock(&fore200e->rate_mtx);
1936             return -EAGAIN;
1937         }
1938
1939         fore200e->available_cell_rate += vcc->qos.txtp.max_pcr;
1940         fore200e->available_cell_rate -= qos->txtp.max_pcr;
1941
1942         mutex_unlock(&fore200e->rate_mtx);
1943
1944         memcpy(&vcc->qos, qos, sizeof(struct atm_qos));
1945
1946         /* update rate control parameters */
1947         fore200e_rate_ctrl(qos, &fore200e_vcc->rate);
1948
1949         set_bit(ATM_VF_HASQOS, &vcc->flags);
1950
1951         return 0;
1952     }
1953
1954     return -EINVAL;
1955 }
1956
1957
1958 static int fore200e_irq_request(struct fore200e *fore200e)
1959 {
1960     if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
1961
1962         printk(FORE200E "unable to reserve IRQ %s for device %s\n",
1963                fore200e_irq_itoa(fore200e->irq), fore200e->name);
1964         return -EBUSY;
1965     }
1966
1967     printk(FORE200E "IRQ %s reserved for device %s\n",
1968            fore200e_irq_itoa(fore200e->irq), fore200e->name);
1969
1970 #ifdef FORE200E_USE_TASKLET
1971     tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
1972     tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
1973 #endif
1974
1975     fore200e->state = FORE200E_STATE_IRQ;
1976     return 0;
1977 }
1978
1979
1980 static int fore200e_get_esi(struct fore200e *fore200e)
1981 {
1982     struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL);
1983     int ok, i;
1984
1985     if (!prom)
1986         return -ENOMEM;
1987
1988     ok = fore200e->bus->prom_read(fore200e, prom);
1989     if (ok < 0) {
1990         kfree(prom);
1991         return -EBUSY;
1992     }
1993
1994     printk(FORE200E "device %s, rev. %c, S/N: %d, ESI: %pM\n",
1995            fore200e->name,
1996            (prom->hw_revision & 0xFF) + '@',    /* probably meaningless with SBA boards */
1997            prom->serial_number & 0xFFFF, &prom->mac_addr[2]);
1998
1999     for (i = 0; i < ESI_LEN; i++) {
2000         fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
2001     }
2002
2003     kfree(prom);
2004
2005     return 0;
2006 }
2007
2008
2009 static int fore200e_alloc_rx_buf(struct fore200e *fore200e)
2010 {
2011     int scheme, magn, nbr, size, i;
2012
2013     struct host_bsq* bsq;
2014     struct buffer*   buffer;
2015
2016     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2017         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2018
2019             bsq = &fore200e->host_bsq[ scheme ][ magn ];
2020
2021             nbr  = fore200e_rx_buf_nbr[ scheme ][ magn ];
2022             size = fore200e_rx_buf_size[ scheme ][ magn ];
2023
2024             DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
2025
2026             /* allocate the array of receive buffers */
2027             buffer = bsq->buffer = kcalloc(nbr, sizeof(struct buffer),
2028                                            GFP_KERNEL);
2029
2030             if (buffer == NULL)
2031                 return -ENOMEM;
2032
2033             bsq->freebuf = NULL;
2034
2035             for (i = 0; i < nbr; i++) {
2036
2037                 buffer[ i ].scheme = scheme;
2038                 buffer[ i ].magn   = magn;
2039 #ifdef FORE200E_BSQ_DEBUG
2040                 buffer[ i ].index  = i;
2041                 buffer[ i ].supplied = 0;
2042 #endif
2043
2044                 /* allocate the receive buffer body */
2045                 if (fore200e_chunk_alloc(fore200e,
2046                                          &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2047                                          DMA_FROM_DEVICE) < 0) {
2048
2049                     while (i > 0)
2050                         fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2051                     kfree(buffer);
2052
2053                     return -ENOMEM;
2054                 }
2055
2056                 /* insert the buffer into the free buffer list */
2057                 buffer[ i ].next = bsq->freebuf;
2058                 bsq->freebuf = &buffer[ i ];
2059             }
2060             /* all the buffers are free, initially */
2061             bsq->freebuf_count = nbr;
2062
2063 #ifdef FORE200E_BSQ_DEBUG
2064             bsq_audit(3, bsq, scheme, magn);
2065 #endif
2066         }
2067     }
2068
2069     fore200e->state = FORE200E_STATE_ALLOC_BUF;
2070     return 0;
2071 }
2072
2073
2074 static int fore200e_init_bs_queue(struct fore200e *fore200e)
2075 {
2076     int scheme, magn, i;
2077
2078     struct host_bsq*     bsq;
2079     struct cp_bsq_entry __iomem * cp_entry;
2080
2081     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2082         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2083
2084             DPRINTK(2, "buffer supply queue %d / %d is being initialized\n", scheme, magn);
2085
2086             bsq = &fore200e->host_bsq[ scheme ][ magn ];
2087
2088             /* allocate and align the array of status words */
2089             if (fore200e_dma_chunk_alloc(fore200e,
2090                                                &bsq->status,
2091                                                sizeof(enum status),
2092                                                QUEUE_SIZE_BS,
2093                                                fore200e->bus->status_alignment) < 0) {
2094                 return -ENOMEM;
2095             }
2096
2097             /* allocate and align the array of receive buffer descriptors */
2098             if (fore200e_dma_chunk_alloc(fore200e,
2099                                                &bsq->rbd_block,
2100                                                sizeof(struct rbd_block),
2101                                                QUEUE_SIZE_BS,
2102                                                fore200e->bus->descr_alignment) < 0) {
2103
2104                 fore200e_dma_chunk_free(fore200e, &bsq->status);
2105                 return -ENOMEM;
2106             }
2107
2108             /* get the base address of the cp resident buffer supply queue entries */
2109             cp_entry = fore200e->virt_base +
2110                        fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2111
2112             /* fill the host resident and cp resident buffer supply queue entries */
2113             for (i = 0; i < QUEUE_SIZE_BS; i++) {
2114
2115                 bsq->host_entry[ i ].status =
2116                                      FORE200E_INDEX(bsq->status.align_addr, enum status, i);
2117                 bsq->host_entry[ i ].rbd_block =
2118                                      FORE200E_INDEX(bsq->rbd_block.align_addr, struct rbd_block, i);
2119                 bsq->host_entry[ i ].rbd_block_dma =
2120                                      FORE200E_DMA_INDEX(bsq->rbd_block.dma_addr, struct rbd_block, i);
2121                 bsq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2122
2123                 *bsq->host_entry[ i ].status = STATUS_FREE;
2124
2125                 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i),
2126                                      &cp_entry[ i ].status_haddr);
2127             }
2128         }
2129     }
2130
2131     fore200e->state = FORE200E_STATE_INIT_BSQ;
2132     return 0;
2133 }
2134
2135
2136 static int fore200e_init_rx_queue(struct fore200e *fore200e)
2137 {
2138     struct host_rxq*     rxq =  &fore200e->host_rxq;
2139     struct cp_rxq_entry __iomem * cp_entry;
2140     int i;
2141
2142     DPRINTK(2, "receive queue is being initialized\n");
2143
2144     /* allocate and align the array of status words */
2145     if (fore200e_dma_chunk_alloc(fore200e,
2146                                        &rxq->status,
2147                                        sizeof(enum status),
2148                                        QUEUE_SIZE_RX,
2149                                        fore200e->bus->status_alignment) < 0) {
2150         return -ENOMEM;
2151     }
2152
2153     /* allocate and align the array of receive PDU descriptors */
2154     if (fore200e_dma_chunk_alloc(fore200e,
2155                                        &rxq->rpd,
2156                                        sizeof(struct rpd),
2157                                        QUEUE_SIZE_RX,
2158                                        fore200e->bus->descr_alignment) < 0) {
2159
2160         fore200e_dma_chunk_free(fore200e, &rxq->status);
2161         return -ENOMEM;
2162     }
2163
2164     /* get the base address of the cp resident rx queue entries */
2165     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2166
2167     /* fill the host resident and cp resident rx entries */
2168     for (i=0; i < QUEUE_SIZE_RX; i++) {
2169
2170         rxq->host_entry[ i ].status =
2171                              FORE200E_INDEX(rxq->status.align_addr, enum status, i);
2172         rxq->host_entry[ i ].rpd =
2173                              FORE200E_INDEX(rxq->rpd.align_addr, struct rpd, i);
2174         rxq->host_entry[ i ].rpd_dma =
2175                              FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i);
2176         rxq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2177
2178         *rxq->host_entry[ i ].status = STATUS_FREE;
2179
2180         fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i),
2181                              &cp_entry[ i ].status_haddr);
2182
2183         fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2184                              &cp_entry[ i ].rpd_haddr);
2185     }
2186
2187     /* set the head entry of the queue */
2188     rxq->head = 0;
2189
2190     fore200e->state = FORE200E_STATE_INIT_RXQ;
2191     return 0;
2192 }
2193
2194
2195 static int fore200e_init_tx_queue(struct fore200e *fore200e)
2196 {
2197     struct host_txq*     txq =  &fore200e->host_txq;
2198     struct cp_txq_entry __iomem * cp_entry;
2199     int i;
2200
2201     DPRINTK(2, "transmit queue is being initialized\n");
2202
2203     /* allocate and align the array of status words */
2204     if (fore200e_dma_chunk_alloc(fore200e,
2205                                        &txq->status,
2206                                        sizeof(enum status),
2207                                        QUEUE_SIZE_TX,
2208                                        fore200e->bus->status_alignment) < 0) {
2209         return -ENOMEM;
2210     }
2211
2212     /* allocate and align the array of transmit PDU descriptors */
2213     if (fore200e_dma_chunk_alloc(fore200e,
2214                                        &txq->tpd,
2215                                        sizeof(struct tpd),
2216                                        QUEUE_SIZE_TX,
2217                                        fore200e->bus->descr_alignment) < 0) {
2218
2219         fore200e_dma_chunk_free(fore200e, &txq->status);
2220         return -ENOMEM;
2221     }
2222
2223     /* get the base address of the cp resident tx queue entries */
2224     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2225
2226     /* fill the host resident and cp resident tx entries */
2227     for (i=0; i < QUEUE_SIZE_TX; i++) {
2228
2229         txq->host_entry[ i ].status =
2230                              FORE200E_INDEX(txq->status.align_addr, enum status, i);
2231         txq->host_entry[ i ].tpd =
2232                              FORE200E_INDEX(txq->tpd.align_addr, struct tpd, i);
2233         txq->host_entry[ i ].tpd_dma  =
2234                              FORE200E_DMA_INDEX(txq->tpd.dma_addr, struct tpd, i);
2235         txq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2236
2237         *txq->host_entry[ i ].status = STATUS_FREE;
2238
2239         fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i),
2240                              &cp_entry[ i ].status_haddr);
2241
2242         /* although there is a one-to-one mapping of tx queue entries and tpds,
2243            we do not write here the DMA (physical) base address of each tpd into
2244            the related cp resident entry, because the cp relies on this write
2245            operation to detect that a new pdu has been submitted for tx */
2246     }
2247
2248     /* set the head and tail entries of the queue */
2249     txq->head = 0;
2250     txq->tail = 0;
2251
2252     fore200e->state = FORE200E_STATE_INIT_TXQ;
2253     return 0;
2254 }
2255
2256
2257 static int fore200e_init_cmd_queue(struct fore200e *fore200e)
2258 {
2259     struct host_cmdq*     cmdq =  &fore200e->host_cmdq;
2260     struct cp_cmdq_entry __iomem * cp_entry;
2261     int i;
2262
2263     DPRINTK(2, "command queue is being initialized\n");
2264
2265     /* allocate and align the array of status words */
2266     if (fore200e_dma_chunk_alloc(fore200e,
2267                                        &cmdq->status,
2268                                        sizeof(enum status),
2269                                        QUEUE_SIZE_CMD,
2270                                        fore200e->bus->status_alignment) < 0) {
2271         return -ENOMEM;
2272     }
2273
2274     /* get the base address of the cp resident cmd queue entries */
2275     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2276
2277     /* fill the host resident and cp resident cmd entries */
2278     for (i=0; i < QUEUE_SIZE_CMD; i++) {
2279
2280         cmdq->host_entry[ i ].status   =
2281                               FORE200E_INDEX(cmdq->status.align_addr, enum status, i);
2282         cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2283
2284         *cmdq->host_entry[ i ].status = STATUS_FREE;
2285
2286         fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),
2287                              &cp_entry[ i ].status_haddr);
2288     }
2289
2290     /* set the head entry of the queue */
2291     cmdq->head = 0;
2292
2293     fore200e->state = FORE200E_STATE_INIT_CMDQ;
2294     return 0;
2295 }
2296
2297
2298 static void fore200e_param_bs_queue(struct fore200e *fore200e,
2299                                     enum buffer_scheme scheme,
2300                                     enum buffer_magn magn, int queue_length,
2301                                     int pool_size, int supply_blksize)
2302 {
2303     struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2304
2305     fore200e->bus->write(queue_length,                           &bs_spec->queue_length);
2306     fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2307     fore200e->bus->write(pool_size,                              &bs_spec->pool_size);
2308     fore200e->bus->write(supply_blksize,                         &bs_spec->supply_blksize);
2309 }
2310
2311
2312 static int fore200e_initialize(struct fore200e *fore200e)
2313 {
2314     struct cp_queues __iomem * cpq;
2315     int               ok, scheme, magn;
2316
2317     DPRINTK(2, "device %s being initialized\n", fore200e->name);
2318
2319     mutex_init(&fore200e->rate_mtx);
2320     spin_lock_init(&fore200e->q_lock);
2321
2322     cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2323
2324     /* enable cp to host interrupts */
2325     fore200e->bus->write(1, &cpq->imask);
2326
2327     if (fore200e->bus->irq_enable)
2328         fore200e->bus->irq_enable(fore200e);
2329
2330     fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2331
2332     fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2333     fore200e->bus->write(QUEUE_SIZE_RX,  &cpq->init.rx_queue_len);
2334     fore200e->bus->write(QUEUE_SIZE_TX,  &cpq->init.tx_queue_len);
2335
2336     fore200e->bus->write(RSD_EXTENSION,  &cpq->init.rsd_extension);
2337     fore200e->bus->write(TSD_EXTENSION,  &cpq->init.tsd_extension);
2338
2339     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++)
2340         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++)
2341             fore200e_param_bs_queue(fore200e, scheme, magn,
2342                                     QUEUE_SIZE_BS,
2343                                     fore200e_rx_buf_nbr[ scheme ][ magn ],
2344                                     RBD_BLK_SIZE);
2345
2346     /* issue the initialize command */
2347     fore200e->bus->write(STATUS_PENDING,    &cpq->init.status);
2348     fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2349
2350     ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2351     if (ok == 0) {
2352         printk(FORE200E "device %s initialization failed\n", fore200e->name);
2353         return -ENODEV;
2354     }
2355
2356     printk(FORE200E "device %s initialized\n", fore200e->name);
2357
2358     fore200e->state = FORE200E_STATE_INITIALIZE;
2359     return 0;
2360 }
2361
2362
2363 static void fore200e_monitor_putc(struct fore200e *fore200e, char c)
2364 {
2365     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2366
2367 #if 0
2368     printk("%c", c);
2369 #endif
2370     fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2371 }
2372
2373
2374 static int fore200e_monitor_getc(struct fore200e *fore200e)
2375 {
2376     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2377     unsigned long      timeout = jiffies + msecs_to_jiffies(50);
2378     int                c;
2379
2380     while (time_before(jiffies, timeout)) {
2381
2382         c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2383
2384         if (c & FORE200E_CP_MONITOR_UART_AVAIL) {
2385
2386             fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2387 #if 0
2388             printk("%c", c & 0xFF);
2389 #endif
2390             return c & 0xFF;
2391         }
2392     }
2393
2394     return -1;
2395 }
2396
2397
2398 static void fore200e_monitor_puts(struct fore200e *fore200e, char *str)
2399 {
2400     while (*str) {
2401
2402         /* the i960 monitor doesn't accept any new character if it has something to say */
2403         while (fore200e_monitor_getc(fore200e) >= 0);
2404
2405         fore200e_monitor_putc(fore200e, *str++);
2406     }
2407
2408     while (fore200e_monitor_getc(fore200e) >= 0);
2409 }
2410
2411 #ifdef __LITTLE_ENDIAN
2412 #define FW_EXT ".bin"
2413 #else
2414 #define FW_EXT "_ecd.bin2"
2415 #endif
2416
2417 static int fore200e_load_and_start_fw(struct fore200e *fore200e)
2418 {
2419     const struct firmware *firmware;
2420     const struct fw_header *fw_header;
2421     const __le32 *fw_data;
2422     u32 fw_size;
2423     u32 __iomem *load_addr;
2424     char buf[48];
2425     int err;
2426
2427     sprintf(buf, "%s%s", fore200e->bus->proc_name, FW_EXT);
2428     if ((err = request_firmware(&firmware, buf, fore200e->dev)) < 0) {
2429         printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
2430         return err;
2431     }
2432
2433     fw_data = (const __le32 *)firmware->data;
2434     fw_size = firmware->size / sizeof(u32);
2435     fw_header = (const struct fw_header *)firmware->data;
2436     load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2437
2438     DPRINTK(2, "device %s firmware being loaded at 0x%p (%d words)\n",
2439             fore200e->name, load_addr, fw_size);
2440
2441     if (le32_to_cpu(fw_header->magic) != FW_HEADER_MAGIC) {
2442         printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2443         goto release;
2444     }
2445
2446     for (; fw_size--; fw_data++, load_addr++)
2447         fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2448
2449     DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2450
2451 #if defined(__sparc_v9__)
2452     /* reported to be required by SBA cards on some sparc64 hosts */
2453     fore200e_spin(100);
2454 #endif
2455
2456     sprintf(buf, "\rgo %x\r", le32_to_cpu(fw_header->start_offset));
2457     fore200e_monitor_puts(fore200e, buf);
2458
2459     if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2460         printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2461         goto release;
2462     }
2463
2464     printk(FORE200E "device %s firmware started\n", fore200e->name);
2465
2466     fore200e->state = FORE200E_STATE_START_FW;
2467     err = 0;
2468
2469 release:
2470     release_firmware(firmware);
2471     return err;
2472 }
2473
2474
2475 static int fore200e_register(struct fore200e *fore200e, struct device *parent)
2476 {
2477     struct atm_dev* atm_dev;
2478
2479     DPRINTK(2, "device %s being registered\n", fore200e->name);
2480
2481     atm_dev = atm_dev_register(fore200e->bus->proc_name, parent, &fore200e_ops,
2482                                -1, NULL);
2483     if (atm_dev == NULL) {
2484         printk(FORE200E "unable to register device %s\n", fore200e->name);
2485         return -ENODEV;
2486     }
2487
2488     atm_dev->dev_data = fore200e;
2489     fore200e->atm_dev = atm_dev;
2490
2491     atm_dev->ci_range.vpi_bits = FORE200E_VPI_BITS;
2492     atm_dev->ci_range.vci_bits = FORE200E_VCI_BITS;
2493
2494     fore200e->available_cell_rate = ATM_OC3_PCR;
2495
2496     fore200e->state = FORE200E_STATE_REGISTER;
2497     return 0;
2498 }
2499
2500
2501 static int fore200e_init(struct fore200e *fore200e, struct device *parent)
2502 {
2503     if (fore200e_register(fore200e, parent) < 0)
2504         return -ENODEV;
2505
2506     if (fore200e->bus->configure(fore200e) < 0)
2507         return -ENODEV;
2508
2509     if (fore200e->bus->map(fore200e) < 0)
2510         return -ENODEV;
2511
2512     if (fore200e_reset(fore200e, 1) < 0)
2513         return -ENODEV;
2514
2515     if (fore200e_load_and_start_fw(fore200e) < 0)
2516         return -ENODEV;
2517
2518     if (fore200e_initialize(fore200e) < 0)
2519         return -ENODEV;
2520
2521     if (fore200e_init_cmd_queue(fore200e) < 0)
2522         return -ENOMEM;
2523
2524     if (fore200e_init_tx_queue(fore200e) < 0)
2525         return -ENOMEM;
2526
2527     if (fore200e_init_rx_queue(fore200e) < 0)
2528         return -ENOMEM;
2529
2530     if (fore200e_init_bs_queue(fore200e) < 0)
2531         return -ENOMEM;
2532
2533     if (fore200e_alloc_rx_buf(fore200e) < 0)
2534         return -ENOMEM;
2535
2536     if (fore200e_get_esi(fore200e) < 0)
2537         return -EIO;
2538
2539     if (fore200e_irq_request(fore200e) < 0)
2540         return -EBUSY;
2541
2542     fore200e_supply(fore200e);
2543
2544     /* all done, board initialization is now complete */
2545     fore200e->state = FORE200E_STATE_COMPLETE;
2546     return 0;
2547 }
2548
2549 #ifdef CONFIG_SBUS
2550 static const struct of_device_id fore200e_sba_match[];
2551 static int fore200e_sba_probe(struct platform_device *op)
2552 {
2553         const struct of_device_id *match;
2554         struct fore200e *fore200e;
2555         static int index = 0;
2556         int err;
2557
2558         match = of_match_device(fore200e_sba_match, &op->dev);
2559         if (!match)
2560                 return -EINVAL;
2561
2562         fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2563         if (!fore200e)
2564                 return -ENOMEM;
2565
2566         fore200e->bus = &fore200e_sbus_ops;
2567         fore200e->dev = &op->dev;
2568         fore200e->irq = op->archdata.irqs[0];
2569         fore200e->phys_base = op->resource[0].start;
2570
2571         sprintf(fore200e->name, "SBA-200E-%d", index);
2572
2573         err = fore200e_init(fore200e, &op->dev);
2574         if (err < 0) {
2575                 fore200e_shutdown(fore200e);
2576                 kfree(fore200e);
2577                 return err;
2578         }
2579
2580         index++;
2581         dev_set_drvdata(&op->dev, fore200e);
2582
2583         return 0;
2584 }
2585
2586 static int fore200e_sba_remove(struct platform_device *op)
2587 {
2588         struct fore200e *fore200e = dev_get_drvdata(&op->dev);
2589
2590         fore200e_shutdown(fore200e);
2591         kfree(fore200e);
2592
2593         return 0;
2594 }
2595
2596 static const struct of_device_id fore200e_sba_match[] = {
2597         {
2598                 .name = SBA200E_PROM_NAME,
2599         },
2600         {},
2601 };
2602 MODULE_DEVICE_TABLE(of, fore200e_sba_match);
2603
2604 static struct platform_driver fore200e_sba_driver = {
2605         .driver = {
2606                 .name = "fore_200e",
2607                 .of_match_table = fore200e_sba_match,
2608         },
2609         .probe          = fore200e_sba_probe,
2610         .remove         = fore200e_sba_remove,
2611 };
2612 #endif
2613
2614 #ifdef CONFIG_PCI
2615 static int fore200e_pca_detect(struct pci_dev *pci_dev,
2616                                const struct pci_device_id *pci_ent)
2617 {
2618     struct fore200e* fore200e;
2619     int err = 0;
2620     static int index = 0;
2621
2622     if (pci_enable_device(pci_dev)) {
2623         err = -EINVAL;
2624         goto out;
2625     }
2626
2627     if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) {
2628         err = -EINVAL;
2629         goto out;
2630     }
2631
2632     fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2633     if (fore200e == NULL) {
2634         err = -ENOMEM;
2635         goto out_disable;
2636     }
2637
2638     fore200e->bus       = &fore200e_pci_ops;
2639     fore200e->dev       = &pci_dev->dev;
2640     fore200e->irq       = pci_dev->irq;
2641     fore200e->phys_base = pci_resource_start(pci_dev, 0);
2642
2643     sprintf(fore200e->name, "PCA-200E-%d", index - 1);
2644
2645     pci_set_master(pci_dev);
2646
2647     printk(FORE200E "device PCA-200E found at 0x%lx, IRQ %s\n",
2648            fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2649
2650     sprintf(fore200e->name, "PCA-200E-%d", index);
2651
2652     err = fore200e_init(fore200e, &pci_dev->dev);
2653     if (err < 0) {
2654         fore200e_shutdown(fore200e);
2655         goto out_free;
2656     }
2657
2658     ++index;
2659     pci_set_drvdata(pci_dev, fore200e);
2660
2661 out:
2662     return err;
2663
2664 out_free:
2665     kfree(fore200e);
2666 out_disable:
2667     pci_disable_device(pci_dev);
2668     goto out;
2669 }
2670
2671
2672 static void fore200e_pca_remove_one(struct pci_dev *pci_dev)
2673 {
2674     struct fore200e *fore200e;
2675
2676     fore200e = pci_get_drvdata(pci_dev);
2677
2678     fore200e_shutdown(fore200e);
2679     kfree(fore200e);
2680     pci_disable_device(pci_dev);
2681 }
2682
2683
2684 static const struct pci_device_id fore200e_pca_tbl[] = {
2685     { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_PCA200E, PCI_ANY_ID, PCI_ANY_ID },
2686     { 0, }
2687 };
2688
2689 MODULE_DEVICE_TABLE(pci, fore200e_pca_tbl);
2690
2691 static struct pci_driver fore200e_pca_driver = {
2692     .name =     "fore_200e",
2693     .probe =    fore200e_pca_detect,
2694     .remove =   fore200e_pca_remove_one,
2695     .id_table = fore200e_pca_tbl,
2696 };
2697 #endif
2698
2699 static int __init fore200e_module_init(void)
2700 {
2701         int err = 0;
2702
2703         printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
2704
2705 #ifdef CONFIG_SBUS
2706         err = platform_driver_register(&fore200e_sba_driver);
2707         if (err)
2708                 return err;
2709 #endif
2710
2711 #ifdef CONFIG_PCI
2712         err = pci_register_driver(&fore200e_pca_driver);
2713 #endif
2714
2715 #ifdef CONFIG_SBUS
2716         if (err)
2717                 platform_driver_unregister(&fore200e_sba_driver);
2718 #endif
2719
2720         return err;
2721 }
2722
2723 static void __exit fore200e_module_cleanup(void)
2724 {
2725 #ifdef CONFIG_PCI
2726         pci_unregister_driver(&fore200e_pca_driver);
2727 #endif
2728 #ifdef CONFIG_SBUS
2729         platform_driver_unregister(&fore200e_sba_driver);
2730 #endif
2731 }
2732
2733 static int
2734 fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
2735 {
2736     struct fore200e*     fore200e  = FORE200E_DEV(dev);
2737     struct fore200e_vcc* fore200e_vcc;
2738     struct atm_vcc*      vcc;
2739     int                  i, len, left = *pos;
2740     unsigned long        flags;
2741
2742     if (!left--) {
2743
2744         if (fore200e_getstats(fore200e) < 0)
2745             return -EIO;
2746
2747         len = sprintf(page,"\n"
2748                        " device:\n"
2749                        "   internal name:\t\t%s\n", fore200e->name);
2750
2751         /* print bus-specific information */
2752         if (fore200e->bus->proc_read)
2753             len += fore200e->bus->proc_read(fore200e, page + len);
2754
2755         len += sprintf(page + len,
2756                 "   interrupt line:\t\t%s\n"
2757                 "   physical base address:\t0x%p\n"
2758                 "   virtual base address:\t0x%p\n"
2759                 "   factory address (ESI):\t%pM\n"
2760                 "   board serial number:\t\t%d\n\n",
2761                 fore200e_irq_itoa(fore200e->irq),
2762                 (void*)fore200e->phys_base,
2763                 fore200e->virt_base,
2764                 fore200e->esi,
2765                 fore200e->esi[4] * 256 + fore200e->esi[5]);
2766
2767         return len;
2768     }
2769
2770     if (!left--)
2771         return sprintf(page,
2772                        "   free small bufs, scheme 1:\t%d\n"
2773                        "   free large bufs, scheme 1:\t%d\n"
2774                        "   free small bufs, scheme 2:\t%d\n"
2775                        "   free large bufs, scheme 2:\t%d\n",
2776                        fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2777                        fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2778                        fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2779                        fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2780
2781     if (!left--) {
2782         u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2783
2784         len = sprintf(page,"\n\n"
2785                       " cell processor:\n"
2786                       "   heartbeat state:\t\t");
2787
2788         if (hb >> 16 != 0xDEAD)
2789             len += sprintf(page + len, "0x%08x\n", hb);
2790         else
2791             len += sprintf(page + len, "*** FATAL ERROR %04x ***\n", hb & 0xFFFF);
2792
2793         return len;
2794     }
2795
2796     if (!left--) {
2797         static const char* media_name[] = {
2798             "unshielded twisted pair",
2799             "multimode optical fiber ST",
2800             "multimode optical fiber SC",
2801             "single-mode optical fiber ST",
2802             "single-mode optical fiber SC",
2803             "unknown"
2804         };
2805
2806         static const char* oc3_mode[] = {
2807             "normal operation",
2808             "diagnostic loopback",
2809             "line loopback",
2810             "unknown"
2811         };
2812
2813         u32 fw_release     = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2814         u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2815         u32 oc3_revision   = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2816         u32 media_index    = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2817         u32 oc3_index;
2818
2819         if (media_index > 4)
2820                 media_index = 5;
2821
2822         switch (fore200e->loop_mode) {
2823             case ATM_LM_NONE:    oc3_index = 0;
2824                                  break;
2825             case ATM_LM_LOC_PHY: oc3_index = 1;
2826                                  break;
2827             case ATM_LM_RMT_PHY: oc3_index = 2;
2828                                  break;
2829             default:             oc3_index = 3;
2830         }
2831
2832         return sprintf(page,
2833                        "   firmware release:\t\t%d.%d.%d\n"
2834                        "   monitor release:\t\t%d.%d\n"
2835                        "   media type:\t\t\t%s\n"
2836                        "   OC-3 revision:\t\t0x%x\n"
2837                        "   OC-3 mode:\t\t\t%s",
2838                        fw_release >> 16, fw_release << 16 >> 24,  fw_release << 24 >> 24,
2839                        mon960_release >> 16, mon960_release << 16 >> 16,
2840                        media_name[ media_index ],
2841                        oc3_revision,
2842                        oc3_mode[ oc3_index ]);
2843     }
2844
2845     if (!left--) {
2846         struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2847
2848         return sprintf(page,
2849                        "\n\n"
2850                        " monitor:\n"
2851                        "   version number:\t\t%d\n"
2852                        "   boot status word:\t\t0x%08x\n",
2853                        fore200e->bus->read(&cp_monitor->mon_version),
2854                        fore200e->bus->read(&cp_monitor->bstat));
2855     }
2856
2857     if (!left--)
2858         return sprintf(page,
2859                        "\n"
2860                        " device statistics:\n"
2861                        "  4b5b:\n"
2862                        "     crc_header_errors:\t\t%10u\n"
2863                        "     framing_errors:\t\t%10u\n",
2864                        be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2865                        be32_to_cpu(fore200e->stats->phy.framing_errors));
2866
2867     if (!left--)
2868         return sprintf(page, "\n"
2869                        "  OC-3:\n"
2870                        "     section_bip8_errors:\t%10u\n"
2871                        "     path_bip8_errors:\t\t%10u\n"
2872                        "     line_bip24_errors:\t\t%10u\n"
2873                        "     line_febe_errors:\t\t%10u\n"
2874                        "     path_febe_errors:\t\t%10u\n"
2875                        "     corr_hcs_errors:\t\t%10u\n"
2876                        "     ucorr_hcs_errors:\t\t%10u\n",
2877                        be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2878                        be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2879                        be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2880                        be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2881                        be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2882                        be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2883                        be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
2884
2885     if (!left--)
2886         return sprintf(page,"\n"
2887                        "   ATM:\t\t\t\t     cells\n"
2888                        "     TX:\t\t\t%10u\n"
2889                        "     RX:\t\t\t%10u\n"
2890                        "     vpi out of range:\t\t%10u\n"
2891                        "     vpi no conn:\t\t%10u\n"
2892                        "     vci out of range:\t\t%10u\n"
2893                        "     vci no conn:\t\t%10u\n",
2894                        be32_to_cpu(fore200e->stats->atm.cells_transmitted),
2895                        be32_to_cpu(fore200e->stats->atm.cells_received),
2896                        be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
2897                        be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
2898                        be32_to_cpu(fore200e->stats->atm.vci_bad_range),
2899                        be32_to_cpu(fore200e->stats->atm.vci_no_conn));
2900
2901     if (!left--)
2902         return sprintf(page,"\n"
2903                        "   AAL0:\t\t\t     cells\n"
2904                        "     TX:\t\t\t%10u\n"
2905                        "     RX:\t\t\t%10u\n"
2906                        "     dropped:\t\t\t%10u\n",
2907                        be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
2908                        be32_to_cpu(fore200e->stats->aal0.cells_received),
2909                        be32_to_cpu(fore200e->stats->aal0.cells_dropped));
2910
2911     if (!left--)
2912         return sprintf(page,"\n"
2913                        "   AAL3/4:\n"
2914                        "     SAR sublayer:\t\t     cells\n"
2915                        "       TX:\t\t\t%10u\n"
2916                        "       RX:\t\t\t%10u\n"
2917                        "       dropped:\t\t\t%10u\n"
2918                        "       CRC errors:\t\t%10u\n"
2919                        "       protocol errors:\t\t%10u\n\n"
2920                        "     CS  sublayer:\t\t      PDUs\n"
2921                        "       TX:\t\t\t%10u\n"
2922                        "       RX:\t\t\t%10u\n"
2923                        "       dropped:\t\t\t%10u\n"
2924                        "       protocol errors:\t\t%10u\n",
2925                        be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
2926                        be32_to_cpu(fore200e->stats->aal34.cells_received),
2927                        be32_to_cpu(fore200e->stats->aal34.cells_dropped),
2928                        be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
2929                        be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
2930                        be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
2931                        be32_to_cpu(fore200e->stats->aal34.cspdus_received),
2932                        be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
2933                        be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
2934
2935     if (!left--)
2936         return sprintf(page,"\n"
2937                        "   AAL5:\n"
2938                        "     SAR sublayer:\t\t     cells\n"
2939                        "       TX:\t\t\t%10u\n"
2940                        "       RX:\t\t\t%10u\n"
2941                        "       dropped:\t\t\t%10u\n"
2942                        "       congestions:\t\t%10u\n\n"
2943                        "     CS  sublayer:\t\t      PDUs\n"
2944                        "       TX:\t\t\t%10u\n"
2945                        "       RX:\t\t\t%10u\n"
2946                        "       dropped:\t\t\t%10u\n"
2947                        "       CRC errors:\t\t%10u\n"
2948                        "       protocol errors:\t\t%10u\n",
2949                        be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
2950                        be32_to_cpu(fore200e->stats->aal5.cells_received),
2951                        be32_to_cpu(fore200e->stats->aal5.cells_dropped),
2952                        be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
2953                        be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
2954                        be32_to_cpu(fore200e->stats->aal5.cspdus_received),
2955                        be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
2956                        be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
2957                        be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
2958
2959     if (!left--)
2960         return sprintf(page,"\n"
2961                        "   AUX:\t\t       allocation failures\n"
2962                        "     small b1:\t\t\t%10u\n"
2963                        "     large b1:\t\t\t%10u\n"
2964                        "     small b2:\t\t\t%10u\n"
2965                        "     large b2:\t\t\t%10u\n"
2966                        "     RX PDUs:\t\t\t%10u\n"
2967                        "     TX PDUs:\t\t\t%10lu\n",
2968                        be32_to_cpu(fore200e->stats->aux.small_b1_failed),
2969                        be32_to_cpu(fore200e->stats->aux.large_b1_failed),
2970                        be32_to_cpu(fore200e->stats->aux.small_b2_failed),
2971                        be32_to_cpu(fore200e->stats->aux.large_b2_failed),
2972                        be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
2973                        fore200e->tx_sat);
2974
2975     if (!left--)
2976         return sprintf(page,"\n"
2977                        " receive carrier:\t\t\t%s\n",
2978                        fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
2979
2980     if (!left--) {
2981         return sprintf(page,"\n"
2982                        " VCCs:\n  address   VPI VCI   AAL "
2983                        "TX PDUs   TX min/max size  RX PDUs   RX min/max size\n");
2984     }
2985
2986     for (i = 0; i < NBR_CONNECT; i++) {
2987
2988         vcc = fore200e->vc_map[i].vcc;
2989
2990         if (vcc == NULL)
2991             continue;
2992
2993         spin_lock_irqsave(&fore200e->q_lock, flags);
2994
2995         if (vcc && test_bit(ATM_VF_READY, &vcc->flags) && !left--) {
2996
2997             fore200e_vcc = FORE200E_VCC(vcc);
2998             ASSERT(fore200e_vcc);
2999
3000             len = sprintf(page,
3001                           "  %pK  %03d %05d %1d   %09lu %05d/%05d      %09lu %05d/%05d\n",
3002                           vcc,
3003                           vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
3004                           fore200e_vcc->tx_pdu,
3005                           fore200e_vcc->tx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->tx_min_pdu,
3006                           fore200e_vcc->tx_max_pdu,
3007                           fore200e_vcc->rx_pdu,
3008                           fore200e_vcc->rx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->rx_min_pdu,
3009                           fore200e_vcc->rx_max_pdu);
3010
3011             spin_unlock_irqrestore(&fore200e->q_lock, flags);
3012             return len;
3013         }
3014
3015         spin_unlock_irqrestore(&fore200e->q_lock, flags);
3016     }
3017
3018     return 0;
3019 }
3020
3021 module_init(fore200e_module_init);
3022 module_exit(fore200e_module_cleanup);
3023
3024
3025 static const struct atmdev_ops fore200e_ops = {
3026         .open       = fore200e_open,
3027         .close      = fore200e_close,
3028         .ioctl      = fore200e_ioctl,
3029         .getsockopt = fore200e_getsockopt,
3030         .setsockopt = fore200e_setsockopt,
3031         .send       = fore200e_send,
3032         .change_qos = fore200e_change_qos,
3033         .proc_read  = fore200e_proc_read,
3034         .owner      = THIS_MODULE
3035 };
3036
3037 MODULE_LICENSE("GPL");
3038 #ifdef CONFIG_PCI
3039 #ifdef __LITTLE_ENDIAN__
3040 MODULE_FIRMWARE("pca200e.bin");
3041 #else
3042 MODULE_FIRMWARE("pca200e_ecd.bin2");
3043 #endif
3044 #endif /* CONFIG_PCI */
3045 #ifdef CONFIG_SBUS
3046 MODULE_FIRMWARE("sba200e_ecd.bin2");
3047 #endif