drivers/atm/zatm.c

   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/system.h>
  28 #include <asm/string.h>
  29 #include <asm/io.h>
  30 #include <asm/atomic.h>
  31 #include <asm/uaccess.h>
  32
  33 #include "uPD98401.h"
  34 #include "uPD98402.h"
  35 #include "zeprom.h"
  36 #include "zatm.h"
  37
  38
  39 /*
  40  * TODO:
  41  *
  42  * Minor features
  43  *  - support 64 kB SDUs (will have to use multibuffer batches then :-( )
  44  *  - proper use of CDV, credit = max(1,CDVT*PCR)
  45  *  - AAL0
  46  *  - better receive timestamps
  47  *  - OAM
  48  */
  49
  50 #define ZATM_COPPER     1
  51
  52 #if 0
  53 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
  54 #else
  55 #define DPRINTK(format,args...)
  56 #endif
  57
  58 #ifndef CONFIG_ATM_ZATM_DEBUG
  59
  60
  61 #define NULLCHECK(x)
  62
  63 #define EVENT(s,a,b)
  64
  65
  66 static void event_dump(void)
  67 {
  68 }
  69
  70
  71 #else
  72
  73
  74 /*
  75  * NULL pointer checking
  76  */
  77
  78 #define NULLCHECK(x) \
  79   if ((unsigned long) (x) < 0x30) printk(KERN_CRIT #x "==0x%x\n", (int) (x))
  80
  81 /*
  82  * Very extensive activity logging. Greatly improves bug detection speed but
  83  * costs a few Mbps if enabled.
  84  */
  85
  86 #define EV 64
  87
  88 static const char *ev[EV];
  89 static unsigned long ev_a[EV],ev_b[EV];
  90 static int ec = 0;
  91
  92
  93 static void EVENT(const char *s,unsigned long a,unsigned long b)
  94 {
  95         ev[ec] = s;
  96         ev_a[ec] = a;
  97         ev_b[ec] = b;
  98         ec = (ec+1) % EV;
  99 }
 100
 101
 102 static void event_dump(void)
 103 {
 104         int n,i;
 105
 106         printk(KERN_NOTICE "----- event dump follows -----\n");
 107         for (n = 0; n < EV; n++) {
 108                 i = (ec+n) % EV;
 109                 printk(KERN_NOTICE);
 110                 printk(ev[i] ? ev[i] : "(null)",ev_a[i],ev_b[i]);
 111         }
 112         printk(KERN_NOTICE "----- event dump ends here -----\n");
 113 }
 114
 115
 116 #endif /* CONFIG_ATM_ZATM_DEBUG */
 117
 118
 119 #define RING_BUSY       1       /* indication from do_tx that PDU has to be
 120                                    backlogged */
 121
 122 static struct atm_dev *zatm_boards = NULL;
 123 static unsigned long dummy[2] = {0,0};
 124
 125
 126 #define zin_n(r) inl(zatm_dev->base+r*4)
 127 #define zin(r) inl(zatm_dev->base+uPD98401_##r*4)
 128 #define zout(v,r) outl(v,zatm_dev->base+uPD98401_##r*4)
 129 #define zwait while (zin(CMR) & uPD98401_BUSY)
 130
 131 /* RX0, RX1, TX0, TX1 */
 132 static const int mbx_entries[NR_MBX] = { 1024,1024,1024,1024 };
 133 static const int mbx_esize[NR_MBX] = { 16,16,4,4 }; /* entry size in bytes */
 134
 135 #define MBX_SIZE(i) (mbx_entries[i]*mbx_esize[i])
 136
 137
 138 /*-------------------------------- utilities --------------------------------*/
 139
 140
 141 static void zpokel(struct zatm_dev *zatm_dev,u32 value,u32 addr)
 142 {
 143         zwait;
 144         zout(value,CER);
 145         zout(uPD98401_IND_ACC | uPD98401_IA_BALL |
 146             (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
 147 }
 148
 149
 150 static u32 zpeekl(struct zatm_dev *zatm_dev,u32 addr)
 151 {
 152         zwait;
 153         zout(uPD98401_IND_ACC | uPD98401_IA_BALL | uPD98401_IA_RW |
 154           (uPD98401_IA_TGT_CM << uPD98401_IA_TGT_SHIFT) | addr,CMR);
 155         zwait;
 156         return zin(CER);
 157 }
 158
 159
 160 /*------------------------------- free lists --------------------------------*/
 161
 162
 163 /*
 164  * Free buffer head structure:
 165  *   [0] pointer to buffer (for SAR)
 166  *   [1] buffer descr link pointer (for SAR)
 167  *   [2] back pointer to skb (for poll_rx)
 168  *   [3] data
 169  *   ...
 170  */
 171
 172 struct rx_buffer_head {
 173         u32             buffer; /* pointer to buffer (for SAR) */
 174         u32             link;   /* buffer descriptor link pointer (for SAR) */
 175         struct sk_buff  *skb;   /* back pointer to skb (for poll_rx) */
 176 };
 177
 178
 179 static void refill_pool(struct atm_dev *dev,int pool)
 180 {
 181         struct zatm_dev *zatm_dev;
 182         struct sk_buff *skb;
 183         struct rx_buffer_head *first;
 184         unsigned long flags;
 185         int align,offset,free,count,size;
 186
 187         EVENT("refill_pool\n",0,0);
 188         zatm_dev = ZATM_DEV(dev);
 189         size = (64 << (pool <= ZATM_AAL5_POOL_BASE ? 0 :
 190             pool-ZATM_AAL5_POOL_BASE))+sizeof(struct rx_buffer_head);
 191         if (size < PAGE_SIZE) {
 192                 align = 32; /* for 32 byte alignment */
 193                 offset = sizeof(struct rx_buffer_head);
 194         }
 195         else {
 196                 align = 4096;
 197                 offset = zatm_dev->pool_info[pool].offset+
 198                     sizeof(struct rx_buffer_head);
 199         }
 200         size += align;
 201         spin_lock_irqsave(&zatm_dev->lock, flags);
 202         free = zpeekl(zatm_dev,zatm_dev->pool_base+2*pool) &
 203             uPD98401_RXFP_REMAIN;
 204         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 205         if (free >= zatm_dev->pool_info[pool].low_water) return;
 206         EVENT("starting ... POOL: 0x%x, 0x%x\n",
 207             zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
 208             zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
 209         EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
 210         count = 0;
 211         first = NULL;
 212         while (free < zatm_dev->pool_info[pool].high_water) {
 213                 struct rx_buffer_head *head;
 214
 215                 skb = alloc_skb(size,GFP_ATOMIC);
 216                 if (!skb) {
 217                         printk(KERN_WARNING DEV_LABEL "(Itf %d): got no new "
 218                             "skb (%d) with %d free\n",dev->number,size,free);
 219                         break;
 220                 }
 221                 skb_reserve(skb,(unsigned char *) ((((unsigned long) skb->data+
 222                     align+offset-1) & ~(unsigned long) (align-1))-offset)-
 223                     skb->data);
 224                 head = (struct rx_buffer_head *) skb->data;
 225                 skb_reserve(skb,sizeof(struct rx_buffer_head));
 226                 if (!first) first = head;
 227                 count++;
 228                 head->buffer = virt_to_bus(skb->data);
 229                 head->link = 0;
 230                 head->skb = skb;
 231                 EVENT("enq skb 0x%08lx/0x%08lx\n",(unsigned long) skb,
 232                     (unsigned long) head);
 233                 spin_lock_irqsave(&zatm_dev->lock, flags);
 234                 if (zatm_dev->last_free[pool])
 235                         ((struct rx_buffer_head *) (zatm_dev->last_free[pool]->
 236                             data))[-1].link = virt_to_bus(head);
 237                 zatm_dev->last_free[pool] = skb;
 238                 skb_queue_tail(&zatm_dev->pool[pool],skb);
 239                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
 240                 free++;
 241         }
 242         if (first) {
 243                 spin_lock_irqsave(&zatm_dev->lock, flags);
 244                 zwait;
 245                 zout(virt_to_bus(first),CER);
 246                 zout(uPD98401_ADD_BAT | (pool << uPD98401_POOL_SHIFT) | count,
 247                     CMR);
 248                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
 249                 EVENT ("POOL: 0x%x, 0x%x\n",
 250                     zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
 251                     zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
 252                 EVENT("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
 253         }
 254 }
 255
 256
 257 static void drain_free(struct atm_dev *dev,int pool)
 258 {
 259         skb_queue_purge(&ZATM_DEV(dev)->pool[pool]);
 260 }
 261
 262
 263 static int pool_index(int max_pdu)
 264 {
 265         int i;
 266
 267         if (max_pdu % ATM_CELL_PAYLOAD)
 268                 printk(KERN_ERR DEV_LABEL ": driver error in pool_index: "
 269                     "max_pdu is %d\n",max_pdu);
 270         if (max_pdu > 65536) return -1;
 271         for (i = 0; (64 << i) < max_pdu; i++);
 272         return i+ZATM_AAL5_POOL_BASE;
 273 }
 274
 275
 276 /* use_pool isn't reentrant */
 277
 278
 279 static void use_pool(struct atm_dev *dev,int pool)
 280 {
 281         struct zatm_dev *zatm_dev;
 282         unsigned long flags;
 283         int size;
 284
 285         zatm_dev = ZATM_DEV(dev);
 286         if (!(zatm_dev->pool_info[pool].ref_count++)) {
 287                 skb_queue_head_init(&zatm_dev->pool[pool]);
 288                 size = pool-ZATM_AAL5_POOL_BASE;
 289                 if (size < 0) size = 0; /* 64B... */
 290                 else if (size > 10) size = 10; /* ... 64kB */
 291                 spin_lock_irqsave(&zatm_dev->lock, flags);
 292                 zpokel(zatm_dev,((zatm_dev->pool_info[pool].low_water/4) <<
 293                     uPD98401_RXFP_ALERT_SHIFT) |
 294                     (1 << uPD98401_RXFP_BTSZ_SHIFT) |
 295                     (size << uPD98401_RXFP_BFSZ_SHIFT),
 296                     zatm_dev->pool_base+pool*2);
 297                 zpokel(zatm_dev,(unsigned long) dummy,zatm_dev->pool_base+
 298                     pool*2+1);
 299                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
 300                 zatm_dev->last_free[pool] = NULL;
 301                 refill_pool(dev,pool);
 302         }
 303         DPRINTK("pool %d: %d\n",pool,zatm_dev->pool_info[pool].ref_count);
 304 }
 305
 306
 307 static void unuse_pool(struct atm_dev *dev,int pool)
 308 {
 309         if (!(--ZATM_DEV(dev)->pool_info[pool].ref_count))
 310                 drain_free(dev,pool);
 311 }
 312
 313 /*----------------------------------- RX ------------------------------------*/
 314
 315
 316 #if 0
 317 static void exception(struct atm_vcc *vcc)
 318 {
 319    static int count = 0;
 320    struct zatm_dev *zatm_dev = ZATM_DEV(vcc->dev);
 321    struct zatm_vcc *zatm_vcc = ZATM_VCC(vcc);
 322    unsigned long *qrp;
 323    int i;
 324
 325    if (count++ > 2) return;
 326    for (i = 0; i < 8; i++)
 327         printk("TX%d: 0x%08lx\n",i,
 328           zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+i));
 329    for (i = 0; i < 5; i++)
 330         printk("SH%d: 0x%08lx\n",i,
 331           zpeekl(zatm_dev,uPD98401_IM(zatm_vcc->shaper)+16*i));
 332    qrp = (unsigned long *) zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
 333      uPD98401_TXVC_QRP);
 334    printk("qrp=0x%08lx\n",(unsigned long) qrp);
 335    for (i = 0; i < 4; i++) printk("QRP[%d]: 0x%08lx",i,qrp[i]);
 336 }
 337 #endif
 338
 339
 340 static const char *err_txt[] = {
 341         "No error",
 342         "RX buf underflow",
 343         "RX FIFO overrun",
 344         "Maximum len violation",
 345         "CRC error",
 346         "User abort",
 347         "Length violation",
 348         "T1 error",
 349         "Deactivated",
 350         "???",
 351         "???",
 352         "???",
 353         "???",
 354         "???",
 355         "???",
 356         "???"
 357 };
 358
 359
 360 static void poll_rx(struct atm_dev *dev,int mbx)
 361 {
 362         struct zatm_dev *zatm_dev;
 363         unsigned long pos;
 364         u32 x;
 365         int error;
 366
 367         EVENT("poll_rx\n",0,0);
 368         zatm_dev = ZATM_DEV(dev);
 369         pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
 370         while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
 371                 u32 *here;
 372                 struct sk_buff *skb;
 373                 struct atm_vcc *vcc;
 374                 int cells,size,chan;
 375
 376                 EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
 377                 here = (u32 *) pos;
 378                 if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx])
 379                         pos = zatm_dev->mbx_start[mbx];
 380                 cells = here[0] & uPD98401_AAL5_SIZE;
 381 #if 0
 382 printk("RX IND: 0x%x, 0x%x, 0x%x, 0x%x\n",here[0],here[1],here[2],here[3]);
 383 {
 384 unsigned long *x;
 385                 printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev,
 386                       zatm_dev->pool_base),
 387                       zpeekl(zatm_dev,zatm_dev->pool_base+1));
 388                 x = (unsigned long *) here[2];
 389                 printk("[0..3] = 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",
 390                     x[0],x[1],x[2],x[3]);
 391 }
 392 #endif
 393                 error = 0;
 394                 if (here[3] & uPD98401_AAL5_ERR) {
 395                         error = (here[3] & uPD98401_AAL5_ES) >>
 396                             uPD98401_AAL5_ES_SHIFT;
 397                         if (error == uPD98401_AAL5_ES_DEACT ||
 398                             error == uPD98401_AAL5_ES_FREE) continue;
 399                 }
 400 EVENT("error code 0x%x/0x%x\n",(here[3] & uPD98401_AAL5_ES) >>
 401   uPD98401_AAL5_ES_SHIFT,error);
 402                 skb = ((struct rx_buffer_head *) bus_to_virt(here[2]))->skb;
 403                 __net_timestamp(skb);
 404 #if 0
 405 printk("[-3..0] 0x%08lx 0x%08lx 0x%08lx 0x%08lx\n",((unsigned *) skb->data)[-3],
 406   ((unsigned *) skb->data)[-2],((unsigned *) skb->data)[-1],
 407   ((unsigned *) skb->data)[0]);
 408 #endif
 409                 EVENT("skb 0x%lx, here 0x%lx\n",(unsigned long) skb,
 410                     (unsigned long) here);
 411 #if 0
 412 printk("dummy: 0x%08lx, 0x%08lx\n",dummy[0],dummy[1]);
 413 #endif
 414                 size = error ? 0 : ntohs(((__be16 *) skb->data)[cells*
 415                     ATM_CELL_PAYLOAD/sizeof(u16)-3]);
 416                 EVENT("got skb 0x%lx, size %d\n",(unsigned long) skb,size);
 417                 chan = (here[3] & uPD98401_AAL5_CHAN) >>
 418                     uPD98401_AAL5_CHAN_SHIFT;
 419                 if (chan < zatm_dev->chans && zatm_dev->rx_map[chan]) {
 420                         int pos;
 421                         vcc = zatm_dev->rx_map[chan];
 422                         pos = ZATM_VCC(vcc)->pool;
 423                         if (skb == zatm_dev->last_free[pos])
 424                                 zatm_dev->last_free[pos] = NULL;
 425                         skb_unlink(skb, zatm_dev->pool + pos);
 426                 }
 427                 else {
 428                         printk(KERN_ERR DEV_LABEL "(itf %d): RX indication "
 429                             "for non-existing channel\n",dev->number);
 430                         size = 0;
 431                         vcc = NULL;
 432                         event_dump();
 433                 }
 434                 if (error) {
 435                         static unsigned long silence = 0;
 436                         static int last_error = 0;
 437
 438                         if (error != last_error ||
 439                             time_after(jiffies, silence)  || silence == 0){
 440                                 printk(KERN_WARNING DEV_LABEL "(itf %d): "
 441                                     "chan %d error %s\n",dev->number,chan,
 442                                     err_txt[error]);
 443                                 last_error = error;
 444                                 silence = (jiffies+2*HZ)|1;
 445                         }
 446                         size = 0;
 447                 }
 448                 if (size && (size > cells*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER ||
 449                     size <= (cells-1)*ATM_CELL_PAYLOAD-ATM_AAL5_TRAILER)) {
 450                         printk(KERN_ERR DEV_LABEL "(itf %d): size %d with %d "
 451                             "cells\n",dev->number,size,cells);
 452                         size = 0;
 453                         event_dump();
 454                 }
 455                 if (size > ATM_MAX_AAL5_PDU) {
 456                         printk(KERN_ERR DEV_LABEL "(itf %d): size too big "
 457                             "(%d)\n",dev->number,size);
 458                         size = 0;
 459                         event_dump();
 460                 }
 461                 if (!size) {
 462                         dev_kfree_skb_irq(skb);
 463                         if (vcc) atomic_inc(&vcc->stats->rx_err);
 464                         continue;
 465                 }
 466                 if (!atm_charge(vcc,skb->truesize)) {
 467                         dev_kfree_skb_irq(skb);
 468                         continue;
 469                 }
 470                 skb->len = size;
 471                 ATM_SKB(skb)->vcc = vcc;
 472                 vcc->push(vcc,skb);
 473                 atomic_inc(&vcc->stats->rx);
 474         }
 475         zout(pos & 0xffff,MTA(mbx));
 476 #if 0 /* probably a stupid idea */
 477         refill_pool(dev,zatm_vcc->pool);
 478                 /* maybe this saves us a few interrupts */
 479 #endif
 480 }
 481
 482
 483 static int open_rx_first(struct atm_vcc *vcc)
 484 {
 485         struct zatm_dev *zatm_dev;
 486         struct zatm_vcc *zatm_vcc;
 487         unsigned long flags;
 488         unsigned short chan;
 489         int cells;
 490
 491         DPRINTK("open_rx_first (0x%x)\n",inb_p(0xc053));
 492         zatm_dev = ZATM_DEV(vcc->dev);
 493         zatm_vcc = ZATM_VCC(vcc);
 494         zatm_vcc->rx_chan = 0;
 495         if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0;
 496         if (vcc->qos.aal == ATM_AAL5) {
 497                 if (vcc->qos.rxtp.max_sdu > 65464)
 498                         vcc->qos.rxtp.max_sdu = 65464;
 499                         /* fix this - we may want to receive 64kB SDUs
 500                            later */
 501                 cells = DIV_ROUND_UP(vcc->qos.rxtp.max_sdu + ATM_AAL5_TRAILER,
 502                                 ATM_CELL_PAYLOAD);
 503                 zatm_vcc->pool = pool_index(cells*ATM_CELL_PAYLOAD);
 504         }
 505         else {
 506                 cells = 1;
 507                 zatm_vcc->pool = ZATM_AAL0_POOL;
 508         }
 509         if (zatm_vcc->pool < 0) return -EMSGSIZE;
 510         spin_lock_irqsave(&zatm_dev->lock, flags);
 511         zwait;
 512         zout(uPD98401_OPEN_CHAN,CMR);
 513         zwait;
 514         DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER));
 515         chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT;
 516         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 517         DPRINTK("chan is %d\n",chan);
 518         if (!chan) return -EAGAIN;
 519         use_pool(vcc->dev,zatm_vcc->pool);
 520         DPRINTK("pool %d\n",zatm_vcc->pool);
 521         /* set up VC descriptor */
 522         spin_lock_irqsave(&zatm_dev->lock, flags);
 523         zpokel(zatm_dev,zatm_vcc->pool << uPD98401_RXVC_POOL_SHIFT,
 524             chan*VC_SIZE/4);
 525         zpokel(zatm_dev,uPD98401_RXVC_OD | (vcc->qos.aal == ATM_AAL5 ?
 526             uPD98401_RXVC_AR : 0) | cells,chan*VC_SIZE/4+1);
 527         zpokel(zatm_dev,0,chan*VC_SIZE/4+2);
 528         zatm_vcc->rx_chan = chan;
 529         zatm_dev->rx_map[chan] = vcc;
 530         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 531         return 0;
 532 }
 533
 534
 535 static int open_rx_second(struct atm_vcc *vcc)
 536 {
 537         struct zatm_dev *zatm_dev;
 538         struct zatm_vcc *zatm_vcc;
 539         unsigned long flags;
 540         int pos,shift;
 541
 542         DPRINTK("open_rx_second (0x%x)\n",inb_p(0xc053));
 543         zatm_dev = ZATM_DEV(vcc->dev);
 544         zatm_vcc = ZATM_VCC(vcc);
 545         if (!zatm_vcc->rx_chan) return 0;
 546         spin_lock_irqsave(&zatm_dev->lock, flags);
 547         /* should also handle VPI @@@ */
 548         pos = vcc->vci >> 1;
 549         shift = (1-(vcc->vci & 1)) << 4;
 550         zpokel(zatm_dev,(zpeekl(zatm_dev,pos) & ~(0xffff << shift)) |
 551             ((zatm_vcc->rx_chan | uPD98401_RXLT_ENBL) << shift),pos);
 552         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 553         return 0;
 554 }
 555
 556
 557 static void close_rx(struct atm_vcc *vcc)
 558 {
 559         struct zatm_dev *zatm_dev;
 560         struct zatm_vcc *zatm_vcc;
 561         unsigned long flags;
 562         int pos,shift;
 563
 564         zatm_vcc = ZATM_VCC(vcc);
 565         zatm_dev = ZATM_DEV(vcc->dev);
 566         if (!zatm_vcc->rx_chan) return;
 567         DPRINTK("close_rx\n");
 568         /* disable receiver */
 569         if (vcc->vpi != ATM_VPI_UNSPEC && vcc->vci != ATM_VCI_UNSPEC) {
 570                 spin_lock_irqsave(&zatm_dev->lock, flags);
 571                 pos = vcc->vci >> 1;
 572                 shift = (1-(vcc->vci & 1)) << 4;
 573                 zpokel(zatm_dev,zpeekl(zatm_dev,pos) & ~(0xffff << shift),pos);
 574                 zwait;
 575                 zout(uPD98401_NOP,CMR);
 576                 zwait;
 577                 zout(uPD98401_NOP,CMR);
 578                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
 579         }
 580         spin_lock_irqsave(&zatm_dev->lock, flags);
 581         zwait;
 582         zout(uPD98401_DEACT_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
 583             uPD98401_CHAN_ADDR_SHIFT),CMR);
 584         zwait;
 585         udelay(10); /* why oh why ... ? */
 586         zout(uPD98401_CLOSE_CHAN | uPD98401_CHAN_RT | (zatm_vcc->rx_chan <<
 587             uPD98401_CHAN_ADDR_SHIFT),CMR);
 588         zwait;
 589         if (!(zin(CMR) & uPD98401_CHAN_ADDR))
 590                 printk(KERN_CRIT DEV_LABEL "(itf %d): can't close RX channel "
 591                     "%d\n",vcc->dev->number,zatm_vcc->rx_chan);
 592         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 593         zatm_dev->rx_map[zatm_vcc->rx_chan] = NULL;
 594         zatm_vcc->rx_chan = 0;
 595         unuse_pool(vcc->dev,zatm_vcc->pool);
 596 }
 597
 598
 599 static int start_rx(struct atm_dev *dev)
 600 {
 601         struct zatm_dev *zatm_dev;
 602         int size,i;
 603
 604 DPRINTK("start_rx\n");
 605         zatm_dev = ZATM_DEV(dev);
 606         size = sizeof(struct atm_vcc *)*zatm_dev->chans;
 607         zatm_dev->rx_map =  kzalloc(size,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
 630 static 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 {
 665 printk("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
 710 static 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 */
 724 if (*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
 742 static 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
 765 NO !
 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
 787 static 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
 851 static 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
 869 static 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
 913 static 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
 972 static 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
 995 static 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(sizeof(struct atm_vcc *)*
1003             zatm_dev->chans,GFP_KERNEL);
1004         if (!zatm_dev->tx_map) return -ENOMEM;
1005         zatm_dev->tx_bw = ATM_OC3_PCR;
1006         zatm_dev->free_shapers = (1 << NR_SHAPERS)-1;
1007         zatm_dev->ubr = -1;
1008         zatm_dev->ubr_ref_cnt = 0;
1009         /* initialize shapers */
1010         for (i = 0; i < NR_SHAPERS; i++) zpokel(zatm_dev,0,uPD98401_PS(i));
1011         return 0;
1012 }
1013
1014
1015 /*------------------------------- interrupts --------------------------------*/
1016
1017
1018 static irqreturn_t zatm_int(int irq,void *dev_id)
1019 {
1020         struct atm_dev *dev;
1021         struct zatm_dev *zatm_dev;
1022         u32 reason;
1023         int handled = 0;
1024
1025         dev = dev_id;
1026         zatm_dev = ZATM_DEV(dev);
1027         while ((reason = zin(GSR))) {
1028                 handled = 1;
1029                 EVENT("reason 0x%x\n",reason,0);
1030                 if (reason & uPD98401_INT_PI) {
1031                         EVENT("PHY int\n",0,0);
1032                         dev->phy->interrupt(dev);
1033                 }
1034                 if (reason & uPD98401_INT_RQA) {
1035                         unsigned long pools;
1036                         int i;
1037
1038                         pools = zin(RQA);
1039                         EVENT("RQA (0x%08x)\n",pools,0);
1040                         for (i = 0; pools; i++) {
1041                                 if (pools & 1) {
1042                                         refill_pool(dev,i);
1043                                         zatm_dev->pool_info[i].rqa_count++;
1044                                 }
1045                                 pools >>= 1;
1046                         }
1047                 }
1048                 if (reason & uPD98401_INT_RQU) {
1049                         unsigned long pools;
1050                         int i;
1051                         pools = zin(RQU);
1052                         printk(KERN_WARNING DEV_LABEL "(itf %d): RQU 0x%08lx\n",
1053                             dev->number,pools);
1054                         event_dump();
1055                         for (i = 0; pools; i++) {
1056                                 if (pools & 1) {
1057                                         refill_pool(dev,i);
1058                                         zatm_dev->pool_info[i].rqu_count++;
1059                                 }
1060                                 pools >>= 1;
1061                         }
1062                 }
1063                 /* don't handle RD */
1064                 if (reason & uPD98401_INT_SPE)
1065                         printk(KERN_ALERT DEV_LABEL "(itf %d): system parity "
1066                             "error at 0x%08x\n",dev->number,zin(ADDR));
1067                 if (reason & uPD98401_INT_CPE)
1068                         printk(KERN_ALERT DEV_LABEL "(itf %d): control memory "
1069                             "parity error at 0x%08x\n",dev->number,zin(ADDR));
1070                 if (reason & uPD98401_INT_SBE) {
1071                         printk(KERN_ALERT DEV_LABEL "(itf %d): system bus "
1072                             "error at 0x%08x\n",dev->number,zin(ADDR));
1073                         event_dump();
1074                 }
1075                 /* don't handle IND */
1076                 if (reason & uPD98401_INT_MF) {
1077                         printk(KERN_CRIT DEV_LABEL "(itf %d): mailbox full "
1078                             "(0x%x)\n",dev->number,(reason & uPD98401_INT_MF)
1079                             >> uPD98401_INT_MF_SHIFT);
1080                         event_dump();
1081                             /* @@@ should try to recover */
1082                 }
1083                 if (reason & uPD98401_INT_MM) {
1084                         if (reason & 1) poll_rx(dev,0);
1085                         if (reason & 2) poll_rx(dev,1);
1086                         if (reason & 4) poll_tx(dev,2);
1087                         if (reason & 8) poll_tx(dev,3);
1088                 }
1089                 /* @@@ handle RCRn */
1090         }
1091         return IRQ_RETVAL(handled);
1092 }
1093
1094
1095 /*----------------------------- (E)EPROM access -----------------------------*/
1096
1097
1098 static void __devinit eprom_set(struct zatm_dev *zatm_dev,unsigned long value,
1099     unsigned short cmd)
1100 {
1101         int error;
1102
1103         if ((error = pci_write_config_dword(zatm_dev->pci_dev,cmd,value)))
1104                 printk(KERN_ERR DEV_LABEL ": PCI write failed (0x%02x)\n",
1105                     error);
1106 }
1107
1108
1109 static unsigned long __devinit eprom_get(struct zatm_dev *zatm_dev,
1110     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
1122 static void __devinit eprom_put_bits(struct zatm_dev *zatm_dev,
1123     unsigned long data,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
1137 static void __devinit eprom_get_byte(struct zatm_dev *zatm_dev,
1138     unsigned char *byte,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
1153 static unsigned char __devinit eprom_try_esi(struct atm_dev *dev,
1154     unsigned short cmd,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
1174 static void __devinit 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
1184 static int __devinit 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
1261 static int __devinit 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 = pci_alloc_consistent(pdev, 2*MBX_SIZE(i), &mbx_dma);
1312                 if (!mbx) {
1313                         error = -ENOMEM;
1314                         goto out;
1315                 }
1316                 /*
1317                  * Alignment provided by pci_alloc_consistent() isn't enough
1318                  * for this device.
1319                  */
1320                 if (((unsigned long)mbx ^ mbx_dma) & 0xffff) {
1321                         printk(KERN_ERR DEV_LABEL "(itf %d): system "
1322                                "bus incompatible with driver\n", dev->number);
1323                         pci_free_consistent(pdev, 2*MBX_SIZE(i), mbx, mbx_dma);
1324                         error = -ENODEV;
1325                         goto out;
1326                 }
1327                 DPRINTK("mbx@0x%08lx-0x%08lx\n", mbx, mbx + MBX_SIZE(i));
1328                 zatm_dev->mbx_start[i] = (unsigned long)mbx;
1329                 zatm_dev->mbx_dma[i] = mbx_dma;
1330                 zatm_dev->mbx_end[i] = (zatm_dev->mbx_start[i] + MBX_SIZE(i)) &
1331                                         0xffff;
1332                 zout(mbx_dma >> 16, MSH(i));
1333                 zout(mbx_dma, MSL(i));
1334                 zout(zatm_dev->mbx_end[i], MBA(i));
1335                 zout((unsigned long)mbx & 0xffff, MTA(i));
1336                 zout((unsigned long)mbx & 0xffff, MWA(i));
1337         }
1338         error = start_tx(dev);
1339         if (error)
1340                 goto out;
1341         error = start_rx(dev);
1342         if (error)
1343                 goto out_tx;
1344         error = dev->phy->start(dev);
1345         if (error)
1346                 goto out_rx;
1347         zout(0xffffffff,IMR); /* enable interrupts */
1348         /* enable TX & RX */
1349         zout(zin(GMR) | uPD98401_GMR_SE | uPD98401_GMR_RE,GMR);
1350 done:
1351         return error;
1352
1353 out_rx:
1354         kfree(zatm_dev->rx_map);
1355 out_tx:
1356         kfree(zatm_dev->tx_map);
1357 out:
1358         while (i-- > 0) {
1359                 pci_free_consistent(pdev, 2*MBX_SIZE(i),
1360                                     (void *)zatm_dev->mbx_start[i],
1361                                     zatm_dev->mbx_dma[i]);
1362         }
1363         free_irq(zatm_dev->irq, dev);
1364         goto done;
1365 }
1366
1367
1368 static void zatm_close(struct atm_vcc *vcc)
1369 {
1370         DPRINTK(">zatm_close\n");
1371         if (!ZATM_VCC(vcc)) return;
1372         clear_bit(ATM_VF_READY,&vcc->flags);
1373         close_rx(vcc);
1374         EVENT("close_tx\n",0,0);
1375         close_tx(vcc);
1376         DPRINTK("zatm_close: done waiting\n");
1377         /* deallocate memory */
1378         kfree(ZATM_VCC(vcc));
1379         vcc->dev_data = NULL;
1380         clear_bit(ATM_VF_ADDR,&vcc->flags);
1381 }
1382
1383
1384 static int zatm_open(struct atm_vcc *vcc)
1385 {
1386         struct zatm_dev *zatm_dev;
1387         struct zatm_vcc *zatm_vcc;
1388         short vpi = vcc->vpi;
1389         int vci = vcc->vci;
1390         int error;
1391
1392         DPRINTK(">zatm_open\n");
1393         zatm_dev = ZATM_DEV(vcc->dev);
1394         if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1395                 vcc->dev_data = NULL;
1396         if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1397                 set_bit(ATM_VF_ADDR,&vcc->flags);
1398         if (vcc->qos.aal != ATM_AAL5) return -EINVAL; /* @@@ AAL0 */
1399         DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1400             vcc->vci);
1401         if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) {
1402                 zatm_vcc = kmalloc(sizeof(struct zatm_vcc),GFP_KERNEL);
1403                 if (!zatm_vcc) {
1404                         clear_bit(ATM_VF_ADDR,&vcc->flags);
1405                         return -ENOMEM;
1406                 }
1407                 vcc->dev_data = zatm_vcc;
1408                 ZATM_VCC(vcc)->tx_chan = 0; /* for zatm_close after open_rx */
1409                 if ((error = open_rx_first(vcc))) {
1410                         zatm_close(vcc);
1411                         return error;
1412                 }
1413                 if ((error = open_tx_first(vcc))) {
1414                         zatm_close(vcc);
1415                         return error;
1416                 }
1417         }
1418         if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1419         if ((error = open_rx_second(vcc))) {
1420                 zatm_close(vcc);
1421                 return error;
1422         }
1423         if ((error = open_tx_second(vcc))) {
1424                 zatm_close(vcc);
1425                 return error;
1426         }
1427         set_bit(ATM_VF_READY,&vcc->flags);
1428         return 0;
1429 }
1430
1431
1432 static int zatm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flags)
1433 {
1434         printk("Not yet implemented\n");
1435         return -ENOSYS;
1436         /* @@@ */
1437 }
1438
1439
1440 static int zatm_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
1441 {
1442         struct zatm_dev *zatm_dev;
1443         unsigned long flags;
1444
1445         zatm_dev = ZATM_DEV(dev);
1446         switch (cmd) {
1447                 case ZATM_GETPOOLZ:
1448                         if (!capable(CAP_NET_ADMIN)) return -EPERM;
1449                         /* fall through */
1450                 case ZATM_GETPOOL:
1451                         {
1452                                 struct zatm_pool_info info;
1453                                 int pool;
1454
1455                                 if (get_user(pool,
1456                                     &((struct zatm_pool_req __user *) arg)->pool_num))
1457                                         return -EFAULT;
1458                                 if (pool < 0 || pool > ZATM_LAST_POOL)
1459                                         return -EINVAL;
1460                                 spin_lock_irqsave(&zatm_dev->lock, flags);
1461                                 info = zatm_dev->pool_info[pool];
1462                                 if (cmd == ZATM_GETPOOLZ) {
1463                                         zatm_dev->pool_info[pool].rqa_count = 0;
1464                                         zatm_dev->pool_info[pool].rqu_count = 0;
1465                                 }
1466                                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1467                                 return copy_to_user(
1468                                     &((struct zatm_pool_req __user *) arg)->info,
1469                                     &info,sizeof(info)) ? -EFAULT : 0;
1470                         }
1471                 case ZATM_SETPOOL:
1472                         {
1473                                 struct zatm_pool_info info;
1474                                 int pool;
1475
1476                                 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1477                                 if (get_user(pool,
1478                                     &((struct zatm_pool_req __user *) arg)->pool_num))
1479                                         return -EFAULT;
1480                                 if (pool < 0 || pool > ZATM_LAST_POOL)
1481                                         return -EINVAL;
1482                                 if (copy_from_user(&info,
1483                                     &((struct zatm_pool_req __user *) arg)->info,
1484                                     sizeof(info))) return -EFAULT;
1485                                 if (!info.low_water)
1486                                         info.low_water = zatm_dev->
1487                                             pool_info[pool].low_water;
1488                                 if (!info.high_water)
1489                                         info.high_water = zatm_dev->
1490                                             pool_info[pool].high_water;
1491                                 if (!info.next_thres)
1492                                         info.next_thres = zatm_dev->
1493                                             pool_info[pool].next_thres;
1494                                 if (info.low_water >= info.high_water ||
1495                                     info.low_water < 0)
1496                                         return -EINVAL;
1497                                 spin_lock_irqsave(&zatm_dev->lock, flags);
1498                                 zatm_dev->pool_info[pool].low_water =
1499                                     info.low_water;
1500                                 zatm_dev->pool_info[pool].high_water =
1501                                     info.high_water;
1502                                 zatm_dev->pool_info[pool].next_thres =
1503                                     info.next_thres;
1504                                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1505                                 return 0;
1506                         }
1507                 default:
1508                         if (!dev->phy->ioctl) return -ENOIOCTLCMD;
1509                         return dev->phy->ioctl(dev,cmd,arg);
1510         }
1511 }
1512
1513
1514 static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname,
1515     void __user *optval,int optlen)
1516 {
1517         return -EINVAL;
1518 }
1519
1520
1521 static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname,
1522     void __user *optval,unsigned int optlen)
1523 {
1524         return -EINVAL;
1525 }
1526
1527 static int zatm_send(struct atm_vcc *vcc,struct sk_buff *skb)
1528 {
1529         int error;
1530
1531         EVENT(">zatm_send 0x%lx\n",(unsigned long) skb,0);
1532         if (!ZATM_VCC(vcc)->tx_chan || !test_bit(ATM_VF_READY,&vcc->flags)) {
1533                 if (vcc->pop) vcc->pop(vcc,skb);
1534                 else dev_kfree_skb(skb);
1535                 return -EINVAL;
1536         }
1537         if (!skb) {
1538                 printk(KERN_CRIT "!skb in zatm_send ?\n");
1539                 if (vcc->pop) vcc->pop(vcc,skb);
1540                 return -EINVAL;
1541         }
1542         ATM_SKB(skb)->vcc = vcc;
1543         error = do_tx(skb);
1544         if (error != RING_BUSY) return error;
1545         skb_queue_tail(&ZATM_VCC(vcc)->backlog,skb);
1546         return 0;
1547 }
1548
1549
1550 static void zatm_phy_put(struct atm_dev *dev,unsigned char value,
1551     unsigned long addr)
1552 {
1553         struct zatm_dev *zatm_dev;
1554
1555         zatm_dev = ZATM_DEV(dev);
1556         zwait;
1557         zout(value,CER);
1558         zout(uPD98401_IND_ACC | uPD98401_IA_B0 |
1559             (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1560 }
1561
1562
1563 static unsigned char zatm_phy_get(struct atm_dev *dev,unsigned long addr)
1564 {
1565         struct zatm_dev *zatm_dev;
1566
1567         zatm_dev = ZATM_DEV(dev);
1568         zwait;
1569         zout(uPD98401_IND_ACC | uPD98401_IA_B0 | uPD98401_IA_RW |
1570           (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1571         zwait;
1572         return zin(CER) & 0xff;
1573 }
1574
1575
1576 static const struct atmdev_ops ops = {
1577         .open           = zatm_open,
1578         .close          = zatm_close,
1579         .ioctl          = zatm_ioctl,
1580         .getsockopt     = zatm_getsockopt,
1581         .setsockopt     = zatm_setsockopt,
1582         .send           = zatm_send,
1583         .phy_put        = zatm_phy_put,
1584         .phy_get        = zatm_phy_get,
1585         .change_qos     = zatm_change_qos,
1586 };
1587
1588 static int __devinit zatm_init_one(struct pci_dev *pci_dev,
1589                                    const struct pci_device_id *ent)
1590 {
1591         struct atm_dev *dev;
1592         struct zatm_dev *zatm_dev;
1593         int ret = -ENOMEM;
1594
1595         zatm_dev = kmalloc(sizeof(*zatm_dev), GFP_KERNEL);
1596         if (!zatm_dev) {
1597                 printk(KERN_EMERG "%s: memory shortage\n", DEV_LABEL);
1598                 goto out;
1599         }
1600
1601         dev = atm_dev_register(DEV_LABEL, &pci_dev->dev, &ops, -1, NULL);
1602         if (!dev)
1603                 goto out_free;
1604
1605         ret = pci_enable_device(pci_dev);
1606         if (ret < 0)
1607                 goto out_deregister;
1608
1609         ret = pci_request_regions(pci_dev, DEV_LABEL);
1610         if (ret < 0)
1611                 goto out_disable;
1612
1613         zatm_dev->pci_dev = pci_dev;
1614         dev->dev_data = zatm_dev;
1615         zatm_dev->copper = (int)ent->driver_data;
1616         if ((ret = zatm_init(dev)) || (ret = zatm_start(dev)))
1617                 goto out_release;
1618
1619         pci_set_drvdata(pci_dev, dev);
1620         zatm_dev->more = zatm_boards;
1621         zatm_boards = dev;
1622         ret = 0;
1623 out:
1624         return ret;
1625
1626 out_release:
1627         pci_release_regions(pci_dev);
1628 out_disable:
1629         pci_disable_device(pci_dev);
1630 out_deregister:
1631         atm_dev_deregister(dev);
1632 out_free:
1633         kfree(zatm_dev);
1634         goto out;
1635 }
1636
1637
1638 MODULE_LICENSE("GPL");
1639
1640 static struct pci_device_id zatm_pci_tbl[] __devinitdata = {
1641         { PCI_VDEVICE(ZEITNET, PCI_DEVICE_ID_ZEITNET_1221), ZATM_COPPER },
1642         { PCI_VDEVICE(ZEITNET, PCI_DEVICE_ID_ZEITNET_1225), 0 },
1643         { 0, }
1644 };
1645 MODULE_DEVICE_TABLE(pci, zatm_pci_tbl);
1646
1647 static struct pci_driver zatm_driver = {
1648         .name =         DEV_LABEL,
1649         .id_table =     zatm_pci_tbl,
1650         .probe =        zatm_init_one,
1651 };
1652
1653 static int __init zatm_init_module(void)
1654 {
1655         return pci_register_driver(&zatm_driver);
1656 }
1657
1658 module_init(zatm_init_module);
1659 /* module_exit not defined so not unloadable */