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/config.h>
   7 #include <linux/module.h>
   8 #include <linux/sched.h>
   9 #include <linux/kernel.h>
  10 #include <linux/mm.h>
  11 #include <linux/pci.h>
  12 #include <linux/errno.h>
  13 #include <linux/atm.h>
  14 #include <linux/atmdev.h>
  15 #include <linux/sonet.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/netdevice.h>
  18 #include <linux/delay.h>
  19 #include <linux/uio.h>
  20 #include <linux/init.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/atm_zatm.h>
  23 #include <linux/capability.h>
  24 #include <linux/bitops.h>
  25 #include <linux/wait.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 = ZATM_VCC(vcc)->pool;
 421
 422                         vcc = zatm_dev->rx_map[chan];
 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 = (vcc->qos.rxtp.max_sdu+ATM_AAL5_TRAILER+
 502                     ATM_CELL_PAYLOAD-1)/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 = (struct atm_vcc **) kmalloc(size,GFP_KERNEL);
 608         if (!zatm_dev->rx_map) return -ENOMEM;
 609         memset(zatm_dev->rx_map,0,size);
 610         /* set VPI/VCI split (use all VCIs and give what's left to VPIs) */
 611         zpokel(zatm_dev,(1 << dev->ci_range.vci_bits)-1,uPD98401_VRR);
 612         /* prepare free buffer pools */
 613         for (i = 0; i <= ZATM_LAST_POOL; i++) {
 614                 zatm_dev->pool_info[i].ref_count = 0;
 615                 zatm_dev->pool_info[i].rqa_count = 0;
 616                 zatm_dev->pool_info[i].rqu_count = 0;
 617                 zatm_dev->pool_info[i].low_water = LOW_MARK;
 618                 zatm_dev->pool_info[i].high_water = HIGH_MARK;
 619                 zatm_dev->pool_info[i].offset = 0;
 620                 zatm_dev->pool_info[i].next_off = 0;
 621                 zatm_dev->pool_info[i].next_cnt = 0;
 622                 zatm_dev->pool_info[i].next_thres = OFF_CNG_THRES;
 623         }
 624         return 0;
 625 }
 626
 627
 628 /*----------------------------------- TX ------------------------------------*/
 629
 630
 631 static int do_tx(struct sk_buff *skb)
 632 {
 633         struct atm_vcc *vcc;
 634         struct zatm_dev *zatm_dev;
 635         struct zatm_vcc *zatm_vcc;
 636         u32 *dsc;
 637         unsigned long flags;
 638
 639         EVENT("do_tx\n",0,0);
 640         DPRINTK("sending skb %p\n",skb);
 641         vcc = ATM_SKB(skb)->vcc;
 642         zatm_dev = ZATM_DEV(vcc->dev);
 643         zatm_vcc = ZATM_VCC(vcc);
 644         EVENT("iovcnt=%d\n",skb_shinfo(skb)->nr_frags,0);
 645         spin_lock_irqsave(&zatm_dev->lock, flags);
 646         if (!skb_shinfo(skb)->nr_frags) {
 647                 if (zatm_vcc->txing == RING_ENTRIES-1) {
 648                         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 649                         return RING_BUSY;
 650                 }
 651                 zatm_vcc->txing++;
 652                 dsc = zatm_vcc->ring+zatm_vcc->ring_curr;
 653                 zatm_vcc->ring_curr = (zatm_vcc->ring_curr+RING_WORDS) &
 654                     (RING_ENTRIES*RING_WORDS-1);
 655                 dsc[1] = 0;
 656                 dsc[2] = skb->len;
 657                 dsc[3] = virt_to_bus(skb->data);
 658                 mb();
 659                 dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP | uPD98401_TXPD_SM
 660                     | (vcc->qos.aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 |
 661                     (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ?
 662                     uPD98401_CLPM_1 : uPD98401_CLPM_0));
 663                 EVENT("dsc (0x%lx)\n",(unsigned long) dsc,0);
 664         }
 665         else {
 666 printk("NONONONOO!!!!\n");
 667                 dsc = NULL;
 668 #if 0
 669                 u32 *put;
 670                 int i;
 671
 672                 dsc = (u32 *) kmalloc(uPD98401_TXPD_SIZE*2+
 673                     uPD98401_TXBD_SIZE*ATM_SKB(skb)->iovcnt,GFP_ATOMIC);
 674                 if (!dsc) {
 675                         if (vcc->pop) vcc->pop(vcc,skb);
 676                         else dev_kfree_skb_irq(skb);
 677                         return -EAGAIN;
 678                 }
 679                 /* @@@ should check alignment */
 680                 put = dsc+8;
 681                 dsc[0] = uPD98401_TXPD_V | uPD98401_TXPD_DP |
 682                     (vcc->aal == ATM_AAL5 ? uPD98401_TXPD_AAL5 : 0 |
 683                     (ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ?
 684                     uPD98401_CLPM_1 : uPD98401_CLPM_0));
 685                 dsc[1] = 0;
 686                 dsc[2] = ATM_SKB(skb)->iovcnt*uPD98401_TXBD_SIZE;
 687                 dsc[3] = virt_to_bus(put);
 688                 for (i = 0; i < ATM_SKB(skb)->iovcnt; i++) {
 689                         *put++ = ((struct iovec *) skb->data)[i].iov_len;
 690                         *put++ = virt_to_bus(((struct iovec *)
 691                             skb->data)[i].iov_base);
 692                 }
 693                 put[-2] |= uPD98401_TXBD_LAST;
 694 #endif
 695         }
 696         ZATM_PRV_DSC(skb) = dsc;
 697         skb_queue_tail(&zatm_vcc->tx_queue,skb);
 698         DPRINTK("QRP=0x%08lx\n",zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
 699           uPD98401_TXVC_QRP));
 700         zwait;
 701         zout(uPD98401_TX_READY | (zatm_vcc->tx_chan <<
 702             uPD98401_CHAN_ADDR_SHIFT),CMR);
 703         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 704         EVENT("done\n",0,0);
 705         return 0;
 706 }
 707
 708
 709 static inline void dequeue_tx(struct atm_vcc *vcc)
 710 {
 711         struct zatm_vcc *zatm_vcc;
 712         struct sk_buff *skb;
 713
 714         EVENT("dequeue_tx\n",0,0);
 715         zatm_vcc = ZATM_VCC(vcc);
 716         skb = skb_dequeue(&zatm_vcc->tx_queue);
 717         if (!skb) {
 718                 printk(KERN_CRIT DEV_LABEL "(itf %d): dequeue_tx but not "
 719                     "txing\n",vcc->dev->number);
 720                 return;
 721         }
 722 #if 0 /* @@@ would fail on CLP */
 723 if (*ZATM_PRV_DSC(skb) != (uPD98401_TXPD_V | uPD98401_TXPD_DP |
 724   uPD98401_TXPD_SM | uPD98401_TXPD_AAL5)) printk("@#*$!!!!  (%08x)\n",
 725   *ZATM_PRV_DSC(skb));
 726 #endif
 727         *ZATM_PRV_DSC(skb) = 0; /* mark as invalid */
 728         zatm_vcc->txing--;
 729         if (vcc->pop) vcc->pop(vcc,skb);
 730         else dev_kfree_skb_irq(skb);
 731         while ((skb = skb_dequeue(&zatm_vcc->backlog)))
 732                 if (do_tx(skb) == RING_BUSY) {
 733                         skb_queue_head(&zatm_vcc->backlog,skb);
 734                         break;
 735                 }
 736         atomic_inc(&vcc->stats->tx);
 737         wake_up(&zatm_vcc->tx_wait);
 738 }
 739
 740
 741 static void poll_tx(struct atm_dev *dev,int mbx)
 742 {
 743         struct zatm_dev *zatm_dev;
 744         unsigned long pos;
 745         u32 x;
 746
 747         EVENT("poll_tx\n",0,0);
 748         zatm_dev = ZATM_DEV(dev);
 749         pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
 750         while (x = zin(MWA(mbx)), (pos & 0xffff) != x) {
 751                 int chan;
 752
 753 #if 1
 754                 u32 data,*addr;
 755
 756                 EVENT("MBX: host 0x%lx, nic 0x%x\n",pos,x);
 757                 addr = (u32 *) pos;
 758                 data = *addr;
 759                 chan = (data & uPD98401_TXI_CONN) >> uPD98401_TXI_CONN_SHIFT;
 760                 EVENT("addr = 0x%lx, data = 0x%08x,",(unsigned long) addr,
 761                     data);
 762                 EVENT("chan = %d\n",chan,0);
 763 #else
 764 NO !
 765                 chan = (zatm_dev->mbx_start[mbx][pos >> 2] & uPD98401_TXI_CONN)
 766                 >> uPD98401_TXI_CONN_SHIFT;
 767 #endif
 768                 if (chan < zatm_dev->chans && zatm_dev->tx_map[chan])
 769                         dequeue_tx(zatm_dev->tx_map[chan]);
 770                 else {
 771                         printk(KERN_CRIT DEV_LABEL "(itf %d): TX indication "
 772                             "for non-existing channel %d\n",dev->number,chan);
 773                         event_dump();
 774                 }
 775                 if (((pos += 4) & 0xffff) == zatm_dev->mbx_end[mbx])
 776                         pos = zatm_dev->mbx_start[mbx];
 777         }
 778         zout(pos & 0xffff,MTA(mbx));
 779 }
 780
 781
 782 /*
 783  * BUG BUG BUG: Doesn't handle "new-style" rate specification yet.
 784  */
 785
 786 static int alloc_shaper(struct atm_dev *dev,int *pcr,int min,int max,int ubr)
 787 {
 788         struct zatm_dev *zatm_dev;
 789         unsigned long flags;
 790         unsigned long i,m,c;
 791         int shaper;
 792
 793         DPRINTK("alloc_shaper (min = %d, max = %d)\n",min,max);
 794         zatm_dev = ZATM_DEV(dev);
 795         if (!zatm_dev->free_shapers) return -EAGAIN;
 796         for (shaper = 0; !((zatm_dev->free_shapers >> shaper) & 1); shaper++);
 797         zatm_dev->free_shapers &= ~1 << shaper;
 798         if (ubr) {
 799                 c = 5;
 800                 i = m = 1;
 801                 zatm_dev->ubr_ref_cnt++;
 802                 zatm_dev->ubr = shaper;
 803         }
 804         else {
 805                 if (min) {
 806                         if (min <= 255) {
 807                                 i = min;
 808                                 m = ATM_OC3_PCR;
 809                         }
 810                         else {
 811                                 i = 255;
 812                                 m = ATM_OC3_PCR*255/min;
 813                         }
 814                 }
 815                 else {
 816                         if (max > zatm_dev->tx_bw) max = zatm_dev->tx_bw;
 817                         if (max <= 255) {
 818                                 i = max;
 819                                 m = ATM_OC3_PCR;
 820                         }
 821                         else {
 822                                 i = 255;
 823                                 m = (ATM_OC3_PCR*255+max-1)/max;
 824                         }
 825                 }
 826                 if (i > m) {
 827                         printk(KERN_CRIT DEV_LABEL "shaper algorithm botched "
 828                             "[%d,%d] -> i=%ld,m=%ld\n",min,max,i,m);
 829                         m = i;
 830                 }
 831                 *pcr = i*ATM_OC3_PCR/m;
 832                 c = 20; /* @@@ should use max_cdv ! */
 833                 if ((min && *pcr < min) || (max && *pcr > max)) return -EINVAL;
 834                 if (zatm_dev->tx_bw < *pcr) return -EAGAIN;
 835                 zatm_dev->tx_bw -= *pcr;
 836         }
 837         spin_lock_irqsave(&zatm_dev->lock, flags);
 838         DPRINTK("i = %d, m = %d, PCR = %d\n",i,m,*pcr);
 839         zpokel(zatm_dev,(i << uPD98401_IM_I_SHIFT) | m,uPD98401_IM(shaper));
 840         zpokel(zatm_dev,c << uPD98401_PC_C_SHIFT,uPD98401_PC(shaper));
 841         zpokel(zatm_dev,0,uPD98401_X(shaper));
 842         zpokel(zatm_dev,0,uPD98401_Y(shaper));
 843         zpokel(zatm_dev,uPD98401_PS_E,uPD98401_PS(shaper));
 844         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 845         return shaper;
 846 }
 847
 848
 849 static void dealloc_shaper(struct atm_dev *dev,int shaper)
 850 {
 851         struct zatm_dev *zatm_dev;
 852         unsigned long flags;
 853
 854         zatm_dev = ZATM_DEV(dev);
 855         if (shaper == zatm_dev->ubr) {
 856                 if (--zatm_dev->ubr_ref_cnt) return;
 857                 zatm_dev->ubr = -1;
 858         }
 859         spin_lock_irqsave(&zatm_dev->lock, flags);
 860         zpokel(zatm_dev,zpeekl(zatm_dev,uPD98401_PS(shaper)) & ~uPD98401_PS_E,
 861             uPD98401_PS(shaper));
 862         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 863         zatm_dev->free_shapers |= 1 << shaper;
 864 }
 865
 866
 867 static void close_tx(struct atm_vcc *vcc)
 868 {
 869         struct zatm_dev *zatm_dev;
 870         struct zatm_vcc *zatm_vcc;
 871         unsigned long flags;
 872         int chan;
 873
 874         zatm_vcc = ZATM_VCC(vcc);
 875         zatm_dev = ZATM_DEV(vcc->dev);
 876         chan = zatm_vcc->tx_chan;
 877         if (!chan) return;
 878         DPRINTK("close_tx\n");
 879         if (skb_peek(&zatm_vcc->backlog)) {
 880                 printk("waiting for backlog to drain ...\n");
 881                 event_dump();
 882                 wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->backlog));
 883         }
 884         if (skb_peek(&zatm_vcc->tx_queue)) {
 885                 printk("waiting for TX queue to drain ...\n");
 886                 event_dump();
 887                 wait_event(zatm_vcc->tx_wait, !skb_peek(&zatm_vcc->tx_queue));
 888         }
 889         spin_lock_irqsave(&zatm_dev->lock, flags);
 890 #if 0
 891         zwait;
 892         zout(uPD98401_DEACT_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
 893 #endif
 894         zwait;
 895         zout(uPD98401_CLOSE_CHAN | (chan << uPD98401_CHAN_ADDR_SHIFT),CMR);
 896         zwait;
 897         if (!(zin(CMR) & uPD98401_CHAN_ADDR))
 898                 printk(KERN_CRIT DEV_LABEL "(itf %d): can't close TX channel "
 899                     "%d\n",vcc->dev->number,chan);
 900         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 901         zatm_vcc->tx_chan = 0;
 902         zatm_dev->tx_map[chan] = NULL;
 903         if (zatm_vcc->shaper != zatm_dev->ubr) {
 904                 zatm_dev->tx_bw += vcc->qos.txtp.min_pcr;
 905                 dealloc_shaper(vcc->dev,zatm_vcc->shaper);
 906         }
 907         kfree(zatm_vcc->ring);
 908 }
 909
 910
 911 static int open_tx_first(struct atm_vcc *vcc)
 912 {
 913         struct zatm_dev *zatm_dev;
 914         struct zatm_vcc *zatm_vcc;
 915         unsigned long flags;
 916         u32 *loop;
 917         unsigned short chan;
 918         int pcr,unlimited;
 919
 920         DPRINTK("open_tx_first\n");
 921         zatm_dev = ZATM_DEV(vcc->dev);
 922         zatm_vcc = ZATM_VCC(vcc);
 923         zatm_vcc->tx_chan = 0;
 924         if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0;
 925         spin_lock_irqsave(&zatm_dev->lock, flags);
 926         zwait;
 927         zout(uPD98401_OPEN_CHAN,CMR);
 928         zwait;
 929         DPRINTK("0x%x 0x%x\n",zin(CMR),zin(CER));
 930         chan = (zin(CMR) & uPD98401_CHAN_ADDR) >> uPD98401_CHAN_ADDR_SHIFT;
 931         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 932         DPRINTK("chan is %d\n",chan);
 933         if (!chan) return -EAGAIN;
 934         unlimited = vcc->qos.txtp.traffic_class == ATM_UBR &&
 935             (!vcc->qos.txtp.max_pcr || vcc->qos.txtp.max_pcr == ATM_MAX_PCR ||
 936             vcc->qos.txtp.max_pcr >= ATM_OC3_PCR);
 937         if (unlimited && zatm_dev->ubr != -1) zatm_vcc->shaper = zatm_dev->ubr;
 938         else {
 939                 if (unlimited) vcc->qos.txtp.max_sdu = ATM_MAX_AAL5_PDU;
 940                 if ((zatm_vcc->shaper = alloc_shaper(vcc->dev,&pcr,
 941                     vcc->qos.txtp.min_pcr,vcc->qos.txtp.max_pcr,unlimited))
 942                     < 0) {
 943                         close_tx(vcc);
 944                         return zatm_vcc->shaper;
 945                 }
 946                 if (pcr > ATM_OC3_PCR) pcr = ATM_OC3_PCR;
 947                 vcc->qos.txtp.min_pcr = vcc->qos.txtp.max_pcr = pcr;
 948         }
 949         zatm_vcc->tx_chan = chan;
 950         skb_queue_head_init(&zatm_vcc->tx_queue);
 951         init_waitqueue_head(&zatm_vcc->tx_wait);
 952         /* initialize ring */
 953         zatm_vcc->ring = kmalloc(RING_SIZE,GFP_KERNEL);
 954         if (!zatm_vcc->ring) return -ENOMEM;
 955         memset(zatm_vcc->ring,0,RING_SIZE);
 956         loop = zatm_vcc->ring+RING_ENTRIES*RING_WORDS;
 957         loop[0] = uPD98401_TXPD_V;
 958         loop[1] = loop[2] = 0;
 959         loop[3] = virt_to_bus(zatm_vcc->ring);
 960         zatm_vcc->ring_curr = 0;
 961         zatm_vcc->txing = 0;
 962         skb_queue_head_init(&zatm_vcc->backlog);
 963         zpokel(zatm_dev,virt_to_bus(zatm_vcc->ring),
 964             chan*VC_SIZE/4+uPD98401_TXVC_QRP);
 965         return 0;
 966 }
 967
 968
 969 static int open_tx_second(struct atm_vcc *vcc)
 970 {
 971         struct zatm_dev *zatm_dev;
 972         struct zatm_vcc *zatm_vcc;
 973         unsigned long flags;
 974
 975         DPRINTK("open_tx_second\n");
 976         zatm_dev = ZATM_DEV(vcc->dev);
 977         zatm_vcc = ZATM_VCC(vcc);
 978         if (!zatm_vcc->tx_chan) return 0;
 979         /* set up VC descriptor */
 980         spin_lock_irqsave(&zatm_dev->lock, flags);
 981         zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4);
 982         zpokel(zatm_dev,uPD98401_TXVC_L | (zatm_vcc->shaper <<
 983             uPD98401_TXVC_SHP_SHIFT) | (vcc->vpi << uPD98401_TXVC_VPI_SHIFT) |
 984             vcc->vci,zatm_vcc->tx_chan*VC_SIZE/4+1);
 985         zpokel(zatm_dev,0,zatm_vcc->tx_chan*VC_SIZE/4+2);
 986         spin_unlock_irqrestore(&zatm_dev->lock, flags);
 987         zatm_dev->tx_map[zatm_vcc->tx_chan] = vcc;
 988         return 0;
 989 }
 990
 991
 992 static int start_tx(struct atm_dev *dev)
 993 {
 994         struct zatm_dev *zatm_dev;
 995         int i;
 996
 997         DPRINTK("start_tx\n");
 998         zatm_dev = ZATM_DEV(dev);
 999         zatm_dev->tx_map = (struct atm_vcc **) kmalloc(sizeof(struct atm_vcc *)*
1000             zatm_dev->chans,GFP_KERNEL);
1001         if (!zatm_dev->tx_map) return -ENOMEM;
1002         zatm_dev->tx_bw = ATM_OC3_PCR;
1003         zatm_dev->free_shapers = (1 << NR_SHAPERS)-1;
1004         zatm_dev->ubr = -1;
1005         zatm_dev->ubr_ref_cnt = 0;
1006         /* initialize shapers */
1007         for (i = 0; i < NR_SHAPERS; i++) zpokel(zatm_dev,0,uPD98401_PS(i));
1008         return 0;
1009 }
1010
1011
1012 /*------------------------------- interrupts --------------------------------*/
1013
1014
1015 static irqreturn_t zatm_int(int irq,void *dev_id,struct pt_regs *regs)
1016 {
1017         struct atm_dev *dev;
1018         struct zatm_dev *zatm_dev;
1019         u32 reason;
1020         int handled = 0;
1021
1022         dev = dev_id;
1023         zatm_dev = ZATM_DEV(dev);
1024         while ((reason = zin(GSR))) {
1025                 handled = 1;
1026                 EVENT("reason 0x%x\n",reason,0);
1027                 if (reason & uPD98401_INT_PI) {
1028                         EVENT("PHY int\n",0,0);
1029                         dev->phy->interrupt(dev);
1030                 }
1031                 if (reason & uPD98401_INT_RQA) {
1032                         unsigned long pools;
1033                         int i;
1034
1035                         pools = zin(RQA);
1036                         EVENT("RQA (0x%08x)\n",pools,0);
1037                         for (i = 0; pools; i++) {
1038                                 if (pools & 1) {
1039                                         refill_pool(dev,i);
1040                                         zatm_dev->pool_info[i].rqa_count++;
1041                                 }
1042                                 pools >>= 1;
1043                         }
1044                 }
1045                 if (reason & uPD98401_INT_RQU) {
1046                         unsigned long pools;
1047                         int i;
1048                         pools = zin(RQU);
1049                         printk(KERN_WARNING DEV_LABEL "(itf %d): RQU 0x%08lx\n",
1050                             dev->number,pools);
1051                         event_dump();
1052                         for (i = 0; pools; i++) {
1053                                 if (pools & 1) {
1054                                         refill_pool(dev,i);
1055                                         zatm_dev->pool_info[i].rqu_count++;
1056                                 }
1057                                 pools >>= 1;
1058                         }
1059                 }
1060                 /* don't handle RD */
1061                 if (reason & uPD98401_INT_SPE)
1062                         printk(KERN_ALERT DEV_LABEL "(itf %d): system parity "
1063                             "error at 0x%08x\n",dev->number,zin(ADDR));
1064                 if (reason & uPD98401_INT_CPE)
1065                         printk(KERN_ALERT DEV_LABEL "(itf %d): control memory "
1066                             "parity error at 0x%08x\n",dev->number,zin(ADDR));
1067                 if (reason & uPD98401_INT_SBE) {
1068                         printk(KERN_ALERT DEV_LABEL "(itf %d): system bus "
1069                             "error at 0x%08x\n",dev->number,zin(ADDR));
1070                         event_dump();
1071                 }
1072                 /* don't handle IND */
1073                 if (reason & uPD98401_INT_MF) {
1074                         printk(KERN_CRIT DEV_LABEL "(itf %d): mailbox full "
1075                             "(0x%x)\n",dev->number,(reason & uPD98401_INT_MF)
1076                             >> uPD98401_INT_MF_SHIFT);
1077                         event_dump();
1078                             /* @@@ should try to recover */
1079                 }
1080                 if (reason & uPD98401_INT_MM) {
1081                         if (reason & 1) poll_rx(dev,0);
1082                         if (reason & 2) poll_rx(dev,1);
1083                         if (reason & 4) poll_tx(dev,2);
1084                         if (reason & 8) poll_tx(dev,3);
1085                 }
1086                 /* @@@ handle RCRn */
1087         }
1088         return IRQ_RETVAL(handled);
1089 }
1090
1091
1092 /*----------------------------- (E)EPROM access -----------------------------*/
1093
1094
1095 static void __devinit eprom_set(struct zatm_dev *zatm_dev,unsigned long value,
1096     unsigned short cmd)
1097 {
1098         int error;
1099
1100         if ((error = pci_write_config_dword(zatm_dev->pci_dev,cmd,value)))
1101                 printk(KERN_ERR DEV_LABEL ": PCI write failed (0x%02x)\n",
1102                     error);
1103 }
1104
1105
1106 static unsigned long __devinit eprom_get(struct zatm_dev *zatm_dev,
1107     unsigned short cmd)
1108 {
1109         unsigned int value;
1110         int error;
1111
1112         if ((error = pci_read_config_dword(zatm_dev->pci_dev,cmd,&value)))
1113                 printk(KERN_ERR DEV_LABEL ": PCI read failed (0x%02x)\n",
1114                     error);
1115         return value;
1116 }
1117
1118
1119 static void __devinit eprom_put_bits(struct zatm_dev *zatm_dev,
1120     unsigned long data,int bits,unsigned short cmd)
1121 {
1122         unsigned long value;
1123         int i;
1124
1125         for (i = bits-1; i >= 0; i--) {
1126                 value = ZEPROM_CS | (((data >> i) & 1) ? ZEPROM_DI : 0);
1127                 eprom_set(zatm_dev,value,cmd);
1128                 eprom_set(zatm_dev,value | ZEPROM_SK,cmd);
1129                 eprom_set(zatm_dev,value,cmd);
1130         }
1131 }
1132
1133
1134 static void __devinit eprom_get_byte(struct zatm_dev *zatm_dev,
1135     unsigned char *byte,unsigned short cmd)
1136 {
1137         int i;
1138
1139         *byte = 0;
1140         for (i = 8; i; i--) {
1141                 eprom_set(zatm_dev,ZEPROM_CS,cmd);
1142                 eprom_set(zatm_dev,ZEPROM_CS | ZEPROM_SK,cmd);
1143                 *byte <<= 1;
1144                 if (eprom_get(zatm_dev,cmd) & ZEPROM_DO) *byte |= 1;
1145                 eprom_set(zatm_dev,ZEPROM_CS,cmd);
1146         }
1147 }
1148
1149
1150 static unsigned char __devinit eprom_try_esi(struct atm_dev *dev,
1151     unsigned short cmd,int offset,int swap)
1152 {
1153         unsigned char buf[ZEPROM_SIZE];
1154         struct zatm_dev *zatm_dev;
1155         int i;
1156
1157         zatm_dev = ZATM_DEV(dev);
1158         for (i = 0; i < ZEPROM_SIZE; i += 2) {
1159                 eprom_set(zatm_dev,ZEPROM_CS,cmd); /* select EPROM */
1160                 eprom_put_bits(zatm_dev,ZEPROM_CMD_READ,ZEPROM_CMD_LEN,cmd);
1161                 eprom_put_bits(zatm_dev,i >> 1,ZEPROM_ADDR_LEN,cmd);
1162                 eprom_get_byte(zatm_dev,buf+i+swap,cmd);
1163                 eprom_get_byte(zatm_dev,buf+i+1-swap,cmd);
1164                 eprom_set(zatm_dev,0,cmd); /* deselect EPROM */
1165         }
1166         memcpy(dev->esi,buf+offset,ESI_LEN);
1167         return memcmp(dev->esi,"\0\0\0\0\0",ESI_LEN); /* assumes ESI_LEN == 6 */
1168 }
1169
1170
1171 static void __devinit eprom_get_esi(struct atm_dev *dev)
1172 {
1173         if (eprom_try_esi(dev,ZEPROM_V1_REG,ZEPROM_V1_ESI_OFF,1)) return;
1174         (void) eprom_try_esi(dev,ZEPROM_V2_REG,ZEPROM_V2_ESI_OFF,0);
1175 }
1176
1177
1178 /*--------------------------------- entries ---------------------------------*/
1179
1180
1181 static int __init zatm_init(struct atm_dev *dev)
1182 {
1183         struct zatm_dev *zatm_dev;
1184         struct pci_dev *pci_dev;
1185         unsigned short command;
1186         unsigned char revision;
1187         int error,i,last;
1188         unsigned long t0,t1,t2;
1189
1190         DPRINTK(">zatm_init\n");
1191         zatm_dev = ZATM_DEV(dev);
1192         spin_lock_init(&zatm_dev->lock);
1193         pci_dev = zatm_dev->pci_dev;
1194         zatm_dev->base = pci_resource_start(pci_dev, 0);
1195         zatm_dev->irq = pci_dev->irq;
1196         if ((error = pci_read_config_word(pci_dev,PCI_COMMAND,&command)) ||
1197             (error = pci_read_config_byte(pci_dev,PCI_REVISION_ID,&revision))) {
1198                 printk(KERN_ERR DEV_LABEL "(itf %d): init error 0x%02x\n",
1199                     dev->number,error);
1200                 return -EINVAL;
1201         }
1202         if ((error = pci_write_config_word(pci_dev,PCI_COMMAND,
1203             command | PCI_COMMAND_IO | PCI_COMMAND_MASTER))) {
1204                 printk(KERN_ERR DEV_LABEL "(itf %d): can't enable IO (0x%02x)"
1205                     "\n",dev->number,error);
1206                 return -EIO;
1207         }
1208         eprom_get_esi(dev);
1209         printk(KERN_NOTICE DEV_LABEL "(itf %d): rev.%d,base=0x%x,irq=%d,",
1210             dev->number,revision,zatm_dev->base,zatm_dev->irq);
1211         /* reset uPD98401 */
1212         zout(0,SWR);
1213         while (!(zin(GSR) & uPD98401_INT_IND));
1214         zout(uPD98401_GMR_ONE /*uPD98401_BURST4*/,GMR);
1215         last = MAX_CRAM_SIZE;
1216         for (i = last-RAM_INCREMENT; i >= 0; i -= RAM_INCREMENT) {
1217                 zpokel(zatm_dev,0x55555555,i);
1218                 if (zpeekl(zatm_dev,i) != 0x55555555) last = i;
1219                 else {
1220                         zpokel(zatm_dev,0xAAAAAAAA,i);
1221                         if (zpeekl(zatm_dev,i) != 0xAAAAAAAA) last = i;
1222                         else zpokel(zatm_dev,i,i);
1223                 }
1224         }
1225         for (i = 0; i < last; i += RAM_INCREMENT)
1226                 if (zpeekl(zatm_dev,i) != i) break;
1227         zatm_dev->mem = i << 2;
1228         while (i) zpokel(zatm_dev,0,--i);
1229         /* reset again to rebuild memory pointers */
1230         zout(0,SWR);
1231         while (!(zin(GSR) & uPD98401_INT_IND));
1232         zout(uPD98401_GMR_ONE | uPD98401_BURST8 | uPD98401_BURST4 |
1233             uPD98401_BURST2 | uPD98401_GMR_PM | uPD98401_GMR_DR,GMR);
1234         /* TODO: should shrink allocation now */
1235         printk("mem=%dkB,%s (",zatm_dev->mem >> 10,zatm_dev->copper ? "UTP" :
1236             "MMF");
1237         for (i = 0; i < ESI_LEN; i++)
1238                 printk("%02X%s",dev->esi[i],i == ESI_LEN-1 ? ")\n" : "-");
1239         do {
1240                 unsigned long flags;
1241
1242                 spin_lock_irqsave(&zatm_dev->lock, flags);
1243                 t0 = zpeekl(zatm_dev,uPD98401_TSR);
1244                 udelay(10);
1245                 t1 = zpeekl(zatm_dev,uPD98401_TSR);
1246                 udelay(1010);
1247                 t2 = zpeekl(zatm_dev,uPD98401_TSR);
1248                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1249         }
1250         while (t0 > t1 || t1 > t2); /* loop if wrapping ... */
1251         zatm_dev->khz = t2-2*t1+t0;
1252         printk(KERN_NOTICE DEV_LABEL "(itf %d): uPD98401 %d.%d at %d.%03d "
1253             "MHz\n",dev->number,
1254             (zin(VER) & uPD98401_MAJOR) >> uPD98401_MAJOR_SHIFT,
1255             zin(VER) & uPD98401_MINOR,zatm_dev->khz/1000,zatm_dev->khz % 1000);
1256         return uPD98402_init(dev);
1257 }
1258
1259
1260 static int __init zatm_start(struct atm_dev *dev)
1261 {
1262         struct zatm_dev *zatm_dev = ZATM_DEV(dev);
1263         struct pci_dev *pdev = zatm_dev->pci_dev;
1264         unsigned long curr;
1265         int pools,vccs,rx;
1266         int error, i, ld;
1267
1268         DPRINTK("zatm_start\n");
1269         zatm_dev->rx_map = zatm_dev->tx_map = NULL;
1270         for (i = 0; i < NR_MBX; i++)
1271                 zatm_dev->mbx_start[i] = 0;
1272         error = request_irq(zatm_dev->irq, zatm_int, SA_SHIRQ, DEV_LABEL, dev);
1273         if (error < 0) {
1274                 printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n",
1275                     dev->number,zatm_dev->irq);
1276                 goto done;
1277         }
1278         /* define memory regions */
1279         pools = NR_POOLS;
1280         if (NR_SHAPERS*SHAPER_SIZE > pools*POOL_SIZE)
1281                 pools = NR_SHAPERS*SHAPER_SIZE/POOL_SIZE;
1282         vccs = (zatm_dev->mem-NR_SHAPERS*SHAPER_SIZE-pools*POOL_SIZE)/
1283             (2*VC_SIZE+RX_SIZE);
1284         ld = -1;
1285         for (rx = 1; rx < vccs; rx <<= 1) ld++;
1286         dev->ci_range.vpi_bits = 0; /* @@@ no VPI for now */
1287         dev->ci_range.vci_bits = ld;
1288         dev->link_rate = ATM_OC3_PCR;
1289         zatm_dev->chans = vccs; /* ??? */
1290         curr = rx*RX_SIZE/4;
1291         DPRINTK("RX pool 0x%08lx\n",curr);
1292         zpokel(zatm_dev,curr,uPD98401_PMA); /* receive pool */
1293         zatm_dev->pool_base = curr;
1294         curr += pools*POOL_SIZE/4;
1295         DPRINTK("Shapers 0x%08lx\n",curr);
1296         zpokel(zatm_dev,curr,uPD98401_SMA); /* shapers */
1297         curr += NR_SHAPERS*SHAPER_SIZE/4;
1298         DPRINTK("Free    0x%08lx\n",curr);
1299         zpokel(zatm_dev,curr,uPD98401_TOS); /* free pool */
1300         printk(KERN_INFO DEV_LABEL "(itf %d): %d shapers, %d pools, %d RX, "
1301             "%ld VCs\n",dev->number,NR_SHAPERS,pools,rx,
1302             (zatm_dev->mem-curr*4)/VC_SIZE);
1303         /* create mailboxes */
1304         for (i = 0; i < NR_MBX; i++) {
1305                 void *mbx;
1306                 dma_addr_t mbx_dma;
1307
1308                 if (!mbx_entries[i])
1309                         continue;
1310                 mbx = pci_alloc_consistent(pdev, 2*MBX_SIZE(i), &mbx_dma);
1311                 if (!mbx) {
1312                         error = -ENOMEM;
1313                         goto out;
1314                 }
1315                 /*
1316                  * Alignment provided by pci_alloc_consistent() isn't enough
1317                  * for this device.
1318                  */
1319                 if (((unsigned long)mbx ^ mbx_dma) & 0xffff) {
1320                         printk(KERN_ERR DEV_LABEL "(itf %d): system "
1321                                "bus incompatible with driver\n", dev->number);
1322                         pci_free_consistent(pdev, 2*MBX_SIZE(i), mbx, mbx_dma);
1323                         error = -ENODEV;
1324                         goto out;
1325                 }
1326                 DPRINTK("mbx@0x%08lx-0x%08lx\n", mbx, mbx + MBX_SIZE(i));
1327                 zatm_dev->mbx_start[i] = (unsigned long)mbx;
1328                 zatm_dev->mbx_dma[i] = mbx_dma;
1329                 zatm_dev->mbx_end[i] = (zatm_dev->mbx_start[i] + MBX_SIZE(i)) &
1330                                         0xffff;
1331                 zout(mbx_dma >> 16, MSH(i));
1332                 zout(mbx_dma, MSL(i));
1333                 zout(zatm_dev->mbx_end[i], MBA(i));
1334                 zout((unsigned long)mbx & 0xffff, MTA(i));
1335                 zout((unsigned long)mbx & 0xffff, MWA(i));
1336         }
1337         error = start_tx(dev);
1338         if (error)
1339                 goto out;
1340         error = start_rx(dev);
1341         if (error)
1342                 goto out_tx;
1343         error = dev->phy->start(dev);
1344         if (error)
1345                 goto out_rx;
1346         zout(0xffffffff,IMR); /* enable interrupts */
1347         /* enable TX & RX */
1348         zout(zin(GMR) | uPD98401_GMR_SE | uPD98401_GMR_RE,GMR);
1349 done:
1350         return error;
1351
1352 out_rx:
1353         kfree(zatm_dev->rx_map);
1354 out_tx:
1355         kfree(zatm_dev->tx_map);
1356 out:
1357         while (i-- > 0) {
1358                 pci_free_consistent(pdev, 2*MBX_SIZE(i),
1359                                     (void *)zatm_dev->mbx_start[i],
1360                                     zatm_dev->mbx_dma[i]);
1361         }
1362         free_irq(zatm_dev->irq, dev);
1363         goto done;
1364 }
1365
1366
1367 static void zatm_close(struct atm_vcc *vcc)
1368 {
1369         DPRINTK(">zatm_close\n");
1370         if (!ZATM_VCC(vcc)) return;
1371         clear_bit(ATM_VF_READY,&vcc->flags);
1372         close_rx(vcc);
1373         EVENT("close_tx\n",0,0);
1374         close_tx(vcc);
1375         DPRINTK("zatm_close: done waiting\n");
1376         /* deallocate memory */
1377         kfree(ZATM_VCC(vcc));
1378         vcc->dev_data = NULL;
1379         clear_bit(ATM_VF_ADDR,&vcc->flags);
1380 }
1381
1382
1383 static int zatm_open(struct atm_vcc *vcc)
1384 {
1385         struct zatm_dev *zatm_dev;
1386         struct zatm_vcc *zatm_vcc;
1387         short vpi = vcc->vpi;
1388         int vci = vcc->vci;
1389         int error;
1390
1391         DPRINTK(">zatm_open\n");
1392         zatm_dev = ZATM_DEV(vcc->dev);
1393         if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1394                 vcc->dev_data = NULL;
1395         if (vci != ATM_VPI_UNSPEC && vpi != ATM_VCI_UNSPEC)
1396                 set_bit(ATM_VF_ADDR,&vcc->flags);
1397         if (vcc->qos.aal != ATM_AAL5) return -EINVAL; /* @@@ AAL0 */
1398         DPRINTK(DEV_LABEL "(itf %d): open %d.%d\n",vcc->dev->number,vcc->vpi,
1399             vcc->vci);
1400         if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) {
1401                 zatm_vcc = kmalloc(sizeof(struct zatm_vcc),GFP_KERNEL);
1402                 if (!zatm_vcc) {
1403                         clear_bit(ATM_VF_ADDR,&vcc->flags);
1404                         return -ENOMEM;
1405                 }
1406                 vcc->dev_data = zatm_vcc;
1407                 ZATM_VCC(vcc)->tx_chan = 0; /* for zatm_close after open_rx */
1408                 if ((error = open_rx_first(vcc))) {
1409                         zatm_close(vcc);
1410                         return error;
1411                 }
1412                 if ((error = open_tx_first(vcc))) {
1413                         zatm_close(vcc);
1414                         return error;
1415                 }
1416         }
1417         if (vci == ATM_VPI_UNSPEC || vpi == ATM_VCI_UNSPEC) return 0;
1418         if ((error = open_rx_second(vcc))) {
1419                 zatm_close(vcc);
1420                 return error;
1421         }
1422         if ((error = open_tx_second(vcc))) {
1423                 zatm_close(vcc);
1424                 return error;
1425         }
1426         set_bit(ATM_VF_READY,&vcc->flags);
1427         return 0;
1428 }
1429
1430
1431 static int zatm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos,int flags)
1432 {
1433         printk("Not yet implemented\n");
1434         return -ENOSYS;
1435         /* @@@ */
1436 }
1437
1438
1439 static int zatm_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
1440 {
1441         struct zatm_dev *zatm_dev;
1442         unsigned long flags;
1443
1444         zatm_dev = ZATM_DEV(dev);
1445         switch (cmd) {
1446                 case ZATM_GETPOOLZ:
1447                         if (!capable(CAP_NET_ADMIN)) return -EPERM;
1448                         /* fall through */
1449                 case ZATM_GETPOOL:
1450                         {
1451                                 struct zatm_pool_info info;
1452                                 int pool;
1453
1454                                 if (get_user(pool,
1455                                     &((struct zatm_pool_req __user *) arg)->pool_num))
1456                                         return -EFAULT;
1457                                 if (pool < 0 || pool > ZATM_LAST_POOL)
1458                                         return -EINVAL;
1459                                 spin_lock_irqsave(&zatm_dev->lock, flags);
1460                                 info = zatm_dev->pool_info[pool];
1461                                 if (cmd == ZATM_GETPOOLZ) {
1462                                         zatm_dev->pool_info[pool].rqa_count = 0;
1463                                         zatm_dev->pool_info[pool].rqu_count = 0;
1464                                 }
1465                                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1466                                 return copy_to_user(
1467                                     &((struct zatm_pool_req __user *) arg)->info,
1468                                     &info,sizeof(info)) ? -EFAULT : 0;
1469                         }
1470                 case ZATM_SETPOOL:
1471                         {
1472                                 struct zatm_pool_info info;
1473                                 int pool;
1474
1475                                 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1476                                 if (get_user(pool,
1477                                     &((struct zatm_pool_req __user *) arg)->pool_num))
1478                                         return -EFAULT;
1479                                 if (pool < 0 || pool > ZATM_LAST_POOL)
1480                                         return -EINVAL;
1481                                 if (copy_from_user(&info,
1482                                     &((struct zatm_pool_req __user *) arg)->info,
1483                                     sizeof(info))) return -EFAULT;
1484                                 if (!info.low_water)
1485                                         info.low_water = zatm_dev->
1486                                             pool_info[pool].low_water;
1487                                 if (!info.high_water)
1488                                         info.high_water = zatm_dev->
1489                                             pool_info[pool].high_water;
1490                                 if (!info.next_thres)
1491                                         info.next_thres = zatm_dev->
1492                                             pool_info[pool].next_thres;
1493                                 if (info.low_water >= info.high_water ||
1494                                     info.low_water < 0)
1495                                         return -EINVAL;
1496                                 spin_lock_irqsave(&zatm_dev->lock, flags);
1497                                 zatm_dev->pool_info[pool].low_water =
1498                                     info.low_water;
1499                                 zatm_dev->pool_info[pool].high_water =
1500                                     info.high_water;
1501                                 zatm_dev->pool_info[pool].next_thres =
1502                                     info.next_thres;
1503                                 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1504                                 return 0;
1505                         }
1506                 default:
1507                         if (!dev->phy->ioctl) return -ENOIOCTLCMD;
1508                         return dev->phy->ioctl(dev,cmd,arg);
1509         }
1510 }
1511
1512
1513 static int zatm_getsockopt(struct atm_vcc *vcc,int level,int optname,
1514     void __user *optval,int optlen)
1515 {
1516         return -EINVAL;
1517 }
1518
1519
1520 static int zatm_setsockopt(struct atm_vcc *vcc,int level,int optname,
1521     void __user *optval,int optlen)
1522 {
1523         return -EINVAL;
1524 }
1525
1526 static int zatm_send(struct atm_vcc *vcc,struct sk_buff *skb)
1527 {
1528         int error;
1529
1530         EVENT(">zatm_send 0x%lx\n",(unsigned long) skb,0);
1531         if (!ZATM_VCC(vcc)->tx_chan || !test_bit(ATM_VF_READY,&vcc->flags)) {
1532                 if (vcc->pop) vcc->pop(vcc,skb);
1533                 else dev_kfree_skb(skb);
1534                 return -EINVAL;
1535         }
1536         if (!skb) {
1537                 printk(KERN_CRIT "!skb in zatm_send ?\n");
1538                 if (vcc->pop) vcc->pop(vcc,skb);
1539                 return -EINVAL;
1540         }
1541         ATM_SKB(skb)->vcc = vcc;
1542         error = do_tx(skb);
1543         if (error != RING_BUSY) return error;
1544         skb_queue_tail(&ZATM_VCC(vcc)->backlog,skb);
1545         return 0;
1546 }
1547
1548
1549 static void zatm_phy_put(struct atm_dev *dev,unsigned char value,
1550     unsigned long addr)
1551 {
1552         struct zatm_dev *zatm_dev;
1553
1554         zatm_dev = ZATM_DEV(dev);
1555         zwait;
1556         zout(value,CER);
1557         zout(uPD98401_IND_ACC | uPD98401_IA_B0 |
1558             (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1559 }
1560
1561
1562 static unsigned char zatm_phy_get(struct atm_dev *dev,unsigned long addr)
1563 {
1564         struct zatm_dev *zatm_dev;
1565
1566         zatm_dev = ZATM_DEV(dev);
1567         zwait;
1568         zout(uPD98401_IND_ACC | uPD98401_IA_B0 | uPD98401_IA_RW |
1569           (uPD98401_IA_TGT_PHY << uPD98401_IA_TGT_SHIFT) | addr,CMR);
1570         zwait;
1571         return zin(CER) & 0xff;
1572 }
1573
1574
1575 static const struct atmdev_ops ops = {
1576         .open           = zatm_open,
1577         .close          = zatm_close,
1578         .ioctl          = zatm_ioctl,
1579         .getsockopt     = zatm_getsockopt,
1580         .setsockopt     = zatm_setsockopt,
1581         .send           = zatm_send,
1582         .phy_put        = zatm_phy_put,
1583         .phy_get        = zatm_phy_get,
1584         .change_qos     = zatm_change_qos,
1585 };
1586
1587 static int __devinit zatm_init_one(struct pci_dev *pci_dev,
1588                                    const struct pci_device_id *ent)
1589 {
1590         struct atm_dev *dev;
1591         struct zatm_dev *zatm_dev;
1592         int ret = -ENOMEM;
1593
1594         zatm_dev = (struct zatm_dev *) kmalloc(sizeof(*zatm_dev), GFP_KERNEL);
1595         if (!zatm_dev) {
1596                 printk(KERN_EMERG "%s: memory shortage\n", DEV_LABEL);
1597                 goto out;
1598         }
1599
1600         dev = atm_dev_register(DEV_LABEL, &ops, -1, NULL);
1601         if (!dev)
1602                 goto out_free;
1603
1604         ret = pci_enable_device(pci_dev);
1605         if (ret < 0)
1606                 goto out_deregister;
1607
1608         ret = pci_request_regions(pci_dev, DEV_LABEL);
1609         if (ret < 0)
1610                 goto out_disable;
1611
1612         zatm_dev->pci_dev = pci_dev;
1613         dev->dev_data = zatm_dev;
1614         zatm_dev->copper = (int)ent->driver_data;
1615         if ((ret = zatm_init(dev)) || (ret = zatm_start(dev)))
1616                 goto out_release;
1617
1618         pci_set_drvdata(pci_dev, dev);
1619         zatm_dev->more = zatm_boards;
1620         zatm_boards = dev;
1621         ret = 0;
1622 out:
1623         return ret;
1624
1625 out_release:
1626         pci_release_regions(pci_dev);
1627 out_disable:
1628         pci_disable_device(pci_dev);
1629 out_deregister:
1630         atm_dev_deregister(dev);
1631 out_free:
1632         kfree(zatm_dev);
1633         goto out;
1634 }
1635
1636
1637 MODULE_LICENSE("GPL");
1638
1639 static struct pci_device_id zatm_pci_tbl[] __devinitdata = {
1640         { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1221,
1641                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, ZATM_COPPER },
1642         { PCI_VENDOR_ID_ZEITNET, PCI_DEVICE_ID_ZEITNET_1225,
1643                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1644         { 0, }
1645 };
1646 MODULE_DEVICE_TABLE(pci, zatm_pci_tbl);
1647
1648 static struct pci_driver zatm_driver = {
1649         .name =         DEV_LABEL,
1650         .id_table =     zatm_pci_tbl,
1651         .probe =        zatm_init_one,
1652 };
1653
1654 static int __init zatm_init_module(void)
1655 {
1656         return pci_register_driver(&zatm_driver);
1657 }
1658
1659 module_init(zatm_init_module);
1660 /* module_exit not defined so not unloadable */