linux/drivers/atm/zatm.c
<<
>>
Prefs
   1/* drivers/atm/zatm.c - ZeitNet ZN122x device driver */
   2 
   3/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
   4
   5
   6#include <linux/module.h>
   7#include <linux/kernel.h>
   8#include <linux/mm.h>
   9#include <linux/pci.h>
  10#include <linux/errno.h>
  11#include <linux/atm.h>
  12#include <linux/atmdev.h>
  13#include <linux/sonet.h>
  14#include <linux/skbuff.h>
  15#include <linux/netdevice.h>
  16#include <linux/delay.h>
  17#include <linux/uio.h>
  18#include <linux/init.h>
  19#include <linux/interrupt.h>
  20#include <linux/dma-mapping.h>
  21#include <linux/atm_zatm.h>
  22#include <linux/capability.h>
  23#include <linux/bitops.h>
  24#include <linux/wait.h>
  25#include <linux/slab.h>
  26#include <asm/byteorder.h>
  27#include <asm/string.h>
  28#include <asm/io.h>
  29#include <linux/atomic.h>
  30#include <asm/uaccess.h>
  31
  32#include "uPD98401.h"
  33#include "uPD98402.h"
  34#include "zeprom.h"
  35#include "zatm.h"
  36
  37
  38/*
  39 * TODO:
  40 *
  41 * Minor features
  42 *  - support 64 kB SDUs (will have to use multibuffer batches then :-( )
  43 *  - proper use of CDV, credit = max(1,CDVT*PCR)
  44 *  - AAL0
  45 *  - better receive timestamps
  46 *  - OAM
  47 */
  48
  49#define ZATM_COPPER     1
  50
  51#if 0
  52#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
  53#else
  54#define DPRINTK(format,args...)
  55#endif
  56
  57#ifndef CONFIG_ATM_ZATM_DEBUG
  58
  59
  60#define NULLCHECK(x)
  61
  62#define EVENT(s,a,b)
  63
  64
  65static void event_dump(void)
  66{
  67}
  68
  69
  70#else
  71
  72
  73/* 
  74 * NULL pointer checking
  75 */
  76
  77#define NULLCHECK(x) \
  78  if ((unsigned long) (x) < 0x30) printk(KERN_CRIT #x "==0x%x\n", (int) (x))
  79
  80/*
  81 * Very extensive activity logging. Greatly improves bug detection speed but
  82 * costs a few Mbps if enabled.
  83 */
  84
  85#define EV 64
  86
  87static const char *ev[EV];
  88static unsigned long ev_a[EV],ev_b[EV];
  89static int ec = 0;
  90
  91
  92static void EVENT(const char *s,unsigned long a,unsigned long b)
  93{
  94        ev[ec] = s; 
  95        ev_a[ec] = a;
  96        ev_b[ec] = b;
  97        ec = (ec+1) % EV;
  98}
  99
 100
 101static void event_dump(void)
 102{
 103        int n,i;
 104
 105        printk(KERN_NOTICE "----- event dump follows -----\n");
 106        for (n = 0; n < EV; n++) {
 107                i = (ec+n) % EV;
 108                printk(KERN_NOTICE);
 109                printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]);
 110        }
 111        printk(KERN_NOTICE "----- event dump ends here -----\n");
 112}
 113
 114
 115#endif /* CONFIG_ATM_ZATM_DEBUG */
 116
 117
 118#define RING_BUSY       1       /* indication from do_tx that PDU has to be
 119                                   backlogged */
 120
 121static struct atm_dev *zatm_boards = NULL;
 122static unsigned long dummy[2] = {0,0};
 123
 124
 125#define zin_n(r) inl(zatm_dev->base+r*4)
 126#define zin(r) inl(zatm_dev->base+uPD98401_##r*4)
 127#define zout(v,r) outl(v,zatm_dev->base+uPD98401_##r*4)
 128#define zwait while (zin(CMR) & uPD98401_BUSY)
 129
 130/* RX0, RX1, TX0, TX1 */
 131static const int mbx_entries[NR_MBX] = { 1024,1024,1024,1024 };
 132static const int mbx_esize[NR_MBX] = { 16,16,4,4 }; /* entry size in bytes */
 133
 134#define MBX_SIZE(i) (mbx_entries[i]*mbx_esize[i])
 135
 136
 137/*-------------------------------- utilities --------------------------------*/
 138
 139
 140static void zpokel(struct zatm_dev *zatm_dev,u32 value,u32 addr)
 141{
 142        zwait;
 143        zout(value,CER);
 144        zout(uPD98401_IND_ACC | uPD98401_IA_BALL |
 145            (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
 146}
 147
 148
 149static u32 zpeekl(struct zatm_dev *zatm_dev,u32 addr)
 150{
 151        zwait;
 152        zout(uPD98401_IND_ACC | uPD98401_IA_BALL | uPD98401_IA_RW |
 153          (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
 154        zwait;
 155        return zin(CER);
 156}
 157
 158
 159/*------------------------------- free lists --------------------------------*/
 160
 161
 162/*
 163 * Free buffer head structure:
 164 *   [0] pointer to buffer (for SAR)
 165 *   [1] buffer descr link pointer (for SAR)
 166 *   [2] back pointer to skb (for poll_rx)
 167 *   [3] data
 168 *   ...
 169 */
 170
 171struct rx_buffer_head {
 172        u32             buffer; /* pointer to buffer (for SAR) */
 173        u32             link;   /* buffer descriptor link pointer (for SAR) */
 174        struct sk_buff  *skb;   /* back pointer to skb (for poll_rx) */
 175};
 176
 177
 178static void refill_pool(struct atm_dev *dev,int pool)
 179{
 180        struct zatm_dev *zatm_dev;
 181        struct sk_buff *skb;
 182        struct rx_buffer_head *first;
 183        unsigned long flags;
 184        int align,offset,free,count,size;
 185
 186        EVENT("refill_pool\n",0,0);
 187        zatm_dev = ZATM_DEV(dev);
 188        size = (64 << (pool <= ZATM_AAL5_POOL_BASE ? 0 :
 189            pool-ZATM_AAL5_POOL_BASE))+sizeof(struct rx_buffer_head);
 190        if (size < PAGE_SIZE) {
 191                align = 32; /* for 32 byte alignment */
 192                offset = sizeof(struct rx_buffer_head);
 193        }
 194        else {
 195                align = 4096;
 196                offset = zatm_dev->pool_info[pool].offset+
 197                    sizeof(struct rx_buffer_head);
 198        }
 199        size += align;
 200        spin_lock_irqsave(&zatm_dev->lock, flags);
 201        free = zpeekl(zatm_dev,zatm_dev->pool_base+2*pool) &
 202            uPD98401_RXFP_REMAIN;
 203        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 204        if (free >= zatm_dev->pool_info[pool].low_water) return;
 205        EVENT("starting ... POOL: 0x%x, 0x%x\n",
 206            zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
 207            zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
 208        EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
 209        count = 0;
 210        first = NULL;
 211        while (free < zatm_dev->pool_info[pool].high_water) {
 212                struct rx_buffer_head *head;
 213
 214                skb = alloc_skb(size,GFP_ATOMIC);
 215                if (!skb) {
 216                        printk(KERN_WARNING DEV_LABEL "(Itf %d): got no new "
 217                            "skb (%d) with %d free\n",dev->number,size,free);
 218                        break;
 219                }
 220                skb_reserve(skb,(unsigned char *) ((((unsigned long) skb->data+
 221                    align+offset-1) & ~(unsigned long) (align-1))-offset)-
 222                    skb->data);
 223                head = (struct rx_buffer_head *) skb->data;
 224                skb_reserve(skb,sizeof(struct rx_buffer_head));
 225                if (!first) first = head;
 226                count++;
 227                head->buffer = virt_to_bus(skb->data);
 228                head->link = 0;
 229                head->skb = skb;
 230                EVENT("enq skb 0x%08lx/0x%08lx\n",(unsigned long) skb,
 231                    (unsigned long) head);
 232                spin_lock_irqsave(&zatm_dev->lock, flags);
 233                if (zatm_dev->last_free[pool])
 234                        ((struct rx_buffer_head *) (zatm_dev->last_free[pool]->
 235                            data))[-1].link = virt_to_bus(head);
 236                zatm_dev->last_free[pool] = skb;
 237                skb_queue_tail(&zatm_dev->pool[pool],skb);
 238                spin_unlock_irqrestore(&zatm_dev->lock, flags);
 239                free++;
 240        }
 241        if (first) {
 242                spin_lock_irqsave(&zatm_dev->lock, flags);
 243                zwait;
 244                zout(virt_to_bus(first),CER);
 245                zout(uPD98401_ADD_BAT | (pool << uPD98401_POOL_SHIFT) | count,
 246                    CMR);
 247                spin_unlock_irqrestore(&zatm_dev->lock, flags);
 248                EVENT ("POOL: 0x%x, 0x%x\n",
 249                    zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
 250                    zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
 251                EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
 252        }
 253}
 254
 255
 256static void drain_free(struct atm_dev *dev,int pool)
 257{
 258        skb_queue_purge(&ZATM_DEV(dev)->pool[pool]);
 259}
 260
 261
 262static int pool_index(int max_pdu)
 263{
 264        int i;
 265
 266        if (max_pdu % ATM_CELL_PAYLOAD)
 267                printk(KERN_ERR DEV_LABEL ": driver error in pool_index: "
 268                    "max_pdu is %d\n",max_pdu);
 269        if (max_pdu > 65536) return -1;
 270        for (i = 0; (64 << i) < max_pdu; i++);
 271        return i+ZATM_AAL5_POOL_BASE;
 272}
 273
 274
 275/* use_pool isn't reentrant */
 276
 277
 278static void use_pool(struct atm_dev *dev,int pool)
 279{
 280        struct zatm_dev *zatm_dev;
 281        unsigned long flags;
 282        int size;
 283
 284        zatm_dev = ZATM_DEV(dev);
 285        if (!(zatm_dev->pool_info[pool].ref_count++)) {
 286                skb_queue_head_init(&zatm_dev->pool[pool]);
 287                size = pool-ZATM_AAL5_POOL_BASE;
 288                if (size < 0) size = 0; /* 64B... */
 289                else if (size > 10) size = 10; /* ... 64kB */
 290                spin_lock_irqsave(&zatm_dev->lock, flags);
 291                zpokel(zatm_dev,((zatm_dev->pool_info[pool].low_water/4) <<
 292                    uPD98401_RXFP_ALERT_SHIFT) |
 293                    (1 << uPD98401_RXFP_BTSZ_SHIFT) |
 294                    (size << uPD98401_RXFP_BFSZ_SHIFT),
 295                    zatm_dev->pool_base+pool*2);
 296                zpokel(zatm_dev,(unsigned long) dummy,zatm_dev->pool_base+
 297                    pool*2+1);
 298                spin_unlock_irqrestore(&zatm_dev->lock, flags);
 299                zatm_dev->last_free[pool] = NULL;
 300                refill_pool(dev,pool);
 301        }
 302        DPRINTK("pool %d: %d\n",pool,zatm_dev->pool_info[pool].ref_count);
 303}
 304
 305
 306static void unuse_pool(struct atm_dev *dev,int pool)
 307{
 308        if (!(--ZATM_DEV(dev)->pool_info[pool].ref_count))
 309                drain_free(dev,pool);
 310}
 311
 312/*----------------------------------- RX ------------------------------------*/
 313
 314
 315#if 0
 316static void exception(struct atm_vcc *vcc)
 317{
 318   static int count = 0;
 319   struct zatm_dev *zatm_dev = ZATM_DEV(vcc->dev);
 320   struct zatm_vcc *zatm_vcc = ZATM_VCC(vcc);
 321   unsigned long *qrp;
 322   int i;
 323
 324   if (count++ > 2) return;
 325   for (i = 0; i < 8; i++)
 326        printk("TX%d: 0x%08lx\n",i,
 327          zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+i));
 328   for (i = 0; i < 5; i++)
 329        printk("SH%d: 0x%08lx\n",i,
 330          zpeekl(zatm_dev,uPD98401_IM(zatm_vcc->shaper)+16*i));
 331   qrp = (unsigned long *) zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
 332     uPD98401_TXVC_QRP);
 333   printk("qrp=0x%08lx\n",(unsigned long) qrp);
 334   for (i = 0; i < 4; i++) printk("QRP[%d]: 0x%08lx",i,qrp[i]);
 335}
 336#endif
 337
 338
 339static const char *err_txt[] = {
 340        "No error",
 341        "RX buf underflow",
 342        "RX FIFO overrun",
 343        "Maximum len violation",
 344        "CRC error",
 345        "User abort",
 346        "Length violation",
 347        "T1 error",
 348        "Deactivated",
 349        "???",
 350        "???",
 351        "???",
 352        "???",
 353        "???",
 354        "???",
 355        "???"
 356};
 357
 358
 359static void poll_rx(struct atm_dev *dev,int mbx)
 360{
 361        struct zatm_dev *zatm_dev;
 362        unsigned long pos;
 363        u32 x;
 364        int error;
 365
 366        EVENT("poll_rx\n",0,0);
 367        zatm_dev = ZATM_DEV(dev);
 368        pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
 369        while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
 370                u32 *here;
 371                struct sk_buff *skb;
 372                struct atm_vcc *vcc;
 373                int cells,size,chan;
 374
 375                EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
 376                here = (u32 *) pos;
 377                if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx])
 378                        pos = zatm_dev->mbx_start[mbx];
 379                cells = here[0] & uPD98401_AAL5_SIZE;
 380#if 0
 381printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here[0],here[1],here[2],here[3]);
 382{
 383unsigned long *x;
 384                printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev,
 385                      zatm_dev->pool_base),
 386                      zpeekl(zatm_dev,zatm_dev->pool_base+1));
 387                x = (unsigned long *) here[2];
 388                printk("[0..3] = 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",
 389                    x[0],x[1],x[2],x[3]);
 390}
 391#endif
 392                error = 0;
 393                if (here[3] & uPD98401_AAL5_ERR) {
 394                        error = (here[3] & uPD98401_AAL5_ES) >>
 395                            uPD98401_AAL5_ES_SHIFT;
 396                        if (error == uPD98401_AAL5_ES_DEACT ||
 397                            error == uPD98401_AAL5_ES_FREE) continue;
 398                }
 399EVENT("error code 0x%x/0x%x\n",(here[3] & uPD98401_AAL5_ES) >>
 400  uPD98401_AAL5_ES_SHIFT,error);
 401                skb = ((struct rx_buffer_head *) bus_to_virt(here[2]))->skb;
 402                __net_timestamp(skb);
 403#if 0
 404printk("[-3..0] 0x%08lx 0x%08lx 0x%08lx 0x%08lx\n",((unsigned *) skb->data)[-3],
 405  ((unsigned *) skb->data)[-2],((unsigned *) skb->data)[-1],
 406  ((unsigned *) skb->data)[0]);
 407#endif
 408                EVENT("skb 0x%lx, here 0x%lx\n",(unsigned long) skb,
 409                    (unsigned long) here);
 410#if 0
 411printk("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
 412#endif
 413                size = error ? 0 : ntohs(((__be16 *) skb->data)[cells*
 414                    ATM_CELL_PAYLOAD/sizeof(u16)-3]);
 415                EVENT("got skb 0x%lx, size %d\n",(unsigned long) skb,size);
 416                chan = (here[3] & uPD98401_AAL5_CHAN) >>
 417                    uPD98401_AAL5_CHAN_SHIFT;
 418                if (chan < zatm_dev->chans && zatm_dev->rx_map[chan]) {
 419                        int pos;
 420                        vcc = zatm_dev->rx_map[chan];
 421                        pos = ZATM_VCC(vcc)->pool;
 422                        if (skb == zatm_dev->last_free[pos])
 423                                zatm_dev->last_free[pos] = NULL;
 424                        skb_unlink(skb, zatm_dev->pool + pos);
 425                }
 426                else {
 427                        printk(KERN_ERR DEV_LABEL "(itf %d): RX indication "
 428                            "for non-existing channel\n",dev->number);
 429                        size = 0;
 430                        vcc = NULL;
 431                        event_dump();
 432                }
 433                if (error) {
 434                        static unsigned long silence = 0;
 435                        static int last_error = 0;
 436
 437                        if (error != last_error ||
 438                            time_after(jiffies, silence)  || silence == 0){
 439                                printk(KERN_WARNING DEV_LABEL "(itf %d): "
 440                                    "chan %d error %s\n",dev->number,chan,
 441                                    err_txt[error]);
 442                                last_error = error;
 443                                silence = (jiffies+2*HZ)|1;
 444                        }
 445                        size = 0;
 446                }
 447                if (size && (size > cells*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER ||
 448                    size <= (cells-1)*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER)) {
 449                        printk(KERN_ERR DEV_LABEL "(itf %d): size %d with %d "
 450                            "cells\n",dev->number,size,cells);
 451                        size = 0;
 452                        event_dump();
 453                }
 454                if (size > ATM_MAX_AAL5_PDU) {
 455                        printk(KERN_ERR DEV_LABEL "(itf %d): size too big "
 456                            "(%d)\n",dev->number,size);
 457                        size = 0;
 458                        event_dump();
 459                }
 460                if (!size) {
 461                        dev_kfree_skb_irq(skb);
 462                        if (vcc) atomic_inc(&vcc->stats->rx_err);
 463                        continue;
 464                }
 465                if (!atm_charge(vcc,skb->truesize)) {
 466                        dev_kfree_skb_irq(skb);
 467                        continue;
 468                }
 469                skb->len = size;
 470                ATM_SKB(skb)->vcc = vcc;
 471                vcc->push(vcc,skb);
 472                atomic_inc(&vcc->stats->rx);
 473        }
 474        zout(pos & 0xffff,MTA(mbx));
 475#if 0 /* probably a stupid idea */
 476        refill_pool(dev,zatm_vcc->pool);
 477                /* maybe this saves us a few interrupts */
 478#endif
 479}
 480
 481
 482static int open_rx_first(struct atm_vcc *vcc)
 483{
 484        struct zatm_dev *zatm_dev;
 485        struct zatm_vcc *zatm_vcc;
 486        unsigned long flags;
 487        unsigned short chan;
 488        int cells;
 489
 490        DPRINTK("open_rx_first (0x%x)\n",inb_p(0xc053));
 491        zatm_dev = ZATM_DEV(vcc->dev);
 492        zatm_vcc = ZATM_VCC(vcc);
 493        zatm_vcc->rx_chan = 0;
 494        if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0;
 495        if (vcc->qos.aal == ATM_AAL5) {
 496                if (vcc->qos.rxtp.max_sdu > 65464)
 497                        vcc->qos.rxtp.max_sdu = 65464;
 498                        /* fix this - we may want to receive 64kB SDUs
 499                           later */
 500                cells = DIV_ROUND_UP(vcc->qos.rxtp.max_sdu + ATM_AAL5_TRAILER,
 501                                ATM_CELL_PAYLOAD);
 502                zatm_vcc->pool = pool_index(cells*ATM_CELL_PAYLOAD);
 503        }
 504        else {
 505                cells = 1;
 506                zatm_vcc->pool = ZATM_AAL0_POOL;
 507        }
 508        if (zatm_vcc->pool < 0) return -EMSGSIZE;
 509        spin_lock_irqsave(&zatm_dev->lock, flags);
 510        zwait;
 511        zout(uPD98401_OPEN_CHAN,CMR);
 512        zwait;
 513        DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER));
 514        chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT;
 515        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 516        DPRINTK("chan is %d\n",chan);
 517        if (!chan) return -EAGAIN;
 518        use_pool(vcc->dev,zatm_vcc->pool);
 519        DPRINTK("pool %d\n",zatm_vcc->pool);
 520        /* set up VC descriptor */
 521        spin_lock_irqsave(&zatm_dev->lock, flags);
 522        zpokel(zatm_dev,zatm_vcc->pool << uPD98401_RXVC_POOL_SHIFT,
 523            chan*VC_SIZE/4);
 524        zpokel(zatm_dev,uPD98401_RXVC_OD | (vcc->qos.aal == ATM_AAL5 ?
 525            uPD98401_RXVC_AR : 0) | cells,chan*VC_SIZE/4+1);
 526        zpokel(zatm_dev,0,chan*VC_SIZE/4+2);
 527        zatm_vcc->rx_chan = chan;
 528        zatm_dev->rx_map[chan] = vcc;
 529        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 530        return 0;
 531}
 532
 533
 534static int open_rx_second(struct atm_vcc *vcc)
 535{
 536        struct zatm_dev *zatm_dev;
 537        struct zatm_vcc *zatm_vcc;
 538        unsigned long flags;
 539        int pos,shift;
 540
 541        DPRINTK("open_rx_second (0x%x)\n",inb_p(0xc053));
 542        zatm_dev = ZATM_DEV(vcc->dev);
 543        zatm_vcc = ZATM_VCC(vcc);
 544        if (!zatm_vcc->rx_chan) return 0;
 545        spin_lock_irqsave(&zatm_dev->lock, flags);
 546        /* should also handle VPI @@@ */
 547        pos = vcc->vci >> 1;
 548        shift = (1-(vcc->vci & 1)) << 4;
 549        zpokel(zatm_dev,(zpeekl(zatm_dev,pos) & ~(0xffff << shift)) |
 550            ((zatm_vcc->rx_chan | uPD98401_RXLT_ENBL) << shift),pos);
 551        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 552        return 0;
 553}
 554
 555
 556static void close_rx(struct atm_vcc *vcc)
 557{
 558        struct zatm_dev *zatm_dev;
 559        struct zatm_vcc *zatm_vcc;
 560        unsigned long flags;
 561        int pos,shift;
 562
 563        zatm_vcc = ZATM_VCC(vcc);
 564        zatm_dev = ZATM_DEV(vcc->dev);
 565        if (!zatm_vcc->rx_chan) return;
 566        DPRINTK("close_rx\n");
 567        /* disable receiver */
 568        if (vcc->vpi != ATM_VPI_UNSPEC && vcc->vci != ATM_VCI_UNSPEC) {
 569                spin_lock_irqsave(&zatm_dev->lock, flags);
 570                pos = vcc->vci >> 1;
 571                shift = (1-(vcc->vci & 1)) << 4;
 572                zpokel(zatm_dev,zpeekl(zatm_dev,pos) & ~(0xffff << shift),pos);
 573                zwait;
 574                zout(uPD98401_NOP,CMR);
 575                zwait;
 576                zout(uPD98401_NOP,CMR);
 577                spin_unlock_irqrestore(&zatm_dev->lock, flags);
 578        }
 579        spin_lock_irqsave(&zatm_dev->lock, flags);
 580        zwait;
 581        zout(uPD98401_DEACT_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
 582            uPD98401_CHAN_ADDR_SHIFT),CMR);
 583        zwait;
 584        udelay(10); /* why oh why ... ? */
 585        zout(uPD98401_CLOSE_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
 586            uPD98401_CHAN_ADDR_SHIFT),CMR);
 587        zwait;
 588        if (!(zin(CMR) & uPD98401_CHAN_ADDR))
 589                printk(KERN_CRIT DEV_LABEL "(itf %d): can't close RX channel "
 590                    "%d\n",vcc->dev->number,zatm_vcc->rx_chan);
 591        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 592        zatm_dev->rx_map[zatm_vcc->rx_chan] = NULL;
 593        zatm_vcc->rx_chan = 0;
 594        unuse_pool(vcc->dev,zatm_vcc->pool);
 595}
 596
 597
 598static int start_rx(struct atm_dev *dev)
 599{
 600        struct zatm_dev *zatm_dev;
 601        int i;
 602
 603        DPRINTK("start_rx\n");
 604        zatm_dev = ZATM_DEV(dev);
 605        zatm_dev->rx_map = kcalloc(zatm_dev->chans,
 606                                   sizeof(*zatm_dev->rx_map),
 607                                   GFP_KERNEL);
 608        if (!zatm_dev->rx_map) return -ENOMEM;
 609        /* set VPI/VCI split (use all VCIs and give what's left to VPIs) */
 610        zpokel(zatm_dev,(1 << dev->ci_range.vci_bits)-1,uPD98401_VRR);
 611        /* prepare free buffer pools */
 612        for (i = 0; i <= ZATM_LAST_POOL; i++) {
 613                zatm_dev->pool_info[i].ref_count = 0;
 614                zatm_dev->pool_info[i].rqa_count = 0;
 615                zatm_dev->pool_info[i].rqu_count = 0;
 616                zatm_dev->pool_info[i].low_water = LOW_MARK;
 617                zatm_dev->pool_info[i].high_water = HIGH_MARK;
 618                zatm_dev->pool_info[i].offset = 0;
 619                zatm_dev->pool_info[i].next_off = 0;
 620                zatm_dev->pool_info[i].next_cnt = 0;
 621                zatm_dev->pool_info[i].next_thres = OFF_CNG_THRES;
 622        }
 623        return 0;
 624}
 625
 626
 627/*----------------------------------- TX ------------------------------------*/
 628
 629
 630static int do_tx(struct sk_buff *skb)
 631{
 632        struct atm_vcc *vcc;
 633        struct zatm_dev *zatm_dev;
 634        struct zatm_vcc *zatm_vcc;
 635        u32 *dsc;
 636        unsigned long flags;
 637
 638        EVENT("do_tx\n",0,0);
 639        DPRINTK("sending skb %p\n",skb);
 640        vcc = ATM_SKB(skb)->vcc;
 641        zatm_dev = ZATM_DEV(vcc->dev);
 642        zatm_vcc = ZATM_VCC(vcc);
 643        EVENT("iovcnt=%d\n",skb_shinfo(skb)->nr_frags,0);
 644        spin_lock_irqsave(&zatm_dev->lock, flags);
 645        if (!skb_shinfo(skb)->nr_frags) {
 646                if (zatm_vcc->txing == RING_ENTRIES-1) {
 647                        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 648                        return RING_BUSY;
 649                }
 650                zatm_vcc->txing++;
 651                dsc = zatm_vcc->ring+zatm_vcc->ring_curr;
 652                zatm_vcc->ring_curr = (zatm_vcc->ring_curr+RING_WORDS) &
 653                    (RING_ENTRIES*RING_WORDS-1);
 654                dsc[1] = 0;
 655                dsc[2] = skb->len;
 656                dsc[3] = virt_to_bus(skb->data);
 657                mb();
 658                dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP | uPD98401_TXPD_SM
 659                    | (vcc->qos.aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 |
 660                    (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ?
 661                    uPD98401_CLPM_1 : uPD98401_CLPM_0));
 662                EVENT("dsc (0x%lx)\n",(unsigned long) dsc,0);
 663        }
 664        else {
 665printk("NONONONOO!!!!\n");
 666                dsc = NULL;
 667#if 0
 668                u32 *put;
 669                int i;
 670
 671                dsc = kmalloc(uPD98401_TXPD_SIZE * 2 +
 672                        uPD98401_TXBD_SIZE * ATM_SKB(skb)->iovcnt, GFP_ATOMIC);
 673                if (!dsc) {
 674                        if (vcc->pop)
 675                                vcc->pop(vcc, skb);
 676                        else
 677                                dev_kfree_skb_irq(skb);
 678                        return -EAGAIN;
 679                }
 680                /* @@@ should check alignment */
 681                put = dsc+8;
 682                dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP |
 683                    (vcc->aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 |
 684                    (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ?
 685                    uPD98401_CLPM_1 : uPD98401_CLPM_0));
 686                dsc[1] = 0;
 687                dsc[2] = ATM_SKB(skb)->iovcnt * uPD98401_TXBD_SIZE;
 688                dsc[3] = virt_to_bus(put);
 689                for (i = 0; i < ATM_SKB(skb)->iovcnt; i++) {
 690                        *put++ = ((struct iovec *) skb->data)[i].iov_len;
 691                        *put++ = virt_to_bus(((struct iovec *)
 692                            skb->data)[i].iov_base);
 693                }
 694                put[-2] |= uPD98401_TXBD_LAST;
 695#endif
 696        }
 697        ZATM_PRV_DSC(skb) = dsc;
 698        skb_queue_tail(&zatm_vcc->tx_queue,skb);
 699        DPRINTK("QRP=0x%08lx\n",zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
 700          uPD98401_TXVC_QRP));
 701        zwait;
 702        zout(uPD98401_TX_READY | (zatm_vcc->tx_chan <<
 703            uPD98401_CHAN_ADDR_SHIFT),CMR);
 704        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 705        EVENT("done\n",0,0);
 706        return 0;
 707}
 708
 709
 710static inline void dequeue_tx(struct atm_vcc *vcc)
 711{
 712        struct zatm_vcc *zatm_vcc;
 713        struct sk_buff *skb;
 714
 715        EVENT("dequeue_tx\n",0,0);
 716        zatm_vcc = ZATM_VCC(vcc);
 717        skb = skb_dequeue(&zatm_vcc->tx_queue);
 718        if (!skb) {
 719                printk(KERN_CRIT DEV_LABEL "(itf %d): dequeue_tx but not "
 720                    "txing\n",vcc->dev->number);
 721                return;
 722        }
 723#if 0 /* @@@ would fail on CLP */
 724if (*ZATM_PRV_DSC(skb) != (uPD98401_TXPD_V | uPD98401_TXPD_DP |
 725  uPD98401_TXPD_SM | uPD98401_TXPD_AAL5)) printk("@#*$!!!!  (%08x)\n",
 726  *ZATM_PRV_DSC(skb));
 727#endif
 728        *ZATM_PRV_DSC(skb) = 0; /* mark as invalid */
 729        zatm_vcc->txing--;
 730        if (vcc->pop) vcc->pop(vcc,skb);
 731        else dev_kfree_skb_irq(skb);
 732        while ((skb = skb_dequeue(&zatm_vcc->backlog)))
 733                if (do_tx(skb) == RING_BUSY) {
 734                        skb_queue_head(&zatm_vcc->backlog,skb);
 735                        break;
 736                }
 737        atomic_inc(&vcc->stats->tx);
 738        wake_up(&zatm_vcc->tx_wait);
 739}
 740
 741
 742static void poll_tx(struct atm_dev *dev,int mbx)
 743{
 744        struct zatm_dev *zatm_dev;
 745        unsigned long pos;
 746        u32 x;
 747
 748        EVENT("poll_tx\n",0,0);
 749        zatm_dev = ZATM_DEV(dev);
 750        pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
 751        while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
 752                int chan;
 753
 754#if 1
 755                u32 data,*addr;
 756
 757                EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
 758                addr = (u32 *) pos;
 759                data = *addr;
 760                chan = (data & uPD98401_TXI_CONN) >> uPD98401_TXI_CONN_SHIFT;
 761                EVENT("addr = 0x%lx, data = 0x%08x,",(unsigned long) addr,
 762                    data);
 763                EVENT("chan = %d\n",chan,0);
 764#else
 765NO !
 766                chan = (zatm_dev->mbx_start[mbx][pos >> 2] & uPD98401_TXI_CONN)
 767                >> uPD98401_TXI_CONN_SHIFT;
 768#endif
 769                if (chan < zatm_dev->chans && zatm_dev->tx_map[chan])
 770                        dequeue_tx(zatm_dev->tx_map[chan]);
 771                else {
 772                        printk(KERN_CRIT DEV_LABEL "(itf %d): TX indication "
 773                            "for non-existing channel %d\n",dev->number,chan);
 774                        event_dump();
 775                }
 776                if (((pos += 4) & 0xffff) == zatm_dev->mbx_end[mbx])
 777                        pos = zatm_dev->mbx_start[mbx];
 778        }
 779        zout(pos & 0xffff,MTA(mbx));
 780}
 781
 782
 783/*
 784 * BUG BUG BUG: Doesn't handle "new-style" rate specification yet.
 785 */
 786
 787static int alloc_shaper(struct atm_dev *dev,int *pcr,int min,int max,int ubr)
 788{
 789        struct zatm_dev *zatm_dev;
 790        unsigned long flags;
 791        unsigned long i,m,c;
 792        int shaper;
 793
 794        DPRINTK("alloc_shaper (min = %d, max = %d)\n",min,max);
 795        zatm_dev = ZATM_DEV(dev);
 796        if (!zatm_dev->free_shapers) return -EAGAIN;
 797        for (shaper = 0; !((zatm_dev->free_shapers >> shaper) & 1); shaper++);
 798        zatm_dev->free_shapers &= ~1 << shaper;
 799        if (ubr) {
 800                c = 5;
 801                i = m = 1;
 802                zatm_dev->ubr_ref_cnt++;
 803                zatm_dev->ubr = shaper;
 804                *pcr = 0;
 805        }
 806        else {
 807                if (min) {
 808                        if (min <= 255) {
 809                                i = min;
 810                                m = ATM_OC3_PCR;
 811                        }
 812                        else {
 813                                i = 255;
 814                                m = ATM_OC3_PCR*255/min;
 815                        }
 816                }
 817                else {
 818                        if (max > zatm_dev->tx_bw) max = zatm_dev->tx_bw;
 819                        if (max <= 255) {
 820                                i = max;
 821                                m = ATM_OC3_PCR;
 822                        }
 823                        else {
 824                                i = 255;
 825                                m = DIV_ROUND_UP(ATM_OC3_PCR*255, max);
 826                        }
 827                }
 828                if (i > m) {
 829                        printk(KERN_CRIT DEV_LABEL "shaper algorithm botched "
 830                            "[%d,%d] -> i=%ld,m=%ld\n",min,max,i,m);
 831                        m = i;
 832                }
 833                *pcr = i*ATM_OC3_PCR/m;
 834                c = 20; /* @@@ should use max_cdv ! */
 835                if ((min && *pcr < min) || (max && *pcr > max)) return -EINVAL;
 836                if (zatm_dev->tx_bw < *pcr) return -EAGAIN;
 837                zatm_dev->tx_bw -= *pcr;
 838        }
 839        spin_lock_irqsave(&zatm_dev->lock, flags);
 840        DPRINTK("i = %d, m = %d, PCR = %d\n",i,m,*pcr);
 841        zpokel(zatm_dev,(i << uPD98401_IM_I_SHIFT) | m,uPD98401_IM(shaper));
 842        zpokel(zatm_dev,c << uPD98401_PC_C_SHIFT,uPD98401_PC(shaper));
 843        zpokel(zatm_dev,0,uPD98401_X(shaper));
 844        zpokel(zatm_dev,0,uPD98401_Y(shaper));
 845        zpokel(zatm_dev,uPD98401_PS_E,uPD98401_PS(shaper));
 846        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 847        return shaper;
 848}
 849
 850
 851static void dealloc_shaper(struct atm_dev *dev,int shaper)
 852{
 853        struct zatm_dev *zatm_dev;
 854        unsigned long flags;
 855
 856        zatm_dev = ZATM_DEV(dev);
 857        if (shaper == zatm_dev->ubr) {
 858                if (--zatm_dev->ubr_ref_cnt) return;
 859                zatm_dev->ubr = -1;
 860        }
 861        spin_lock_irqsave(&zatm_dev->lock, flags);
 862        zpokel(zatm_dev,zpeekl(zatm_dev,uPD98401_PS(shaper)) & ~uPD98401_PS_E,
 863            uPD98401_PS(shaper));
 864        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 865        zatm_dev->free_shapers |= 1 << shaper;
 866}
 867
 868
 869static void close_tx(struct atm_vcc *vcc)
 870{
 871        struct zatm_dev *zatm_dev;
 872        struct zatm_vcc *zatm_vcc;
 873        unsigned long flags;
 874        int chan;
 875
 876        zatm_vcc = ZATM_VCC(vcc);
 877        zatm_dev = ZATM_DEV(vcc->dev);
 878        chan = zatm_vcc->tx_chan;
 879        if (!chan) return;
 880        DPRINTK("close_tx\n");
 881        if (skb_peek(&zatm_vcc->backlog)) {
 882                printk("waiting for backlog to drain ...\n");
 883                event_dump();
 884                wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->backlog));
 885        }
 886        if (skb_peek(&zatm_vcc->tx_queue)) {
 887                printk("waiting for TX queue to drain ...\n");
 888                event_dump();
 889                wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->tx_queue));
 890        }
 891        spin_lock_irqsave(&zatm_dev->lock, flags);
 892#if 0
 893        zwait;
 894        zout(uPD98401_DEACT_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
 895#endif
 896        zwait;
 897        zout(uPD98401_CLOSE_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
 898        zwait;
 899        if (!(zin(CMR) & uPD98401_CHAN_ADDR))
 900                printk(KERN_CRIT DEV_LABEL "(itf %d): can't close TX channel "
 901                    "%d\n",vcc->dev->number,chan);
 902        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 903        zatm_vcc->tx_chan = 0;
 904        zatm_dev->tx_map[chan] = NULL;
 905        if (zatm_vcc->shaper != zatm_dev->ubr) {
 906                zatm_dev->tx_bw += vcc->qos.txtp.min_pcr;
 907                dealloc_shaper(vcc->dev,zatm_vcc->shaper);
 908        }
 909        kfree(zatm_vcc->ring);
 910}
 911
 912
 913static int open_tx_first(struct atm_vcc *vcc)
 914{
 915        struct zatm_dev *zatm_dev;
 916        struct zatm_vcc *zatm_vcc;
 917        unsigned long flags;
 918        u32 *loop;
 919        unsigned short chan;
 920        int unlimited;
 921
 922        DPRINTK("open_tx_first\n");
 923        zatm_dev = ZATM_DEV(vcc->dev);
 924        zatm_vcc = ZATM_VCC(vcc);
 925        zatm_vcc->tx_chan = 0;
 926        if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0;
 927        spin_lock_irqsave(&zatm_dev->lock, flags);
 928        zwait;
 929        zout(uPD98401_OPEN_CHAN,CMR);
 930        zwait;
 931        DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER));
 932        chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT;
 933        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 934        DPRINTK("chan is %d\n",chan);
 935        if (!chan) return -EAGAIN;
 936        unlimited = vcc->qos.txtp.traffic_class == ATM_UBR &&
 937            (!vcc->qos.txtp.max_pcr || vcc->qos.txtp.max_pcr == ATM_MAX_PCR ||
 938            vcc->qos.txtp.max_pcr >= ATM_OC3_PCR);
 939        if (unlimited && zatm_dev->ubr != -1) zatm_vcc->shaper = zatm_dev->ubr;
 940        else {
 941                int uninitialized_var(pcr);
 942
 943                if (unlimited) vcc->qos.txtp.max_sdu = ATM_MAX_AAL5_PDU;
 944                if ((zatm_vcc->shaper = alloc_shaper(vcc->dev,&pcr,
 945                    vcc->qos.txtp.min_pcr,vcc->qos.txtp.max_pcr,unlimited))
 946                    < 0) {
 947                        close_tx(vcc);
 948                        return zatm_vcc->shaper;
 949                }
 950                if (pcr > ATM_OC3_PCR) pcr = ATM_OC3_PCR;
 951                vcc->qos.txtp.min_pcr = vcc->qos.txtp.max_pcr = pcr;
 952        }
 953        zatm_vcc->tx_chan = chan;
 954        skb_queue_head_init(&zatm_vcc->tx_queue);
 955        init_waitqueue_head(&zatm_vcc->tx_wait);
 956        /* initialize ring */
 957        zatm_vcc->ring = kzalloc(RING_SIZE,GFP_KERNEL);
 958        if (!zatm_vcc->ring) return -ENOMEM;
 959        loop = zatm_vcc->ring+RING_ENTRIES*RING_WORDS;
 960        loop[0] = uPD98401_TXPD_V;
 961        loop[1] = loop[2] = 0;
 962        loop[3] = virt_to_bus(zatm_vcc->ring);
 963        zatm_vcc->ring_curr = 0;
 964        zatm_vcc->txing = 0;
 965        skb_queue_head_init(&zatm_vcc->backlog);
 966        zpokel(zatm_dev,virt_to_bus(zatm_vcc->ring),
 967            chan*VC_SIZE/4+uPD98401_TXVC_QRP);
 968        return 0;
 969}
 970
 971
 972static int open_tx_second(struct atm_vcc *vcc)
 973{
 974        struct zatm_dev *zatm_dev;
 975        struct zatm_vcc *zatm_vcc;
 976        unsigned long flags;
 977
 978        DPRINTK("open_tx_second\n");
 979        zatm_dev = ZATM_DEV(vcc->dev);
 980        zatm_vcc = ZATM_VCC(vcc);
 981        if (!zatm_vcc->tx_chan) return 0;
 982        /* set up VC descriptor */
 983        spin_lock_irqsave(&zatm_dev->lock, flags);
 984        zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4);
 985        zpokel(zatm_dev,uPD98401_TXVC_L | (zatm_vcc->shaper <<
 986            uPD98401_TXVC_SHP_SHIFT) | (vcc->vpi << uPD98401_TXVC_VPI_SHIFT) |
 987            vcc->vci,zatm_vcc->tx_chan*VC_SIZE/4+1);
 988        zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4+2);
 989        spin_unlock_irqrestore(&zatm_dev->lock, flags);
 990        zatm_dev->tx_map[zatm_vcc->tx_chan] = vcc;
 991        return 0;
 992}
 993
 994
 995static int start_tx(struct atm_dev *dev)
 996{
 997        struct zatm_dev *zatm_dev;
 998        int i;
 999
1000        DPRINTK("start_tx\n");
1001        zatm_dev = ZATM_DEV(dev);
1002        zatm_dev->tx_map = kmalloc_array(zatm_dev->chans,
1003                                         sizeof(*zatm_dev->tx_map),
1004                                         GFP_KERNEL);
1005        if (!zatm_dev->tx_map) return -ENOMEM;
1006        zatm_dev->tx_bw = ATM_OC3_PCR;
1007        zatm_dev->free_shapers = (1 << NR_SHAPERS)-1;
1008        zatm_dev->ubr = -1;
1009        zatm_dev->ubr_ref_cnt = 0;
1010        /* initialize shapers */
1011        for (i = 0; i < NR_SHAPERS; i++) zpokel(zatm_dev,0,uPD98401_PS(i));
1012        return 0;
1013}
1014
1015
1016/*------------------------------- interrupts --------------------------------*/
1017
1018
1019static irqreturn_t zatm_int(int irq,void *dev_id)
1020{
1021        struct atm_dev *dev;
1022        struct zatm_dev *zatm_dev;
1023        u32 reason;
1024        int handled = 0;
1025
1026        dev = dev_id;
1027        zatm_dev = ZATM_DEV(dev);
1028        while ((reason = zin(GSR))) {
1029                handled = 1;
1030                EVENT("reason 0x%x\n",reason,0);
1031                if (reason & uPD98401_INT_PI) {
1032                        EVENT("PHY int\n",0,0);
1033                        dev->phy->interrupt(dev);
1034                }
1035                if (reason & uPD98401_INT_RQA) {
1036                        unsigned long pools;
1037                        int i;
1038
1039                        pools = zin(RQA);
1040                        EVENT("RQA (0x%08x)\n",pools,0);
1041                        for (i = 0; pools; i++) {
1042                                if (pools & 1) {
1043                                        refill_pool(dev,i);
1044                                        zatm_dev->pool_info[i].rqa_count++;
1045                                }
1046                                pools >>= 1;
1047                        }
1048                }
1049                if (reason & uPD98401_INT_RQU) {
1050                        unsigned long pools;
1051                        int i;
1052                        pools = zin(RQU);
1053                        printk(KERN_WARNING DEV_LABEL "(itf %d): RQU 0x%08lx\n",
1054                            dev->number,pools);
1055                        event_dump();
1056                        for (i = 0; pools; i++) {
1057                                if (pools & 1) {
1058                                        refill_pool(dev,i);
1059                                        zatm_dev->pool_info[i].rqu_count++;
1060                                }
1061                                pools >>= 1;
1062                        }
1063                }
1064                /* don't handle RD */
1065                if (reason & uPD98401_INT_SPE)
1066                        printk(KERN_ALERT DEV_LABEL "(itf %d): system parity "
1067                            "error at 0x%08x\n",dev->number,zin(ADDR));
1068                if (reason & uPD98401_INT_CPE)
1069                        printk(KERN_ALERT DEV_LABEL "(itf %d): control memory "
1070                            "parity error at 0x%08x\n",dev->number,zin(ADDR));
1071                if (reason & uPD98401_INT_SBE) {
1072                        printk(KERN_ALERT DEV_LABEL "(itf %d): system bus "
1073                            "error at 0x%08x\n",dev->number,zin(ADDR));
1074                        event_dump();
1075                }
1076                /* don't handle IND */
1077                if (reason & uPD98401_INT_MF) {
1078                        printk(KERN_CRIT DEV_LABEL "(itf %d): mailbox full "
1079                            "(0x%x)\n",dev->number,(reason & uPD98401_INT_MF)
1080                            >> uPD98401_INT_MF_SHIFT);
1081                        event_dump();
1082                            /* @@@ should try to recover */
1083                }
1084                if (reason & uPD98401_INT_MM) {
1085                        if (reason & 1) poll_rx(dev,0);
1086                        if (reason & 2) poll_rx(dev,1);
1087                        if (reason & 4) poll_tx(dev,2);
1088                        if (reason & 8) poll_tx(dev,3);
1089                }
1090                /* @@@ handle RCRn */
1091        }
1092        return IRQ_RETVAL(handled);
1093}
1094
1095
1096/*----------------------------- (E)EPROM access -----------------------------*/
1097
1098
1099static void eprom_set(struct zatm_dev *zatm_dev, unsigned long value,
1100                      unsigned short cmd)
1101{
1102        int error;
1103
1104        if ((error = pci_write_config_dword(zatm_dev->pci_dev,cmd,value)))
1105                printk(KERN_ERR DEV_LABEL ": PCI write failed (0x%02x)\n",
1106                    error);
1107}
1108
1109
1110static unsigned long eprom_get(struct zatm_dev *zatm_dev, unsigned short cmd)
1111{
1112        unsigned int value;
1113        int error;
1114
1115        if ((error = pci_read_config_dword(zatm_dev->pci_dev,cmd,&value)))
1116                printk(KERN_ERR DEV_LABEL ": PCI read failed (0x%02x)\n",
1117                    error);
1118        return value;
1119}
1120
1121
1122static void eprom_put_bits(struct zatm_dev *zatm_dev, unsigned long data,
1123                           int bits, unsigned short cmd)
1124{
1125        unsigned long value;
1126        int i;
1127
1128        for (i = bits-1; i >= 0; i--) {
1129                value = ZEPROM_CS | (((data >> i) & 1) ? ZEPROM_DI : 0);
1130                eprom_set(zatm_dev,value,cmd);
1131                eprom_set(zatm_dev,value | ZEPROM_SK,cmd);
1132                eprom_set(zatm_dev,value,cmd);
1133        }
1134}
1135
1136
1137static void eprom_get_byte(struct zatm_dev *zatm_dev, unsigned char *byte,
1138                           unsigned short cmd)
1139{
1140        int i;
1141
1142        *byte = 0;
1143        for (i = 8; i; i--) {
1144                eprom_set(zatm_dev,ZEPROM_CS,cmd);
1145                eprom_set(zatm_dev,ZEPROM_CS | ZEPROM_SK,cmd);
1146                *byte <<= 1;
1147                if (eprom_get(zatm_dev,cmd) & ZEPROM_DO) *byte |= 1;
1148                eprom_set(zatm_dev,ZEPROM_CS,cmd);
1149        }
1150}
1151
1152
1153static unsigned char eprom_try_esi(struct atm_dev *dev, unsigned short cmd,
1154                                   int offset, int swap)
1155{
1156        unsigned char buf[ZEPROM_SIZE];
1157        struct zatm_dev *zatm_dev;
1158        int i;
1159
1160        zatm_dev = ZATM_DEV(dev);
1161        for (i = 0; i < ZEPROM_SIZE; i += 2) {
1162                eprom_set(zatm_dev,ZEPROM_CS,cmd); /* select EPROM */
1163                eprom_put_bits(zatm_dev,ZEPROM_CMD_READ,ZEPROM_CMD_LEN,cmd);
1164                eprom_put_bits(zatm_dev,i >> 1,ZEPROM_ADDR_LEN,cmd);
1165                eprom_get_byte(zatm_dev,buf+i+swap,cmd);
1166                eprom_get_byte(zatm_dev,buf+i+1-swap,cmd);
1167                eprom_set(zatm_dev,0,cmd); /* deselect EPROM */
1168        }
1169        memcpy(dev->esi,buf+offset,ESI_LEN);
1170        return memcmp(dev->esi,"\0\0\0\0\0",ESI_LEN); /* assumes ESI_LEN == 6 */
1171}
1172
1173
1174static void eprom_get_esi(struct atm_dev *dev)
1175{
1176        if (eprom_try_esi(dev,ZEPROM_V1_REG,ZEPROM_V1_ESI_OFF,1)) return;
1177        (void) eprom_try_esi(dev,ZEPROM_V2_REG,ZEPROM_V2_ESI_OFF,0);
1178}
1179
1180
1181/*--------------------------------- entries ---------------------------------*/
1182
1183
1184static int zatm_init(struct atm_dev *dev)
1185{
1186        struct zatm_dev *zatm_dev;
1187        struct pci_dev *pci_dev;
1188        unsigned short command;
1189        int error,i,last;
1190        unsigned long t0,t1,t2;
1191
1192        DPRINTK(">zatm_init\n");
1193        zatm_dev = ZATM_DEV(dev);
1194        spin_lock_init(&zatm_dev->lock);
1195        pci_dev = zatm_dev->pci_dev;
1196        zatm_dev->base = pci_resource_start(pci_dev, 0);
1197        zatm_dev->irq = pci_dev->irq;
1198        if ((error = pci_read_config_word(pci_dev,PCI_COMMAND,&command))) {
1199                printk(KERN_ERR DEV_LABEL "(itf %d): init error 0x%02x\n",
1200                    dev->number,error);
1201                return -EINVAL;
1202        }
1203        if ((error = pci_write_config_word(pci_dev,PCI_COMMAND,
1204            command | PCI_COMMAND_IO | PCI_COMMAND_MASTER))) {
1205                printk(KERN_ERR DEV_LABEL "(itf %d): can't enable IO (0x%02x)"
1206                    "\n",dev->number,error);
1207                return -EIO;
1208        }
1209        eprom_get_esi(dev);
1210        printk(KERN_NOTICE DEV_LABEL "(itf %d): rev.%d,base=0x%x,irq=%d,",
1211            dev->number,pci_dev->revision,zatm_dev->base,zatm_dev->irq);
1212        /* reset uPD98401 */
1213        zout(0,SWR);
1214        while (!(zin(GSR) & uPD98401_INT_IND));
1215        zout(uPD98401_GMR_ONE /*uPD98401_BURST4*/,GMR);
1216        last = MAX_CRAM_SIZE;
1217        for (i = last-RAM_INCREMENT; i >= 0; i -= RAM_INCREMENT) {
1218                zpokel(zatm_dev,0x55555555,i);
1219                if (zpeekl(zatm_dev,i) != 0x55555555) last = i;
1220                else {
1221                        zpokel(zatm_dev,0xAAAAAAAA,i);
1222                        if (zpeekl(zatm_dev,i) != 0xAAAAAAAA) last = i;
1223                        else zpokel(zatm_dev,i,i);
1224                }
1225        }
1226        for (i = 0; i < last; i += RAM_INCREMENT)
1227                if (zpeekl(zatm_dev,i) != i) break;
1228        zatm_dev->mem = i << 2;
1229        while (i) zpokel(zatm_dev,0,--i);
1230        /* reset again to rebuild memory pointers */
1231        zout(0,SWR);
1232        while (!(zin(GSR) & uPD98401_INT_IND));
1233        zout(uPD98401_GMR_ONE | uPD98401_BURST8 | uPD98401_BURST4 |
1234            uPD98401_BURST2 | uPD98401_GMR_PM | uPD98401_GMR_DR,GMR);
1235        /* TODO: should shrink allocation now */
1236        printk("mem=%dkB,%s (",zatm_dev->mem >> 10,zatm_dev->copper ? "UTP" :
1237            "MMF");
1238        for (i = 0; i < ESI_LEN; i++)
1239                printk("%02X%s",dev->esi[i],i == ESI_LEN-1 ? ")\n" : "-");
1240        do {
1241                unsigned long flags;
1242
1243                spin_lock_irqsave(&zatm_dev->lock, flags);
1244                t0 = zpeekl(zatm_dev,uPD98401_TSR);
1245                udelay(10);
1246                t1 = zpeekl(zatm_dev,uPD98401_TSR);
1247                udelay(1010);
1248                t2 = zpeekl(zatm_dev,uPD98401_TSR);
1249                spin_unlock_irqrestore(&zatm_dev->lock, flags);
1250        }
1251        while (t0 > t1 || t1 > t2); /* loop if wrapping ... */
1252        zatm_dev->khz = t2-2*t1+t0;
1253        printk(KERN_NOTICE DEV_LABEL "(itf %d): uPD98401 %d.%d at %d.%03d "
1254            "MHz\n",dev->number,
1255            (zin(VER) & uPD98401_MAJOR) >> uPD98401_MAJOR_SHIFT,
1256            zin(VER) & uPD98401_MINOR,zatm_dev->khz/1000,zatm_dev->khz % 1000);
1257        return uPD98402_init(dev);
1258}
1259
1260
1261static int zatm_start(struct atm_dev *dev)
1262{
1263        struct zatm_dev *zatm_dev = ZATM_DEV(dev);
1264        struct pci_dev *pdev = zatm_dev->pci_dev;
1265        unsigned long curr;
1266        int pools,vccs,rx;
1267        int error, i, ld;
1268
1269        DPRINTK("zatm_start\n");
1270        zatm_dev->rx_map = zatm_dev->tx_map = NULL;
1271        for (i = 0; i < NR_MBX; i++)
1272                zatm_dev->mbx_start[i] = 0;
1273        error = request_irq(zatm_dev->irq, zatm_int, IRQF_SHARED, DEV_LABEL, dev);
1274        if (error < 0) {
1275                printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
1276                    dev->number,zatm_dev->irq);
1277                goto done;
1278        }
1279        /* define memory regions */
1280        pools = NR_POOLS;
1281        if (NR_SHAPERS*SHAPER_SIZE > pools*POOL_SIZE)
1282                pools = NR_SHAPERS*SHAPER_SIZE/POOL_SIZE;
1283        vccs = (zatm_dev->mem-NR_SHAPERS*SHAPER_SIZE-pools*POOL_SIZE)/
1284            (2*VC_SIZE+RX_SIZE);
1285        ld = -1;
1286        for (rx = 1; rx < vccs; rx <<= 1) ld++;
1287        dev->ci_range.vpi_bits = 0; /* @@@ no VPI for now */
1288        dev->ci_range.vci_bits = ld;
1289        dev->link_rate = ATM_OC3_PCR;
1290        zatm_dev->chans = vccs; /* ??? */
1291        curr = rx*RX_SIZE/4;
1292        DPRINTK("RX pool 0x%08lx\n",curr);
1293        zpokel(zatm_dev,curr,uPD98401_PMA); /* receive pool */
1294        zatm_dev->pool_base = curr;
1295        curr += pools*POOL_SIZE/4;
1296        DPRINTK("Shapers 0x%08lx\n",curr);
1297        zpokel(zatm_dev,curr,uPD98401_SMA); /* shapers */
1298        curr += NR_SHAPERS*SHAPER_SIZE/4;
1299        DPRINTK("Free    0x%08lx\n",curr);
1300        zpokel(zatm_dev,curr,uPD98401_TOS); /* free pool */
1301        printk(KERN_INFO DEV_LABEL "(itf %d): %d shapers, %d pools, %d RX, "
1302            "%ld VCs\n",dev->number,NR_SHAPERS,pools,rx,
1303            (zatm_dev->mem-curr*4)/VC_SIZE);
1304        /* create mailboxes */
1305        for (i = 0; i < NR_MBX; i++) {
1306                void *mbx;
1307                dma_addr_t mbx_dma;
1308
1309                if (!mbx_entries[i])
1310                        continue;
1311                mbx = dma_alloc_coherent(&pdev->dev,
1312                                         2 * MBX_SIZE(i), &mbx_dma, GFP_KERNEL);
1313                if (!mbx) {
1314                        error = -ENOMEM;
1315                        goto out;
1316                }
1317                /*
1318                 * Alignment provided by dma_alloc_coherent() isn't enough
1319                 * for this device.
1320                 */
1321                if (((unsigned long)mbx ^ mbx_dma) & 0xffff) {
1322                        printk(KERN_ERR DEV_LABEL "(itf %d): system "
1323                               "bus incompatible with driver\n", dev->number);
1324                        dma_free_coherent(&pdev->dev, 2*MBX_SIZE(i), mbx, mbx_dma);
1325                        error = -ENODEV;
1326                        goto out;
1327                }
1328                DPRINTK("mbx@0x%08lx-0x%08lx\n", mbx, mbx + MBX_SIZE(i));
1329                zatm_dev->mbx_start[i] = (unsigned long)mbx;
1330                zatm_dev->mbx_dma[i] = mbx_dma;
1331                zatm_dev->mbx_end[i] = (zatm_dev->mbx_start[i] + MBX_SIZE(i)) &
1332                                        0xffff;
1333                zout(mbx_dma >> 16, MSH(i));
1334                zout(mbx_dma, MSL(i));
1335                zout(zatm_dev->mbx_end[i], MBA(i));
1336                zout((unsigned long)mbx & 0xffff, MTA(i));
1337                zout((unsigned long)mbx & 0xffff, MWA(i));
1338        }
1339        error = start_tx(dev);
1340        if (error)
1341                goto out;
1342        error = start_rx(dev);
1343        if (error)
1344                goto out_tx;
1345        error = dev->phy->start(dev);
1346        if (error)
1347                goto out_rx;
1348        zout(0xffffffff,IMR); /* enable interrupts */
1349        /* enable TX & RX */
1350        zout(zin(GMR) | uPD98401_GMR_SE | uPD98401_GMR_RE,GMR);
1351done:
1352        return error;
1353
1354out_rx:
1355        kfree(zatm_dev->rx_map);
1356out_tx:
1357        kfree(zatm_dev->tx_map);
1358out:
1359        while (i-- > 0) {
1360                dma_free_coherent(&pdev->dev, 2 * MBX_SIZE(i),
1361                                  (void *)zatm_dev->mbx_start[i],
1362                                  zatm_dev->mbx_dma[i]);
1363        }
1364        free_irq(zatm_dev->irq, dev);
1365        goto done;
1366}
1367
1368
1369static void zatm_close(struct atm_vcc *vcc)
1370{
1371        DPRINTK(">zatm_close\n");
1372        if (!ZATM_VCC(vcc)) return;
1373        clear_bit(ATM_VF_READY,&vcc->flags);
1374        close_rx(vcc);
1375        EVENT("close_tx\n",0,0);
1376        close_tx(vcc);
1377        DPRINTK("zatm_close: done waiting\n");
1378        /* deallocate memory */
1379        kfree(ZATM_VCC(vcc));
1380        vcc->dev_data = NULL;
1381        clear_bit(ATM_VF_ADDR,&vcc->flags);
1382}
1383
1384
1385static int zatm_open(struct atm_vcc *vcc)
1386{
1387        struct zatm_dev *zatm_dev;
1388        struct zatm_vcc *zatm_vcc;
1389        short vpi = vcc->vpi;
1390        int vci = vcc->vci;
1391        int error;
1392
1393        DPRINTK(">zatm_open\n");
1394        zatm_dev = ZATM_DEV(vcc->dev);
1395        if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1396                vcc->dev_data = NULL;
1397        if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1398                set_bit(ATM_VF_ADDR,&vcc->flags);
1399        if (vcc->qos.aal != ATM_AAL5) return -EINVAL; /* @@@ AAL0 */
1400        DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1401            vcc->vci);
1402        if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) {
1403                zatm_vcc = kmalloc(sizeof(*zatm_vcc), GFP_KERNEL);
1404                if (!zatm_vcc) {
1405                        clear_bit(ATM_VF_ADDR,&vcc->flags);
1406                        return -ENOMEM;
1407                }
1408                vcc->dev_data = zatm_vcc;
1409                ZATM_VCC(vcc)->tx_chan = 0; /* for zatm_close after open_rx */
1410                if ((error = open_rx_first(vcc))) {
1411                        zatm_close(vcc);
1412                        return error;
1413                }
1414                if ((error = open_tx_first(vcc))) {
1415                        zatm_close(vcc);
1416                        return error;
1417                }
1418        }
1419        if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1420        if ((error = open_rx_second(vcc))) {
1421                zatm_close(vcc);
1422                return error;
1423        }
1424        if ((error = open_tx_second(vcc))) {
1425                zatm_close(vcc);
1426                return error;
1427        }
1428        set_bit(ATM_VF_READY,&vcc->flags);
1429        return 0;
1430}
1431
1432
1433static int zatm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flags)
1434{
1435        printk("Not yet implemented\n");
1436        return -ENOSYS;
1437        /* @@@ */
1438}
1439
1440
1441static int zatm_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
1442{
1443        struct zatm_dev *zatm_dev;
1444        unsigned long flags;
1445
1446        zatm_dev = ZATM_DEV(dev);
1447        switch (cmd) {
1448                case ZATM_GETPOOLZ:
1449                        if (!capable(CAP_NET_ADMIN)) return -EPERM;
1450                        /* fall through */
1451                case ZATM_GETPOOL:
1452                        {
1453                                struct zatm_pool_info info;
1454                                int pool;
1455
1456                                if (get_user(pool,
1457                                    &((struct zatm_pool_req __user *) arg)->pool_num))
1458                                        return -EFAULT;
1459                                if (pool < 0 || pool > ZATM_LAST_POOL)
1460                                        return -EINVAL;
1461                                spin_lock_irqsave(&zatm_dev->lock, flags);
1462                                info = zatm_dev->pool_info[pool];
1463                                if (cmd == ZATM_GETPOOLZ) {
1464                                        zatm_dev->pool_info[pool].rqa_count = 0;
1465                                        zatm_dev->pool_info[pool].rqu_count = 0;
1466                                }
1467                                spin_unlock_irqrestore(&zatm_dev->lock, flags);
1468                                return copy_to_user(
1469                                    &((struct zatm_pool_req __user *) arg)->info,
1470                                    &info,sizeof(info)) ? -EFAULT : 0;
1471                        }
1472                case ZATM_SETPOOL:
1473                        {
1474                                struct zatm_pool_info info;
1475                                int pool;
1476
1477                                if (!capable(CAP_NET_ADMIN)) return -EPERM;
1478                                if (get_user(pool,
1479                                    &((struct zatm_pool_req __user *) arg)->pool_num))
1480                                        return -EFAULT;
1481                                if (pool < 0 || pool > ZATM_LAST_POOL)
1482                                        return -EINVAL;
1483                                if (copy_from_user(&info,
1484                                    &((struct zatm_pool_req __user *) arg)->info,
1485                                    sizeof(info))) return -EFAULT;
1486                                if (!info.low_water)
1487                                        info.low_water = zatm_dev->
1488                                            pool_info[pool].low_water;
1489                                if (!info.high_water)
1490                                        info.high_water = zatm_dev->
1491                                            pool_info[pool].high_water;
1492                                if (!info.next_thres)
1493                                        info.next_thres = zatm_dev->
1494                                            pool_info[pool].next_thres;
1495                                if (info.low_water >= info.high_water ||
1496                                    info.low_water < 0)
1497                                        return -EINVAL;
1498                                spin_lock_irqsave(&zatm_dev->lock, flags);
1499                                zatm_dev->pool_info[pool].low_water =
1500                                    info.low_water;
1501                                zatm_dev->pool_info[pool].high_water =
1502                                    info.high_water;
1503                                zatm_dev->pool_info[pool].next_thres =
1504                                    info.next_thres;
1505                                spin_unlock_irqrestore(&zatm_dev->lock, flags);
1506                                return 0;
1507                        }
1508                default:
1509                        if (!dev->phy->ioctl) return -ENOIOCTLCMD;
1510                        return dev->phy->ioctl(dev,cmd,arg);
1511        }
1512}
1513
1514
1515static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname,
1516    void __user *optval,int optlen)
1517{
1518        return -EINVAL;
1519}
1520
1521
1522static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname,
1523    void __user *optval,unsigned int optlen)
1524{
1525        return -EINVAL;
1526}
1527
1528static int zatm_send(struct atm_vcc *vcc,struct sk_buff *skb)
1529{
1530        int error;
1531
1532        EVENT(">zatm_send 0x%lx\n",(unsigned long) skb,0);
1533        if (!ZATM_VCC(vcc)->tx_chan || !test_bit(ATM_VF_READY,&vcc->flags)) {
1534                if (vcc->pop) vcc->pop(vcc,skb);
1535                else dev_kfree_skb(skb);
1536                return -EINVAL;
1537        }
1538        if (!skb) {
1539                printk(KERN_CRIT "!skb in zatm_send ?\n");
1540                if (vcc->pop) vcc->pop(vcc,skb);
1541                return -EINVAL;
1542        }
1543        ATM_SKB(skb)->vcc = vcc;
1544        error = do_tx(skb);
1545        if (error != RING_BUSY) return error;
1546        skb_queue_tail(&ZATM_VCC(vcc)->backlog,skb);
1547        return 0;
1548}
1549
1550
1551static void zatm_phy_put(struct atm_dev *dev,unsigned char value,
1552    unsigned long addr)
1553{
1554        struct zatm_dev *zatm_dev;
1555
1556        zatm_dev = ZATM_DEV(dev);
1557        zwait;
1558        zout(value,CER);
1559        zout(uPD98401_IND_ACC | uPD98401_IA_B0 |
1560            (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1561}
1562
1563
1564static unsigned char zatm_phy_get(struct atm_dev *dev,unsigned long addr)
1565{
1566        struct zatm_dev *zatm_dev;
1567
1568        zatm_dev = ZATM_DEV(dev);
1569        zwait;
1570        zout(uPD98401_IND_ACC | uPD98401_IA_B0 | uPD98401_IA_RW |
1571          (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1572        zwait;
1573        return zin(CER) & 0xff;
1574}
1575
1576
1577static const struct atmdev_ops ops = {
1578        .open           = zatm_open,
1579        .close          = zatm_close,
1580        .ioctl          = zatm_ioctl,
1581        .getsockopt     = zatm_getsockopt,
1582        .setsockopt     = zatm_setsockopt,
1583        .send           = zatm_send,
1584        .phy_put        = zatm_phy_put,
1585        .phy_get        = zatm_phy_get,
1586        .change_qos     = zatm_change_qos,
1587};
1588
1589static int zatm_init_one(struct pci_dev *pci_dev,
1590                         const struct pci_device_id *ent)
1591{
1592        struct atm_dev *dev;
1593        struct zatm_dev *zatm_dev;
1594        int ret = -ENOMEM;
1595
1596        zatm_dev = kmalloc(sizeof(*zatm_dev), GFP_KERNEL);
1597        if (!zatm_dev) {
1598                printk(KERN_EMERG "%s: memory shortage\n", DEV_LABEL);
1599                goto out;
1600        }
1601
1602        dev = atm_dev_register(DEV_LABEL, &pci_dev->dev, &ops, -1, NULL);
1603        if (!dev)
1604                goto out_free;
1605
1606        ret = pci_enable_device(pci_dev);
1607        if (ret < 0)
1608                goto out_deregister;
1609
1610        ret = pci_request_regions(pci_dev, DEV_LABEL);
1611        if (ret < 0)
1612                goto out_disable;
1613
1614        ret = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32));
1615        if (ret < 0)
1616                goto out_disable;
1617
1618        zatm_dev->pci_dev = pci_dev;
1619        dev->dev_data = zatm_dev;
1620        zatm_dev->copper = (int)ent->driver_data;
1621        if ((ret = zatm_init(dev)) || (ret = zatm_start(dev)))
1622                goto out_release;
1623
1624        pci_set_drvdata(pci_dev, dev);
1625        zatm_dev->more = zatm_boards;
1626        zatm_boards = dev;
1627        ret = 0;
1628out:
1629        return ret;
1630
1631out_release:
1632        pci_release_regions(pci_dev);
1633out_disable:
1634        pci_disable_device(pci_dev);
1635out_deregister:
1636        atm_dev_deregister(dev);
1637out_free:
1638        kfree(zatm_dev);
1639        goto out;
1640}
1641
1642
1643MODULE_LICENSE("GPL");
1644
1645static struct pci_device_id zatm_pci_tbl[] = {
1646        { PCI_VDEVICE(ZEITNET, PCI_DEVICE_ID_ZEITNET_1221), ZATM_COPPER },
1647        { PCI_VDEVICE(ZEITNET, PCI_DEVICE_ID_ZEITNET_1225), 0 },
1648        { 0, }
1649};
1650MODULE_DEVICE_TABLE(pci, zatm_pci_tbl);
1651
1652static struct pci_driver zatm_driver = {
1653        .name =         DEV_LABEL,
1654        .id_table =     zatm_pci_tbl,
1655        .probe =        zatm_init_one,
1656};
1657
1658static int __init zatm_init_module(void)
1659{
1660        return pci_register_driver(&zatm_driver);
1661}
1662
1663module_init(zatm_init_module);
1664/* module_exit not defined so not unloadable */
1665