drivers/atm/fore200e.c

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