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 <linux/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) + 1) % (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 fore200e_pca_map(struct fore200e* fore200e)
 531 {
 532     DPRINTK(2, "device %s being mapped in memory\n", fore200e->name);
 533
 534     fore200e->virt_base = ioremap(fore200e->phys_base, PCA200E_IOSPACE_LENGTH);
 535
 536     if (fore200e->virt_base == NULL) {
 537         printk(FORE200E "can't map device %s\n", fore200e->name);
 538         return -EFAULT;
 539     }
 540
 541     DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
 542
 543     /* gain access to the PCA specific registers  */
 544     fore200e->regs.pca.hcr = fore200e->virt_base + PCA200E_HCR_OFFSET;
 545     fore200e->regs.pca.imr = fore200e->virt_base + PCA200E_IMR_OFFSET;
 546     fore200e->regs.pca.psr = fore200e->virt_base + PCA200E_PSR_OFFSET;
 547
 548     fore200e->state = FORE200E_STATE_MAP;
 549     return 0;
 550 }
 551
 552
 553 static void
 554 fore200e_pca_unmap(struct fore200e* fore200e)
 555 {
 556     DPRINTK(2, "device %s being unmapped from memory\n", fore200e->name);
 557
 558     if (fore200e->virt_base != NULL)
 559         iounmap(fore200e->virt_base);
 560 }
 561
 562
 563 static int fore200e_pca_configure(struct fore200e *fore200e)
 564 {
 565     struct pci_dev* pci_dev = (struct pci_dev*)fore200e->bus_dev;
 566     u8              master_ctrl, latency;
 567
 568     DPRINTK(2, "device %s being configured\n", fore200e->name);
 569
 570     if ((pci_dev->irq == 0) || (pci_dev->irq == 0xFF)) {
 571         printk(FORE200E "incorrect IRQ setting - misconfigured PCI-PCI bridge?\n");
 572         return -EIO;
 573     }
 574
 575     pci_read_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, &master_ctrl);
 576
 577     master_ctrl = master_ctrl
 578 #if defined(__BIG_ENDIAN)
 579         /* request the PCA board to convert the endianess of slave RAM accesses */
 580         | PCA200E_CTRL_CONVERT_ENDIAN
 581 #endif
 582 #if 0
 583         | PCA200E_CTRL_DIS_CACHE_RD
 584         | PCA200E_CTRL_DIS_WRT_INVAL
 585         | PCA200E_CTRL_ENA_CONT_REQ_MODE
 586         | PCA200E_CTRL_2_CACHE_WRT_INVAL
 587 #endif
 588         | PCA200E_CTRL_LARGE_PCI_BURSTS;
 589
 590     pci_write_config_byte(pci_dev, PCA200E_PCI_MASTER_CTRL, master_ctrl);
 591
 592     /* raise latency from 32 (default) to 192, as this seems to prevent NIC
 593        lockups (under heavy rx loads) due to continuous 'FIFO OUT full' condition.
 594        this may impact the performances of other PCI devices on the same bus, though */
 595     latency = 192;
 596     pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
 597
 598     fore200e->state = FORE200E_STATE_CONFIGURE;
 599     return 0;
 600 }
 601
 602
 603 static int __init
 604 fore200e_pca_prom_read(struct fore200e* fore200e, struct prom_data* prom)
 605 {
 606     struct host_cmdq*       cmdq  = &fore200e->host_cmdq;
 607     struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];
 608     struct prom_opcode      opcode;
 609     int                     ok;
 610     u32                     prom_dma;
 611
 612     FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);
 613
 614     opcode.opcode = OPCODE_GET_PROM;
 615     opcode.pad    = 0;
 616
 617     prom_dma = fore200e->bus->dma_map(fore200e, prom, sizeof(struct prom_data), DMA_FROM_DEVICE);
 618
 619     fore200e->bus->write(prom_dma, &entry->cp_entry->cmd.prom_block.prom_haddr);
 620
 621     *entry->status = STATUS_PENDING;
 622
 623     fore200e->bus->write(*(u32*)&opcode, (u32 __iomem *)&entry->cp_entry->cmd.prom_block.opcode);
 624
 625     ok = fore200e_poll(fore200e, entry->status, STATUS_COMPLETE, 400);
 626
 627     *entry->status = STATUS_FREE;
 628
 629     fore200e->bus->dma_unmap(fore200e, prom_dma, sizeof(struct prom_data), DMA_FROM_DEVICE);
 630
 631     if (ok == 0) {
 632         printk(FORE200E "unable to get PROM data from device %s\n", fore200e->name);
 633         return -EIO;
 634     }
 635
 636 #if defined(__BIG_ENDIAN)
 637
 638 #define swap_here(addr) (*((u32*)(addr)) = swab32( *((u32*)(addr)) ))
 639
 640     /* MAC address is stored as little-endian */
 641     swap_here(&prom->mac_addr[0]);
 642     swap_here(&prom->mac_addr[4]);
 643 #endif
 644
 645     return 0;
 646 }
 647
 648
 649 static int
 650 fore200e_pca_proc_read(struct fore200e* fore200e, char *page)
 651 {
 652     struct pci_dev* pci_dev = (struct pci_dev*)fore200e->bus_dev;
 653
 654     return sprintf(page, "   PCI bus/slot/function:\t%d/%d/%d\n",
 655                    pci_dev->bus->number, PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn));
 656 }
 657
 658 #endif /* CONFIG_PCI */
 659
 660
 661 #ifdef CONFIG_SBUS
 662
 663 static u32 fore200e_sba_read(volatile u32 __iomem *addr)
 664 {
 665     return sbus_readl(addr);
 666 }
 667
 668 static void fore200e_sba_write(u32 val, volatile u32 __iomem *addr)
 669 {
 670     sbus_writel(val, addr);
 671 }
 672
 673 static u32 fore200e_sba_dma_map(struct fore200e *fore200e, void* virt_addr, int size, int direction)
 674 {
 675         struct platform_device *op = fore200e->bus_dev;
 676         u32 dma_addr;
 677
 678         dma_addr = dma_map_single(&op->dev, virt_addr, size, direction);
 679
 680         DPRINTK(3, "SBUS DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d --> dma_addr = 0x%08x\n",
 681                 virt_addr, size, direction, dma_addr);
 682
 683         return dma_addr;
 684 }
 685
 686 static void fore200e_sba_dma_unmap(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
 687 {
 688         struct platform_device *op = fore200e->bus_dev;
 689
 690         DPRINTK(3, "SBUS DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d,\n",
 691                 dma_addr, size, direction);
 692
 693         dma_unmap_single(&op->dev, dma_addr, size, direction);
 694 }
 695
 696 static void fore200e_sba_dma_sync_for_cpu(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
 697 {
 698         struct platform_device *op = fore200e->bus_dev;
 699
 700         DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
 701
 702         dma_sync_single_for_cpu(&op->dev, dma_addr, size, direction);
 703 }
 704
 705 static void fore200e_sba_dma_sync_for_device(struct fore200e *fore200e, u32 dma_addr, int size, int direction)
 706 {
 707         struct platform_device *op = fore200e->bus_dev;
 708
 709         DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction);
 710
 711         dma_sync_single_for_device(&op->dev, dma_addr, size, direction);
 712 }
 713
 714 /* Allocate a DVMA consistent chunk of memory intended to act as a communication mechanism
 715  * (to hold descriptors, status, queues, etc.) shared by the driver and the adapter.
 716  */
 717 static int fore200e_sba_dma_chunk_alloc(struct fore200e *fore200e, struct chunk *chunk,
 718                                         int size, int nbr, int alignment)
 719 {
 720         struct platform_device *op = fore200e->bus_dev;
 721
 722         chunk->alloc_size = chunk->align_size = size * nbr;
 723
 724         /* returned chunks are page-aligned */
 725         chunk->alloc_addr = dma_alloc_coherent(&op->dev, chunk->alloc_size,
 726                                                &chunk->dma_addr, GFP_ATOMIC);
 727
 728         if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0))
 729                 return -ENOMEM;
 730
 731         chunk->align_addr = chunk->alloc_addr;
 732
 733         return 0;
 734 }
 735
 736 /* free a DVMA consistent chunk of memory */
 737 static void fore200e_sba_dma_chunk_free(struct fore200e *fore200e, struct chunk *chunk)
 738 {
 739         struct platform_device *op = fore200e->bus_dev;
 740
 741         dma_free_coherent(&op->dev, chunk->alloc_size,
 742                           chunk->alloc_addr, chunk->dma_addr);
 743 }
 744
 745 static void fore200e_sba_irq_enable(struct fore200e *fore200e)
 746 {
 747         u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
 748         fore200e->bus->write(hcr | SBA200E_HCR_INTR_ENA, fore200e->regs.sba.hcr);
 749 }
 750
 751 static int fore200e_sba_irq_check(struct fore200e *fore200e)
 752 {
 753         return fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_INTR_REQ;
 754 }
 755
 756 static void fore200e_sba_irq_ack(struct fore200e *fore200e)
 757 {
 758         u32 hcr = fore200e->bus->read(fore200e->regs.sba.hcr) & SBA200E_HCR_STICKY;
 759         fore200e->bus->write(hcr | SBA200E_HCR_INTR_CLR, fore200e->regs.sba.hcr);
 760 }
 761
 762 static void fore200e_sba_reset(struct fore200e *fore200e)
 763 {
 764         fore200e->bus->write(SBA200E_HCR_RESET, fore200e->regs.sba.hcr);
 765         fore200e_spin(10);
 766         fore200e->bus->write(0, fore200e->regs.sba.hcr);
 767 }
 768
 769 static int __init fore200e_sba_map(struct fore200e *fore200e)
 770 {
 771         struct platform_device *op = fore200e->bus_dev;
 772         unsigned int bursts;
 773
 774         /* gain access to the SBA specific registers  */
 775         fore200e->regs.sba.hcr = of_ioremap(&op->resource[0], 0, SBA200E_HCR_LENGTH, "SBA HCR");
 776         fore200e->regs.sba.bsr = of_ioremap(&op->resource[1], 0, SBA200E_BSR_LENGTH, "SBA BSR");
 777         fore200e->regs.sba.isr = of_ioremap(&op->resource[2], 0, SBA200E_ISR_LENGTH, "SBA ISR");
 778         fore200e->virt_base    = of_ioremap(&op->resource[3], 0, SBA200E_RAM_LENGTH, "SBA RAM");
 779
 780         if (!fore200e->virt_base) {
 781                 printk(FORE200E "unable to map RAM of device %s\n", fore200e->name);
 782                 return -EFAULT;
 783         }
 784
 785         DPRINTK(1, "device %s mapped to 0x%p\n", fore200e->name, fore200e->virt_base);
 786
 787         fore200e->bus->write(0x02, fore200e->regs.sba.isr); /* XXX hardwired interrupt level */
 788
 789         /* get the supported DVMA burst sizes */
 790         bursts = of_getintprop_default(op->dev.of_node->parent, "burst-sizes", 0x00);
 791
 792         if (sbus_can_dma_64bit())
 793                 sbus_set_sbus64(&op->dev, bursts);
 794
 795         fore200e->state = FORE200E_STATE_MAP;
 796         return 0;
 797 }
 798
 799 static void fore200e_sba_unmap(struct fore200e *fore200e)
 800 {
 801         struct platform_device *op = fore200e->bus_dev;
 802
 803         of_iounmap(&op->resource[0], fore200e->regs.sba.hcr, SBA200E_HCR_LENGTH);
 804         of_iounmap(&op->resource[1], fore200e->regs.sba.bsr, SBA200E_BSR_LENGTH);
 805         of_iounmap(&op->resource[2], fore200e->regs.sba.isr, SBA200E_ISR_LENGTH);
 806         of_iounmap(&op->resource[3], fore200e->virt_base,    SBA200E_RAM_LENGTH);
 807 }
 808
 809 static int __init fore200e_sba_configure(struct fore200e *fore200e)
 810 {
 811         fore200e->state = FORE200E_STATE_CONFIGURE;
 812         return 0;
 813 }
 814
 815 static int __init fore200e_sba_prom_read(struct fore200e *fore200e, struct prom_data *prom)
 816 {
 817         struct platform_device *op = fore200e->bus_dev;
 818         const u8 *prop;
 819         int len;
 820
 821         prop = of_get_property(op->dev.of_node, "madaddrlo2", &len);
 822         if (!prop)
 823                 return -ENODEV;
 824         memcpy(&prom->mac_addr[4], prop, 4);
 825
 826         prop = of_get_property(op->dev.of_node, "madaddrhi4", &len);
 827         if (!prop)
 828                 return -ENODEV;
 829         memcpy(&prom->mac_addr[2], prop, 4);
 830
 831         prom->serial_number = of_getintprop_default(op->dev.of_node,
 832                                                     "serialnumber", 0);
 833         prom->hw_revision = of_getintprop_default(op->dev.of_node,
 834                                                   "promversion", 0);
 835
 836         return 0;
 837 }
 838
 839 static int fore200e_sba_proc_read(struct fore200e *fore200e, char *page)
 840 {
 841         struct platform_device *op = fore200e->bus_dev;
 842         const struct linux_prom_registers *regs;
 843
 844         regs = of_get_property(op->dev.of_node, "reg", NULL);
 845
 846         return sprintf(page, "   SBUS slot/device:\t\t%d/'%s'\n",
 847                        (regs ? regs->which_io : 0), op->dev.of_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, unsigned 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 fore200e_irq_request(struct fore200e *fore200e)
2030 {
2031     if (request_irq(fore200e->irq, fore200e_interrupt, IRQF_SHARED, fore200e->name, fore200e->atm_dev) < 0) {
2032
2033         printk(FORE200E "unable to reserve IRQ %s for device %s\n",
2034                fore200e_irq_itoa(fore200e->irq), fore200e->name);
2035         return -EBUSY;
2036     }
2037
2038     printk(FORE200E "IRQ %s reserved for device %s\n",
2039            fore200e_irq_itoa(fore200e->irq), fore200e->name);
2040
2041 #ifdef FORE200E_USE_TASKLET
2042     tasklet_init(&fore200e->tx_tasklet, fore200e_tx_tasklet, (unsigned long)fore200e);
2043     tasklet_init(&fore200e->rx_tasklet, fore200e_rx_tasklet, (unsigned long)fore200e);
2044 #endif
2045
2046     fore200e->state = FORE200E_STATE_IRQ;
2047     return 0;
2048 }
2049
2050
2051 static int fore200e_get_esi(struct fore200e *fore200e)
2052 {
2053     struct prom_data* prom = kzalloc(sizeof(struct prom_data), GFP_KERNEL | GFP_DMA);
2054     int ok, i;
2055
2056     if (!prom)
2057         return -ENOMEM;
2058
2059     ok = fore200e->bus->prom_read(fore200e, prom);
2060     if (ok < 0) {
2061         kfree(prom);
2062         return -EBUSY;
2063     }
2064
2065     printk(FORE200E "device %s, rev. %c, S/N: %d, ESI: %pM\n",
2066            fore200e->name,
2067            (prom->hw_revision & 0xFF) + '@',    /* probably meaningless with SBA boards */
2068            prom->serial_number & 0xFFFF, &prom->mac_addr[2]);
2069
2070     for (i = 0; i < ESI_LEN; i++) {
2071         fore200e->esi[ i ] = fore200e->atm_dev->esi[ i ] = prom->mac_addr[ i + 2 ];
2072     }
2073
2074     kfree(prom);
2075
2076     return 0;
2077 }
2078
2079
2080 static int fore200e_alloc_rx_buf(struct fore200e *fore200e)
2081 {
2082     int scheme, magn, nbr, size, i;
2083
2084     struct host_bsq* bsq;
2085     struct buffer*   buffer;
2086
2087     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2088         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2089
2090             bsq = &fore200e->host_bsq[ scheme ][ magn ];
2091
2092             nbr  = fore200e_rx_buf_nbr[ scheme ][ magn ];
2093             size = fore200e_rx_buf_size[ scheme ][ magn ];
2094
2095             DPRINTK(2, "rx buffers %d / %d are being allocated\n", scheme, magn);
2096
2097             /* allocate the array of receive buffers */
2098             buffer = bsq->buffer = kzalloc(nbr * sizeof(struct buffer), GFP_KERNEL);
2099
2100             if (buffer == NULL)
2101                 return -ENOMEM;
2102
2103             bsq->freebuf = NULL;
2104
2105             for (i = 0; i < nbr; i++) {
2106
2107                 buffer[ i ].scheme = scheme;
2108                 buffer[ i ].magn   = magn;
2109 #ifdef FORE200E_BSQ_DEBUG
2110                 buffer[ i ].index  = i;
2111                 buffer[ i ].supplied = 0;
2112 #endif
2113
2114                 /* allocate the receive buffer body */
2115                 if (fore200e_chunk_alloc(fore200e,
2116                                          &buffer[ i ].data, size, fore200e->bus->buffer_alignment,
2117                                          DMA_FROM_DEVICE) < 0) {
2118
2119                     while (i > 0)
2120                         fore200e_chunk_free(fore200e, &buffer[ --i ].data);
2121                     kfree(buffer);
2122
2123                     return -ENOMEM;
2124                 }
2125
2126                 /* insert the buffer into the free buffer list */
2127                 buffer[ i ].next = bsq->freebuf;
2128                 bsq->freebuf = &buffer[ i ];
2129             }
2130             /* all the buffers are free, initially */
2131             bsq->freebuf_count = nbr;
2132
2133 #ifdef FORE200E_BSQ_DEBUG
2134             bsq_audit(3, bsq, scheme, magn);
2135 #endif
2136         }
2137     }
2138
2139     fore200e->state = FORE200E_STATE_ALLOC_BUF;
2140     return 0;
2141 }
2142
2143
2144 static int fore200e_init_bs_queue(struct fore200e *fore200e)
2145 {
2146     int scheme, magn, i;
2147
2148     struct host_bsq*     bsq;
2149     struct cp_bsq_entry __iomem * cp_entry;
2150
2151     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++) {
2152         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++) {
2153
2154             DPRINTK(2, "buffer supply queue %d / %d is being initialized\n", scheme, magn);
2155
2156             bsq = &fore200e->host_bsq[ scheme ][ magn ];
2157
2158             /* allocate and align the array of status words */
2159             if (fore200e->bus->dma_chunk_alloc(fore200e,
2160                                                &bsq->status,
2161                                                sizeof(enum status),
2162                                                QUEUE_SIZE_BS,
2163                                                fore200e->bus->status_alignment) < 0) {
2164                 return -ENOMEM;
2165             }
2166
2167             /* allocate and align the array of receive buffer descriptors */
2168             if (fore200e->bus->dma_chunk_alloc(fore200e,
2169                                                &bsq->rbd_block,
2170                                                sizeof(struct rbd_block),
2171                                                QUEUE_SIZE_BS,
2172                                                fore200e->bus->descr_alignment) < 0) {
2173
2174                 fore200e->bus->dma_chunk_free(fore200e, &bsq->status);
2175                 return -ENOMEM;
2176             }
2177
2178             /* get the base address of the cp resident buffer supply queue entries */
2179             cp_entry = fore200e->virt_base +
2180                        fore200e->bus->read(&fore200e->cp_queues->cp_bsq[ scheme ][ magn ]);
2181
2182             /* fill the host resident and cp resident buffer supply queue entries */
2183             for (i = 0; i < QUEUE_SIZE_BS; i++) {
2184
2185                 bsq->host_entry[ i ].status =
2186                                      FORE200E_INDEX(bsq->status.align_addr, enum status, i);
2187                 bsq->host_entry[ i ].rbd_block =
2188                                      FORE200E_INDEX(bsq->rbd_block.align_addr, struct rbd_block, i);
2189                 bsq->host_entry[ i ].rbd_block_dma =
2190                                      FORE200E_DMA_INDEX(bsq->rbd_block.dma_addr, struct rbd_block, i);
2191                 bsq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2192
2193                 *bsq->host_entry[ i ].status = STATUS_FREE;
2194
2195                 fore200e->bus->write(FORE200E_DMA_INDEX(bsq->status.dma_addr, enum status, i),
2196                                      &cp_entry[ i ].status_haddr);
2197             }
2198         }
2199     }
2200
2201     fore200e->state = FORE200E_STATE_INIT_BSQ;
2202     return 0;
2203 }
2204
2205
2206 static int fore200e_init_rx_queue(struct fore200e *fore200e)
2207 {
2208     struct host_rxq*     rxq =  &fore200e->host_rxq;
2209     struct cp_rxq_entry __iomem * cp_entry;
2210     int i;
2211
2212     DPRINTK(2, "receive queue is being initialized\n");
2213
2214     /* allocate and align the array of status words */
2215     if (fore200e->bus->dma_chunk_alloc(fore200e,
2216                                        &rxq->status,
2217                                        sizeof(enum status),
2218                                        QUEUE_SIZE_RX,
2219                                        fore200e->bus->status_alignment) < 0) {
2220         return -ENOMEM;
2221     }
2222
2223     /* allocate and align the array of receive PDU descriptors */
2224     if (fore200e->bus->dma_chunk_alloc(fore200e,
2225                                        &rxq->rpd,
2226                                        sizeof(struct rpd),
2227                                        QUEUE_SIZE_RX,
2228                                        fore200e->bus->descr_alignment) < 0) {
2229
2230         fore200e->bus->dma_chunk_free(fore200e, &rxq->status);
2231         return -ENOMEM;
2232     }
2233
2234     /* get the base address of the cp resident rx queue entries */
2235     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_rxq);
2236
2237     /* fill the host resident and cp resident rx entries */
2238     for (i=0; i < QUEUE_SIZE_RX; i++) {
2239
2240         rxq->host_entry[ i ].status =
2241                              FORE200E_INDEX(rxq->status.align_addr, enum status, i);
2242         rxq->host_entry[ i ].rpd =
2243                              FORE200E_INDEX(rxq->rpd.align_addr, struct rpd, i);
2244         rxq->host_entry[ i ].rpd_dma =
2245                              FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i);
2246         rxq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2247
2248         *rxq->host_entry[ i ].status = STATUS_FREE;
2249
2250         fore200e->bus->write(FORE200E_DMA_INDEX(rxq->status.dma_addr, enum status, i),
2251                              &cp_entry[ i ].status_haddr);
2252
2253         fore200e->bus->write(FORE200E_DMA_INDEX(rxq->rpd.dma_addr, struct rpd, i),
2254                              &cp_entry[ i ].rpd_haddr);
2255     }
2256
2257     /* set the head entry of the queue */
2258     rxq->head = 0;
2259
2260     fore200e->state = FORE200E_STATE_INIT_RXQ;
2261     return 0;
2262 }
2263
2264
2265 static int fore200e_init_tx_queue(struct fore200e *fore200e)
2266 {
2267     struct host_txq*     txq =  &fore200e->host_txq;
2268     struct cp_txq_entry __iomem * cp_entry;
2269     int i;
2270
2271     DPRINTK(2, "transmit queue is being initialized\n");
2272
2273     /* allocate and align the array of status words */
2274     if (fore200e->bus->dma_chunk_alloc(fore200e,
2275                                        &txq->status,
2276                                        sizeof(enum status),
2277                                        QUEUE_SIZE_TX,
2278                                        fore200e->bus->status_alignment) < 0) {
2279         return -ENOMEM;
2280     }
2281
2282     /* allocate and align the array of transmit PDU descriptors */
2283     if (fore200e->bus->dma_chunk_alloc(fore200e,
2284                                        &txq->tpd,
2285                                        sizeof(struct tpd),
2286                                        QUEUE_SIZE_TX,
2287                                        fore200e->bus->descr_alignment) < 0) {
2288
2289         fore200e->bus->dma_chunk_free(fore200e, &txq->status);
2290         return -ENOMEM;
2291     }
2292
2293     /* get the base address of the cp resident tx queue entries */
2294     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_txq);
2295
2296     /* fill the host resident and cp resident tx entries */
2297     for (i=0; i < QUEUE_SIZE_TX; i++) {
2298
2299         txq->host_entry[ i ].status =
2300                              FORE200E_INDEX(txq->status.align_addr, enum status, i);
2301         txq->host_entry[ i ].tpd =
2302                              FORE200E_INDEX(txq->tpd.align_addr, struct tpd, i);
2303         txq->host_entry[ i ].tpd_dma  =
2304                              FORE200E_DMA_INDEX(txq->tpd.dma_addr, struct tpd, i);
2305         txq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2306
2307         *txq->host_entry[ i ].status = STATUS_FREE;
2308
2309         fore200e->bus->write(FORE200E_DMA_INDEX(txq->status.dma_addr, enum status, i),
2310                              &cp_entry[ i ].status_haddr);
2311
2312         /* although there is a one-to-one mapping of tx queue entries and tpds,
2313            we do not write here the DMA (physical) base address of each tpd into
2314            the related cp resident entry, because the cp relies on this write
2315            operation to detect that a new pdu has been submitted for tx */
2316     }
2317
2318     /* set the head and tail entries of the queue */
2319     txq->head = 0;
2320     txq->tail = 0;
2321
2322     fore200e->state = FORE200E_STATE_INIT_TXQ;
2323     return 0;
2324 }
2325
2326
2327 static int fore200e_init_cmd_queue(struct fore200e *fore200e)
2328 {
2329     struct host_cmdq*     cmdq =  &fore200e->host_cmdq;
2330     struct cp_cmdq_entry __iomem * cp_entry;
2331     int i;
2332
2333     DPRINTK(2, "command queue is being initialized\n");
2334
2335     /* allocate and align the array of status words */
2336     if (fore200e->bus->dma_chunk_alloc(fore200e,
2337                                        &cmdq->status,
2338                                        sizeof(enum status),
2339                                        QUEUE_SIZE_CMD,
2340                                        fore200e->bus->status_alignment) < 0) {
2341         return -ENOMEM;
2342     }
2343
2344     /* get the base address of the cp resident cmd queue entries */
2345     cp_entry = fore200e->virt_base + fore200e->bus->read(&fore200e->cp_queues->cp_cmdq);
2346
2347     /* fill the host resident and cp resident cmd entries */
2348     for (i=0; i < QUEUE_SIZE_CMD; i++) {
2349
2350         cmdq->host_entry[ i ].status   =
2351                               FORE200E_INDEX(cmdq->status.align_addr, enum status, i);
2352         cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];
2353
2354         *cmdq->host_entry[ i ].status = STATUS_FREE;
2355
2356         fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),
2357                              &cp_entry[ i ].status_haddr);
2358     }
2359
2360     /* set the head entry of the queue */
2361     cmdq->head = 0;
2362
2363     fore200e->state = FORE200E_STATE_INIT_CMDQ;
2364     return 0;
2365 }
2366
2367
2368 static void fore200e_param_bs_queue(struct fore200e *fore200e,
2369                                     enum buffer_scheme scheme,
2370                                     enum buffer_magn magn, int queue_length,
2371                                     int pool_size, int supply_blksize)
2372 {
2373     struct bs_spec __iomem * bs_spec = &fore200e->cp_queues->init.bs_spec[ scheme ][ magn ];
2374
2375     fore200e->bus->write(queue_length,                           &bs_spec->queue_length);
2376     fore200e->bus->write(fore200e_rx_buf_size[ scheme ][ magn ], &bs_spec->buffer_size);
2377     fore200e->bus->write(pool_size,                              &bs_spec->pool_size);
2378     fore200e->bus->write(supply_blksize,                         &bs_spec->supply_blksize);
2379 }
2380
2381
2382 static int fore200e_initialize(struct fore200e *fore200e)
2383 {
2384     struct cp_queues __iomem * cpq;
2385     int               ok, scheme, magn;
2386
2387     DPRINTK(2, "device %s being initialized\n", fore200e->name);
2388
2389     mutex_init(&fore200e->rate_mtx);
2390     spin_lock_init(&fore200e->q_lock);
2391
2392     cpq = fore200e->cp_queues = fore200e->virt_base + FORE200E_CP_QUEUES_OFFSET;
2393
2394     /* enable cp to host interrupts */
2395     fore200e->bus->write(1, &cpq->imask);
2396
2397     if (fore200e->bus->irq_enable)
2398         fore200e->bus->irq_enable(fore200e);
2399
2400     fore200e->bus->write(NBR_CONNECT, &cpq->init.num_connect);
2401
2402     fore200e->bus->write(QUEUE_SIZE_CMD, &cpq->init.cmd_queue_len);
2403     fore200e->bus->write(QUEUE_SIZE_RX,  &cpq->init.rx_queue_len);
2404     fore200e->bus->write(QUEUE_SIZE_TX,  &cpq->init.tx_queue_len);
2405
2406     fore200e->bus->write(RSD_EXTENSION,  &cpq->init.rsd_extension);
2407     fore200e->bus->write(TSD_EXTENSION,  &cpq->init.tsd_extension);
2408
2409     for (scheme = 0; scheme < BUFFER_SCHEME_NBR; scheme++)
2410         for (magn = 0; magn < BUFFER_MAGN_NBR; magn++)
2411             fore200e_param_bs_queue(fore200e, scheme, magn,
2412                                     QUEUE_SIZE_BS,
2413                                     fore200e_rx_buf_nbr[ scheme ][ magn ],
2414                                     RBD_BLK_SIZE);
2415
2416     /* issue the initialize command */
2417     fore200e->bus->write(STATUS_PENDING,    &cpq->init.status);
2418     fore200e->bus->write(OPCODE_INITIALIZE, &cpq->init.opcode);
2419
2420     ok = fore200e_io_poll(fore200e, &cpq->init.status, STATUS_COMPLETE, 3000);
2421     if (ok == 0) {
2422         printk(FORE200E "device %s initialization failed\n", fore200e->name);
2423         return -ENODEV;
2424     }
2425
2426     printk(FORE200E "device %s initialized\n", fore200e->name);
2427
2428     fore200e->state = FORE200E_STATE_INITIALIZE;
2429     return 0;
2430 }
2431
2432
2433 static void fore200e_monitor_putc(struct fore200e *fore200e, char c)
2434 {
2435     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2436
2437 #if 0
2438     printk("%c", c);
2439 #endif
2440     fore200e->bus->write(((u32) c) | FORE200E_CP_MONITOR_UART_AVAIL, &monitor->soft_uart.send);
2441 }
2442
2443
2444 static int fore200e_monitor_getc(struct fore200e *fore200e)
2445 {
2446     struct cp_monitor __iomem * monitor = fore200e->cp_monitor;
2447     unsigned long      timeout = jiffies + msecs_to_jiffies(50);
2448     int                c;
2449
2450     while (time_before(jiffies, timeout)) {
2451
2452         c = (int) fore200e->bus->read(&monitor->soft_uart.recv);
2453
2454         if (c & FORE200E_CP_MONITOR_UART_AVAIL) {
2455
2456             fore200e->bus->write(FORE200E_CP_MONITOR_UART_FREE, &monitor->soft_uart.recv);
2457 #if 0
2458             printk("%c", c & 0xFF);
2459 #endif
2460             return c & 0xFF;
2461         }
2462     }
2463
2464     return -1;
2465 }
2466
2467
2468 static void fore200e_monitor_puts(struct fore200e *fore200e, char *str)
2469 {
2470     while (*str) {
2471
2472         /* the i960 monitor doesn't accept any new character if it has something to say */
2473         while (fore200e_monitor_getc(fore200e) >= 0);
2474
2475         fore200e_monitor_putc(fore200e, *str++);
2476     }
2477
2478     while (fore200e_monitor_getc(fore200e) >= 0);
2479 }
2480
2481 #ifdef __LITTLE_ENDIAN
2482 #define FW_EXT ".bin"
2483 #else
2484 #define FW_EXT "_ecd.bin2"
2485 #endif
2486
2487 static int fore200e_load_and_start_fw(struct fore200e *fore200e)
2488 {
2489     const struct firmware *firmware;
2490     struct device *device;
2491     struct fw_header *fw_header;
2492     const __le32 *fw_data;
2493     u32 fw_size;
2494     u32 __iomem *load_addr;
2495     char buf[48];
2496     int err = -ENODEV;
2497
2498     if (strcmp(fore200e->bus->model_name, "PCA-200E") == 0)
2499         device = &((struct pci_dev *) fore200e->bus_dev)->dev;
2500 #ifdef CONFIG_SBUS
2501     else if (strcmp(fore200e->bus->model_name, "SBA-200E") == 0)
2502         device = &((struct platform_device *) fore200e->bus_dev)->dev;
2503 #endif
2504     else
2505         return err;
2506
2507     sprintf(buf, "%s%s", fore200e->bus->proc_name, FW_EXT);
2508     if ((err = request_firmware(&firmware, buf, device)) < 0) {
2509         printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
2510         return err;
2511     }
2512
2513     fw_data = (__le32 *) firmware->data;
2514     fw_size = firmware->size / sizeof(u32);
2515     fw_header = (struct fw_header *) firmware->data;
2516     load_addr = fore200e->virt_base + le32_to_cpu(fw_header->load_offset);
2517
2518     DPRINTK(2, "device %s firmware being loaded at 0x%p (%d words)\n",
2519             fore200e->name, load_addr, fw_size);
2520
2521     if (le32_to_cpu(fw_header->magic) != FW_HEADER_MAGIC) {
2522         printk(FORE200E "corrupted %s firmware image\n", fore200e->bus->model_name);
2523         goto release;
2524     }
2525
2526     for (; fw_size--; fw_data++, load_addr++)
2527         fore200e->bus->write(le32_to_cpu(*fw_data), load_addr);
2528
2529     DPRINTK(2, "device %s firmware being started\n", fore200e->name);
2530
2531 #if defined(__sparc_v9__)
2532     /* reported to be required by SBA cards on some sparc64 hosts */
2533     fore200e_spin(100);
2534 #endif
2535
2536     sprintf(buf, "\rgo %x\r", le32_to_cpu(fw_header->start_offset));
2537     fore200e_monitor_puts(fore200e, buf);
2538
2539     if (fore200e_io_poll(fore200e, &fore200e->cp_monitor->bstat, BSTAT_CP_RUNNING, 1000) == 0) {
2540         printk(FORE200E "device %s firmware didn't start\n", fore200e->name);
2541         goto release;
2542     }
2543
2544     printk(FORE200E "device %s firmware started\n", fore200e->name);
2545
2546     fore200e->state = FORE200E_STATE_START_FW;
2547     err = 0;
2548
2549 release:
2550     release_firmware(firmware);
2551     return err;
2552 }
2553
2554
2555 static int fore200e_register(struct fore200e *fore200e, struct device *parent)
2556 {
2557     struct atm_dev* atm_dev;
2558
2559     DPRINTK(2, "device %s being registered\n", fore200e->name);
2560
2561     atm_dev = atm_dev_register(fore200e->bus->proc_name, parent, &fore200e_ops,
2562                                -1, NULL);
2563     if (atm_dev == NULL) {
2564         printk(FORE200E "unable to register device %s\n", fore200e->name);
2565         return -ENODEV;
2566     }
2567
2568     atm_dev->dev_data = fore200e;
2569     fore200e->atm_dev = atm_dev;
2570
2571     atm_dev->ci_range.vpi_bits = FORE200E_VPI_BITS;
2572     atm_dev->ci_range.vci_bits = FORE200E_VCI_BITS;
2573
2574     fore200e->available_cell_rate = ATM_OC3_PCR;
2575
2576     fore200e->state = FORE200E_STATE_REGISTER;
2577     return 0;
2578 }
2579
2580
2581 static int fore200e_init(struct fore200e *fore200e, struct device *parent)
2582 {
2583     if (fore200e_register(fore200e, parent) < 0)
2584         return -ENODEV;
2585
2586     if (fore200e->bus->configure(fore200e) < 0)
2587         return -ENODEV;
2588
2589     if (fore200e->bus->map(fore200e) < 0)
2590         return -ENODEV;
2591
2592     if (fore200e_reset(fore200e, 1) < 0)
2593         return -ENODEV;
2594
2595     if (fore200e_load_and_start_fw(fore200e) < 0)
2596         return -ENODEV;
2597
2598     if (fore200e_initialize(fore200e) < 0)
2599         return -ENODEV;
2600
2601     if (fore200e_init_cmd_queue(fore200e) < 0)
2602         return -ENOMEM;
2603
2604     if (fore200e_init_tx_queue(fore200e) < 0)
2605         return -ENOMEM;
2606
2607     if (fore200e_init_rx_queue(fore200e) < 0)
2608         return -ENOMEM;
2609
2610     if (fore200e_init_bs_queue(fore200e) < 0)
2611         return -ENOMEM;
2612
2613     if (fore200e_alloc_rx_buf(fore200e) < 0)
2614         return -ENOMEM;
2615
2616     if (fore200e_get_esi(fore200e) < 0)
2617         return -EIO;
2618
2619     if (fore200e_irq_request(fore200e) < 0)
2620         return -EBUSY;
2621
2622     fore200e_supply(fore200e);
2623
2624     /* all done, board initialization is now complete */
2625     fore200e->state = FORE200E_STATE_COMPLETE;
2626     return 0;
2627 }
2628
2629 #ifdef CONFIG_SBUS
2630 static const struct of_device_id fore200e_sba_match[];
2631 static int fore200e_sba_probe(struct platform_device *op)
2632 {
2633         const struct of_device_id *match;
2634         const struct fore200e_bus *bus;
2635         struct fore200e *fore200e;
2636         static int index = 0;
2637         int err;
2638
2639         match = of_match_device(fore200e_sba_match, &op->dev);
2640         if (!match)
2641                 return -EINVAL;
2642         bus = match->data;
2643
2644         fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2645         if (!fore200e)
2646                 return -ENOMEM;
2647
2648         fore200e->bus = bus;
2649         fore200e->bus_dev = op;
2650         fore200e->irq = op->archdata.irqs[0];
2651         fore200e->phys_base = op->resource[0].start;
2652
2653         sprintf(fore200e->name, "%s-%d", bus->model_name, index);
2654
2655         err = fore200e_init(fore200e, &op->dev);
2656         if (err < 0) {
2657                 fore200e_shutdown(fore200e);
2658                 kfree(fore200e);
2659                 return err;
2660         }
2661
2662         index++;
2663         dev_set_drvdata(&op->dev, fore200e);
2664
2665         return 0;
2666 }
2667
2668 static int fore200e_sba_remove(struct platform_device *op)
2669 {
2670         struct fore200e *fore200e = dev_get_drvdata(&op->dev);
2671
2672         fore200e_shutdown(fore200e);
2673         kfree(fore200e);
2674
2675         return 0;
2676 }
2677
2678 static const struct of_device_id fore200e_sba_match[] = {
2679         {
2680                 .name = SBA200E_PROM_NAME,
2681                 .data = (void *) &fore200e_bus[1],
2682         },
2683         {},
2684 };
2685 MODULE_DEVICE_TABLE(of, fore200e_sba_match);
2686
2687 static struct platform_driver fore200e_sba_driver = {
2688         .driver = {
2689                 .name = "fore_200e",
2690                 .owner = THIS_MODULE,
2691                 .of_match_table = fore200e_sba_match,
2692         },
2693         .probe          = fore200e_sba_probe,
2694         .remove         = fore200e_sba_remove,
2695 };
2696 #endif
2697
2698 #ifdef CONFIG_PCI
2699 static int fore200e_pca_detect(struct pci_dev *pci_dev,
2700                                const struct pci_device_id *pci_ent)
2701 {
2702     const struct fore200e_bus* bus = (struct fore200e_bus*) pci_ent->driver_data;
2703     struct fore200e* fore200e;
2704     int err = 0;
2705     static int index = 0;
2706
2707     if (pci_enable_device(pci_dev)) {
2708         err = -EINVAL;
2709         goto out;
2710     }
2711
2712     fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL);
2713     if (fore200e == NULL) {
2714         err = -ENOMEM;
2715         goto out_disable;
2716     }
2717
2718     fore200e->bus       = bus;
2719     fore200e->bus_dev   = pci_dev;
2720     fore200e->irq       = pci_dev->irq;
2721     fore200e->phys_base = pci_resource_start(pci_dev, 0);
2722
2723     sprintf(fore200e->name, "%s-%d", bus->model_name, index - 1);
2724
2725     pci_set_master(pci_dev);
2726
2727     printk(FORE200E "device %s found at 0x%lx, IRQ %s\n",
2728            fore200e->bus->model_name,
2729            fore200e->phys_base, fore200e_irq_itoa(fore200e->irq));
2730
2731     sprintf(fore200e->name, "%s-%d", bus->model_name, index);
2732
2733     err = fore200e_init(fore200e, &pci_dev->dev);
2734     if (err < 0) {
2735         fore200e_shutdown(fore200e);
2736         goto out_free;
2737     }
2738
2739     ++index;
2740     pci_set_drvdata(pci_dev, fore200e);
2741
2742 out:
2743     return err;
2744
2745 out_free:
2746     kfree(fore200e);
2747 out_disable:
2748     pci_disable_device(pci_dev);
2749     goto out;
2750 }
2751
2752
2753 static void fore200e_pca_remove_one(struct pci_dev *pci_dev)
2754 {
2755     struct fore200e *fore200e;
2756
2757     fore200e = pci_get_drvdata(pci_dev);
2758
2759     fore200e_shutdown(fore200e);
2760     kfree(fore200e);
2761     pci_disable_device(pci_dev);
2762 }
2763
2764
2765 static struct pci_device_id fore200e_pca_tbl[] = {
2766     { PCI_VENDOR_ID_FORE, PCI_DEVICE_ID_FORE_PCA200E, PCI_ANY_ID, PCI_ANY_ID,
2767       0, 0, (unsigned long) &fore200e_bus[0] },
2768     { 0, }
2769 };
2770
2771 MODULE_DEVICE_TABLE(pci, fore200e_pca_tbl);
2772
2773 static struct pci_driver fore200e_pca_driver = {
2774     .name =     "fore_200e",
2775     .probe =    fore200e_pca_detect,
2776     .remove =   fore200e_pca_remove_one,
2777     .id_table = fore200e_pca_tbl,
2778 };
2779 #endif
2780
2781 static int __init fore200e_module_init(void)
2782 {
2783         int err;
2784
2785         printk(FORE200E "FORE Systems 200E-series ATM driver - version " FORE200E_VERSION "\n");
2786
2787 #ifdef CONFIG_SBUS
2788         err = platform_driver_register(&fore200e_sba_driver);
2789         if (err)
2790                 return err;
2791 #endif
2792
2793 #ifdef CONFIG_PCI
2794         err = pci_register_driver(&fore200e_pca_driver);
2795 #endif
2796
2797 #ifdef CONFIG_SBUS
2798         if (err)
2799                 platform_driver_unregister(&fore200e_sba_driver);
2800 #endif
2801
2802         return err;
2803 }
2804
2805 static void __exit fore200e_module_cleanup(void)
2806 {
2807 #ifdef CONFIG_PCI
2808         pci_unregister_driver(&fore200e_pca_driver);
2809 #endif
2810 #ifdef CONFIG_SBUS
2811         platform_driver_unregister(&fore200e_sba_driver);
2812 #endif
2813 }
2814
2815 static int
2816 fore200e_proc_read(struct atm_dev *dev, loff_t* pos, char* page)
2817 {
2818     struct fore200e*     fore200e  = FORE200E_DEV(dev);
2819     struct fore200e_vcc* fore200e_vcc;
2820     struct atm_vcc*      vcc;
2821     int                  i, len, left = *pos;
2822     unsigned long        flags;
2823
2824     if (!left--) {
2825
2826         if (fore200e_getstats(fore200e) < 0)
2827             return -EIO;
2828
2829         len = sprintf(page,"\n"
2830                        " device:\n"
2831                        "   internal name:\t\t%s\n", fore200e->name);
2832
2833         /* print bus-specific information */
2834         if (fore200e->bus->proc_read)
2835             len += fore200e->bus->proc_read(fore200e, page + len);
2836
2837         len += sprintf(page + len,
2838                 "   interrupt line:\t\t%s\n"
2839                 "   physical base address:\t0x%p\n"
2840                 "   virtual base address:\t0x%p\n"
2841                 "   factory address (ESI):\t%pM\n"
2842                 "   board serial number:\t\t%d\n\n",
2843                 fore200e_irq_itoa(fore200e->irq),
2844                 (void*)fore200e->phys_base,
2845                 fore200e->virt_base,
2846                 fore200e->esi,
2847                 fore200e->esi[4] * 256 + fore200e->esi[5]);
2848
2849         return len;
2850     }
2851
2852     if (!left--)
2853         return sprintf(page,
2854                        "   free small bufs, scheme 1:\t%d\n"
2855                        "   free large bufs, scheme 1:\t%d\n"
2856                        "   free small bufs, scheme 2:\t%d\n"
2857                        "   free large bufs, scheme 2:\t%d\n",
2858                        fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_SMALL ].freebuf_count,
2859                        fore200e->host_bsq[ BUFFER_SCHEME_ONE ][ BUFFER_MAGN_LARGE ].freebuf_count,
2860                        fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_SMALL ].freebuf_count,
2861                        fore200e->host_bsq[ BUFFER_SCHEME_TWO ][ BUFFER_MAGN_LARGE ].freebuf_count);
2862
2863     if (!left--) {
2864         u32 hb = fore200e->bus->read(&fore200e->cp_queues->heartbeat);
2865
2866         len = sprintf(page,"\n\n"
2867                       " cell processor:\n"
2868                       "   heartbeat state:\t\t");
2869
2870         if (hb >> 16 != 0xDEAD)
2871             len += sprintf(page + len, "0x%08x\n", hb);
2872         else
2873             len += sprintf(page + len, "*** FATAL ERROR %04x ***\n", hb & 0xFFFF);
2874
2875         return len;
2876     }
2877
2878     if (!left--) {
2879         static const char* media_name[] = {
2880             "unshielded twisted pair",
2881             "multimode optical fiber ST",
2882             "multimode optical fiber SC",
2883             "single-mode optical fiber ST",
2884             "single-mode optical fiber SC",
2885             "unknown"
2886         };
2887
2888         static const char* oc3_mode[] = {
2889             "normal operation",
2890             "diagnostic loopback",
2891             "line loopback",
2892             "unknown"
2893         };
2894
2895         u32 fw_release     = fore200e->bus->read(&fore200e->cp_queues->fw_release);
2896         u32 mon960_release = fore200e->bus->read(&fore200e->cp_queues->mon960_release);
2897         u32 oc3_revision   = fore200e->bus->read(&fore200e->cp_queues->oc3_revision);
2898         u32 media_index    = FORE200E_MEDIA_INDEX(fore200e->bus->read(&fore200e->cp_queues->media_type));
2899         u32 oc3_index;
2900
2901         if (media_index > 4)
2902                 media_index = 5;
2903
2904         switch (fore200e->loop_mode) {
2905             case ATM_LM_NONE:    oc3_index = 0;
2906                                  break;
2907             case ATM_LM_LOC_PHY: oc3_index = 1;
2908                                  break;
2909             case ATM_LM_RMT_PHY: oc3_index = 2;
2910                                  break;
2911             default:             oc3_index = 3;
2912         }
2913
2914         return sprintf(page,
2915                        "   firmware release:\t\t%d.%d.%d\n"
2916                        "   monitor release:\t\t%d.%d\n"
2917                        "   media type:\t\t\t%s\n"
2918                        "   OC-3 revision:\t\t0x%x\n"
2919                        "   OC-3 mode:\t\t\t%s",
2920                        fw_release >> 16, fw_release << 16 >> 24,  fw_release << 24 >> 24,
2921                        mon960_release >> 16, mon960_release << 16 >> 16,
2922                        media_name[ media_index ],
2923                        oc3_revision,
2924                        oc3_mode[ oc3_index ]);
2925     }
2926
2927     if (!left--) {
2928         struct cp_monitor __iomem * cp_monitor = fore200e->cp_monitor;
2929
2930         return sprintf(page,
2931                        "\n\n"
2932                        " monitor:\n"
2933                        "   version number:\t\t%d\n"
2934                        "   boot status word:\t\t0x%08x\n",
2935                        fore200e->bus->read(&cp_monitor->mon_version),
2936                        fore200e->bus->read(&cp_monitor->bstat));
2937     }
2938
2939     if (!left--)
2940         return sprintf(page,
2941                        "\n"
2942                        " device statistics:\n"
2943                        "  4b5b:\n"
2944                        "     crc_header_errors:\t\t%10u\n"
2945                        "     framing_errors:\t\t%10u\n",
2946                        be32_to_cpu(fore200e->stats->phy.crc_header_errors),
2947                        be32_to_cpu(fore200e->stats->phy.framing_errors));
2948
2949     if (!left--)
2950         return sprintf(page, "\n"
2951                        "  OC-3:\n"
2952                        "     section_bip8_errors:\t%10u\n"
2953                        "     path_bip8_errors:\t\t%10u\n"
2954                        "     line_bip24_errors:\t\t%10u\n"
2955                        "     line_febe_errors:\t\t%10u\n"
2956                        "     path_febe_errors:\t\t%10u\n"
2957                        "     corr_hcs_errors:\t\t%10u\n"
2958                        "     ucorr_hcs_errors:\t\t%10u\n",
2959                        be32_to_cpu(fore200e->stats->oc3.section_bip8_errors),
2960                        be32_to_cpu(fore200e->stats->oc3.path_bip8_errors),
2961                        be32_to_cpu(fore200e->stats->oc3.line_bip24_errors),
2962                        be32_to_cpu(fore200e->stats->oc3.line_febe_errors),
2963                        be32_to_cpu(fore200e->stats->oc3.path_febe_errors),
2964                        be32_to_cpu(fore200e->stats->oc3.corr_hcs_errors),
2965                        be32_to_cpu(fore200e->stats->oc3.ucorr_hcs_errors));
2966
2967     if (!left--)
2968         return sprintf(page,"\n"
2969                        "   ATM:\t\t\t\t     cells\n"
2970                        "     TX:\t\t\t%10u\n"
2971                        "     RX:\t\t\t%10u\n"
2972                        "     vpi out of range:\t\t%10u\n"
2973                        "     vpi no conn:\t\t%10u\n"
2974                        "     vci out of range:\t\t%10u\n"
2975                        "     vci no conn:\t\t%10u\n",
2976                        be32_to_cpu(fore200e->stats->atm.cells_transmitted),
2977                        be32_to_cpu(fore200e->stats->atm.cells_received),
2978                        be32_to_cpu(fore200e->stats->atm.vpi_bad_range),
2979                        be32_to_cpu(fore200e->stats->atm.vpi_no_conn),
2980                        be32_to_cpu(fore200e->stats->atm.vci_bad_range),
2981                        be32_to_cpu(fore200e->stats->atm.vci_no_conn));
2982
2983     if (!left--)
2984         return sprintf(page,"\n"
2985                        "   AAL0:\t\t\t     cells\n"
2986                        "     TX:\t\t\t%10u\n"
2987                        "     RX:\t\t\t%10u\n"
2988                        "     dropped:\t\t\t%10u\n",
2989                        be32_to_cpu(fore200e->stats->aal0.cells_transmitted),
2990                        be32_to_cpu(fore200e->stats->aal0.cells_received),
2991                        be32_to_cpu(fore200e->stats->aal0.cells_dropped));
2992
2993     if (!left--)
2994         return sprintf(page,"\n"
2995                        "   AAL3/4:\n"
2996                        "     SAR sublayer:\t\t     cells\n"
2997                        "       TX:\t\t\t%10u\n"
2998                        "       RX:\t\t\t%10u\n"
2999                        "       dropped:\t\t\t%10u\n"
3000                        "       CRC errors:\t\t%10u\n"
3001                        "       protocol errors:\t\t%10u\n\n"
3002                        "     CS  sublayer:\t\t      PDUs\n"
3003                        "       TX:\t\t\t%10u\n"
3004                        "       RX:\t\t\t%10u\n"
3005                        "       dropped:\t\t\t%10u\n"
3006                        "       protocol errors:\t\t%10u\n",
3007                        be32_to_cpu(fore200e->stats->aal34.cells_transmitted),
3008                        be32_to_cpu(fore200e->stats->aal34.cells_received),
3009                        be32_to_cpu(fore200e->stats->aal34.cells_dropped),
3010                        be32_to_cpu(fore200e->stats->aal34.cells_crc_errors),
3011                        be32_to_cpu(fore200e->stats->aal34.cells_protocol_errors),
3012                        be32_to_cpu(fore200e->stats->aal34.cspdus_transmitted),
3013                        be32_to_cpu(fore200e->stats->aal34.cspdus_received),
3014                        be32_to_cpu(fore200e->stats->aal34.cspdus_dropped),
3015                        be32_to_cpu(fore200e->stats->aal34.cspdus_protocol_errors));
3016
3017     if (!left--)
3018         return sprintf(page,"\n"
3019                        "   AAL5:\n"
3020                        "     SAR sublayer:\t\t     cells\n"
3021                        "       TX:\t\t\t%10u\n"
3022                        "       RX:\t\t\t%10u\n"
3023                        "       dropped:\t\t\t%10u\n"
3024                        "       congestions:\t\t%10u\n\n"
3025                        "     CS  sublayer:\t\t      PDUs\n"
3026                        "       TX:\t\t\t%10u\n"
3027                        "       RX:\t\t\t%10u\n"
3028                        "       dropped:\t\t\t%10u\n"
3029                        "       CRC errors:\t\t%10u\n"
3030                        "       protocol errors:\t\t%10u\n",
3031                        be32_to_cpu(fore200e->stats->aal5.cells_transmitted),
3032                        be32_to_cpu(fore200e->stats->aal5.cells_received),
3033                        be32_to_cpu(fore200e->stats->aal5.cells_dropped),
3034                        be32_to_cpu(fore200e->stats->aal5.congestion_experienced),
3035                        be32_to_cpu(fore200e->stats->aal5.cspdus_transmitted),
3036                        be32_to_cpu(fore200e->stats->aal5.cspdus_received),
3037                        be32_to_cpu(fore200e->stats->aal5.cspdus_dropped),
3038                        be32_to_cpu(fore200e->stats->aal5.cspdus_crc_errors),
3039                        be32_to_cpu(fore200e->stats->aal5.cspdus_protocol_errors));
3040
3041     if (!left--)
3042         return sprintf(page,"\n"
3043                        "   AUX:\t\t       allocation failures\n"
3044                        "     small b1:\t\t\t%10u\n"
3045                        "     large b1:\t\t\t%10u\n"
3046                        "     small b2:\t\t\t%10u\n"
3047                        "     large b2:\t\t\t%10u\n"
3048                        "     RX PDUs:\t\t\t%10u\n"
3049                        "     TX PDUs:\t\t\t%10lu\n",
3050                        be32_to_cpu(fore200e->stats->aux.small_b1_failed),
3051                        be32_to_cpu(fore200e->stats->aux.large_b1_failed),
3052                        be32_to_cpu(fore200e->stats->aux.small_b2_failed),
3053                        be32_to_cpu(fore200e->stats->aux.large_b2_failed),
3054                        be32_to_cpu(fore200e->stats->aux.rpd_alloc_failed),
3055                        fore200e->tx_sat);
3056
3057     if (!left--)
3058         return sprintf(page,"\n"
3059                        " receive carrier:\t\t\t%s\n",
3060                        fore200e->stats->aux.receive_carrier ? "ON" : "OFF!");
3061
3062     if (!left--) {
3063         return sprintf(page,"\n"
3064                        " VCCs:\n  address   VPI VCI   AAL "
3065                        "TX PDUs   TX min/max size  RX PDUs   RX min/max size\n");
3066     }
3067
3068     for (i = 0; i < NBR_CONNECT; i++) {
3069
3070         vcc = fore200e->vc_map[i].vcc;
3071
3072         if (vcc == NULL)
3073             continue;
3074
3075         spin_lock_irqsave(&fore200e->q_lock, flags);
3076
3077         if (vcc && test_bit(ATM_VF_READY, &vcc->flags) && !left--) {
3078
3079             fore200e_vcc = FORE200E_VCC(vcc);
3080             ASSERT(fore200e_vcc);
3081
3082             len = sprintf(page,
3083                           "  %08x  %03d %05d %1d   %09lu %05d/%05d      %09lu %05d/%05d\n",
3084                           (u32)(unsigned long)vcc,
3085                           vcc->vpi, vcc->vci, fore200e_atm2fore_aal(vcc->qos.aal),
3086                           fore200e_vcc->tx_pdu,
3087                           fore200e_vcc->tx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->tx_min_pdu,
3088                           fore200e_vcc->tx_max_pdu,
3089                           fore200e_vcc->rx_pdu,
3090                           fore200e_vcc->rx_min_pdu > 0xFFFF ? 0 : fore200e_vcc->rx_min_pdu,
3091                           fore200e_vcc->rx_max_pdu);
3092
3093             spin_unlock_irqrestore(&fore200e->q_lock, flags);
3094             return len;
3095         }
3096
3097         spin_unlock_irqrestore(&fore200e->q_lock, flags);
3098     }
3099
3100     return 0;
3101 }
3102
3103 module_init(fore200e_module_init);
3104 module_exit(fore200e_module_cleanup);
3105
3106
3107 static const struct atmdev_ops fore200e_ops =
3108 {
3109         .open       = fore200e_open,
3110         .close      = fore200e_close,
3111         .ioctl      = fore200e_ioctl,
3112         .getsockopt = fore200e_getsockopt,
3113         .setsockopt = fore200e_setsockopt,
3114         .send       = fore200e_send,
3115         .change_qos = fore200e_change_qos,
3116         .proc_read  = fore200e_proc_read,
3117         .owner      = THIS_MODULE
3118 };
3119
3120
3121 static const struct fore200e_bus fore200e_bus[] = {
3122 #ifdef CONFIG_PCI
3123     { "PCA-200E", "pca200e", 32, 4, 32,
3124       fore200e_pca_read,
3125       fore200e_pca_write,
3126       fore200e_pca_dma_map,
3127       fore200e_pca_dma_unmap,
3128       fore200e_pca_dma_sync_for_cpu,
3129       fore200e_pca_dma_sync_for_device,
3130       fore200e_pca_dma_chunk_alloc,
3131       fore200e_pca_dma_chunk_free,
3132       fore200e_pca_configure,
3133       fore200e_pca_map,
3134       fore200e_pca_reset,
3135       fore200e_pca_prom_read,
3136       fore200e_pca_unmap,
3137       NULL,
3138       fore200e_pca_irq_check,
3139       fore200e_pca_irq_ack,
3140       fore200e_pca_proc_read,
3141     },
3142 #endif
3143 #ifdef CONFIG_SBUS
3144     { "SBA-200E", "sba200e", 32, 64, 32,
3145       fore200e_sba_read,
3146       fore200e_sba_write,
3147       fore200e_sba_dma_map,
3148       fore200e_sba_dma_unmap,
3149       fore200e_sba_dma_sync_for_cpu,
3150       fore200e_sba_dma_sync_for_device,
3151       fore200e_sba_dma_chunk_alloc,
3152       fore200e_sba_dma_chunk_free,
3153       fore200e_sba_configure,
3154       fore200e_sba_map,
3155       fore200e_sba_reset,
3156       fore200e_sba_prom_read,
3157       fore200e_sba_unmap,
3158       fore200e_sba_irq_enable,
3159       fore200e_sba_irq_check,
3160       fore200e_sba_irq_ack,
3161       fore200e_sba_proc_read,
3162     },
3163 #endif
3164     {}
3165 };
3166
3167 MODULE_LICENSE("GPL");
3168 #ifdef CONFIG_PCI
3169 #ifdef __LITTLE_ENDIAN__
3170 MODULE_FIRMWARE("pca200e.bin");
3171 #else
3172 MODULE_FIRMWARE("pca200e_ecd.bin2");
3173 #endif
3174 #endif /* CONFIG_PCI */
3175 #ifdef CONFIG_SBUS
3176 MODULE_FIRMWARE("sba200e_ecd.bin2");
3177 #endif