drivers/atm/zatm.c

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