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