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