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