Lines Matching defs:zatm_dev
127 #define zin_n(r) inl(zatm_dev->base+r*4)
128 #define zin(r) inl(zatm_dev->base+uPD98401_##r*4)
129 #define zout(v,r) outl(v,zatm_dev->base+uPD98401_##r*4)
142 static void zpokel(struct zatm_dev *zatm_dev,u32 value,u32 addr)
151 static u32 zpeekl(struct zatm_dev *zatm_dev,u32 addr)
182 struct zatm_dev *zatm_dev;
189 zatm_dev = ZATM_DEV(dev);
198 offset = zatm_dev->pool_info[pool].offset+
202 spin_lock_irqsave(&zatm_dev->lock, flags);
203 free = zpeekl(zatm_dev,zatm_dev->pool_base+2*pool) &
205 spin_unlock_irqrestore(&zatm_dev->lock, flags);
206 if (free >= zatm_dev->pool_info[pool].low_water) return;
208 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
209 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
213 while (free < zatm_dev->pool_info[pool].high_water) {
234 spin_lock_irqsave(&zatm_dev->lock, flags);
235 if (zatm_dev->last_free[pool])
236 ((struct rx_buffer_head *) (zatm_dev->last_free[pool]->
238 zatm_dev->last_free[pool] = skb;
239 skb_queue_tail(&zatm_dev->pool[pool],skb);
240 spin_unlock_irqrestore(&zatm_dev->lock, flags);
244 spin_lock_irqsave(&zatm_dev->lock, flags);
249 spin_unlock_irqrestore(&zatm_dev->lock, flags);
251 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool),
252 zpeekl(zatm_dev,zatm_dev->pool_base+2*pool+1));
282 struct zatm_dev *zatm_dev;
286 zatm_dev = ZATM_DEV(dev);
287 if (!(zatm_dev->pool_info[pool].ref_count++)) {
288 skb_queue_head_init(&zatm_dev->pool[pool]);
292 spin_lock_irqsave(&zatm_dev->lock, flags);
293 zpokel(zatm_dev,((zatm_dev->pool_info[pool].low_water/4) <<
297 zatm_dev->pool_base+pool*2);
298 zpokel(zatm_dev,(unsigned long) dummy,zatm_dev->pool_base+
300 spin_unlock_irqrestore(&zatm_dev->lock, flags);
301 zatm_dev->last_free[pool] = NULL;
304 DPRINTK("pool %d: %d\n",pool,zatm_dev->pool_info[pool].ref_count);
321 struct zatm_dev *zatm_dev = ZATM_DEV(vcc->dev);
329 zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+i));
332 zpeekl(zatm_dev,uPD98401_IM(zatm_vcc->shaper)+16*i));
333 qrp = (unsigned long *) zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
363 struct zatm_dev *zatm_dev;
369 zatm_dev = ZATM_DEV(dev);
370 pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
379 if (((pos += 16) & 0xffff) == zatm_dev->mbx_end[mbx])
380 pos = zatm_dev->mbx_start[mbx];
386 printk("POOL: 0x%08x, 0x%08x\n",zpeekl(zatm_dev,
387 zatm_dev->pool_base),
388 zpeekl(zatm_dev,zatm_dev->pool_base+1));
420 if (chan < zatm_dev->chans && zatm_dev->rx_map[chan]) {
422 vcc = zatm_dev->rx_map[chan];
424 if (skb == zatm_dev->last_free[pos])
425 zatm_dev->last_free[pos] = NULL;
426 skb_unlink(skb, zatm_dev->pool + pos);
486 struct zatm_dev *zatm_dev;
493 zatm_dev = ZATM_DEV(vcc->dev);
511 spin_lock_irqsave(&zatm_dev->lock, flags);
517 spin_unlock_irqrestore(&zatm_dev->lock, flags);
523 spin_lock_irqsave(&zatm_dev->lock, flags);
524 zpokel(zatm_dev,zatm_vcc->pool << uPD98401_RXVC_POOL_SHIFT,
526 zpokel(zatm_dev,uPD98401_RXVC_OD | (vcc->qos.aal == ATM_AAL5 ?
528 zpokel(zatm_dev,0,chan*VC_SIZE/4+2);
530 zatm_dev->rx_map[chan] = vcc;
531 spin_unlock_irqrestore(&zatm_dev->lock, flags);
538 struct zatm_dev *zatm_dev;
544 zatm_dev = ZATM_DEV(vcc->dev);
547 spin_lock_irqsave(&zatm_dev->lock, flags);
551 zpokel(zatm_dev,(zpeekl(zatm_dev,pos) & ~(0xffff << shift)) |
553 spin_unlock_irqrestore(&zatm_dev->lock, flags);
560 struct zatm_dev *zatm_dev;
566 zatm_dev = ZATM_DEV(vcc->dev);
571 spin_lock_irqsave(&zatm_dev->lock, flags);
574 zpokel(zatm_dev,zpeekl(zatm_dev,pos) & ~(0xffff << shift),pos);
579 spin_unlock_irqrestore(&zatm_dev->lock, flags);
581 spin_lock_irqsave(&zatm_dev->lock, flags);
593 spin_unlock_irqrestore(&zatm_dev->lock, flags);
594 zatm_dev->rx_map[zatm_vcc->rx_chan] = NULL;
602 struct zatm_dev *zatm_dev;
606 zatm_dev = ZATM_DEV(dev);
607 zatm_dev->rx_map = kcalloc(zatm_dev->chans,
608 sizeof(*zatm_dev->rx_map),
610 if (!zatm_dev->rx_map) return -ENOMEM;
612 zpokel(zatm_dev,(1 << dev->ci_range.vci_bits)-1,uPD98401_VRR);
615 zatm_dev->pool_info[i].ref_count = 0;
616 zatm_dev->pool_info[i].rqa_count = 0;
617 zatm_dev->pool_info[i].rqu_count = 0;
618 zatm_dev->pool_info[i].low_water = LOW_MARK;
619 zatm_dev->pool_info[i].high_water = HIGH_MARK;
620 zatm_dev->pool_info[i].offset = 0;
621 zatm_dev->pool_info[i].next_off = 0;
622 zatm_dev->pool_info[i].next_cnt = 0;
623 zatm_dev->pool_info[i].next_thres = OFF_CNG_THRES;
635 struct zatm_dev *zatm_dev;
643 zatm_dev = ZATM_DEV(vcc->dev);
646 spin_lock_irqsave(&zatm_dev->lock, flags);
649 spin_unlock_irqrestore(&zatm_dev->lock, flags);
701 DPRINTK("QRP=0x%08lx\n",zpeekl(zatm_dev,zatm_vcc->tx_chan*VC_SIZE/4+
706 spin_unlock_irqrestore(&zatm_dev->lock, flags);
746 struct zatm_dev *zatm_dev;
751 zatm_dev = ZATM_DEV(dev);
752 pos = (zatm_dev->mbx_start[mbx] & ~0xffffUL) | zin(MTA(mbx));
768 chan = (zatm_dev->mbx_start[mbx][pos >> 2] & uPD98401_TXI_CONN)
771 if (chan < zatm_dev->chans && zatm_dev->tx_map[chan])
772 dequeue_tx(zatm_dev->tx_map[chan]);
778 if (((pos += 4) & 0xffff) == zatm_dev->mbx_end[mbx])
779 pos = zatm_dev->mbx_start[mbx];
791 struct zatm_dev *zatm_dev;
797 zatm_dev = ZATM_DEV(dev);
798 if (!zatm_dev->free_shapers) return -EAGAIN;
799 for (shaper = 0; !((zatm_dev->free_shapers >> shaper) & 1); shaper++);
800 zatm_dev->free_shapers &= ~1 << shaper;
804 zatm_dev->ubr_ref_cnt++;
805 zatm_dev->ubr = shaper;
820 if (max > zatm_dev->tx_bw) max = zatm_dev->tx_bw;
838 if (zatm_dev->tx_bw < *pcr) return -EAGAIN;
839 zatm_dev->tx_bw -= *pcr;
841 spin_lock_irqsave(&zatm_dev->lock, flags);
843 zpokel(zatm_dev,(i << uPD98401_IM_I_SHIFT) | m,uPD98401_IM(shaper));
844 zpokel(zatm_dev,c << uPD98401_PC_C_SHIFT,uPD98401_PC(shaper));
845 zpokel(zatm_dev,0,uPD98401_X(shaper));
846 zpokel(zatm_dev,0,uPD98401_Y(shaper));
847 zpokel(zatm_dev,uPD98401_PS_E,uPD98401_PS(shaper));
848 spin_unlock_irqrestore(&zatm_dev->lock, flags);
855 struct zatm_dev *zatm_dev;
858 zatm_dev = ZATM_DEV(dev);
859 if (shaper == zatm_dev->ubr) {
860 if (--zatm_dev->ubr_ref_cnt) return;
861 zatm_dev->ubr = -1;
863 spin_lock_irqsave(&zatm_dev->lock, flags);
864 zpokel(zatm_dev,zpeekl(zatm_dev,uPD98401_PS(shaper)) & ~uPD98401_PS_E,
866 spin_unlock_irqrestore(&zatm_dev->lock, flags);
867 zatm_dev->free_shapers |= 1 << shaper;
873 struct zatm_dev *zatm_dev;
879 zatm_dev = ZATM_DEV(vcc->dev);
893 spin_lock_irqsave(&zatm_dev->lock, flags);
904 spin_unlock_irqrestore(&zatm_dev->lock, flags);
906 zatm_dev->tx_map[chan] = NULL;
907 if (zatm_vcc->shaper != zatm_dev->ubr) {
908 zatm_dev->tx_bw += vcc->qos.txtp.min_pcr;
917 struct zatm_dev *zatm_dev;
925 zatm_dev = ZATM_DEV(vcc->dev);
929 spin_lock_irqsave(&zatm_dev->lock, flags);
935 spin_unlock_irqrestore(&zatm_dev->lock, flags);
941 if (unlimited && zatm_dev->ubr != -1) zatm_vcc->shaper = zatm_dev->ubr;
968 zpokel(zatm_dev,virt_to_bus(zatm_vcc->ring),
976 struct zatm_dev *zatm_dev;
981 zatm_dev = ZATM_DEV(vcc->dev);
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 <<
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;
999 struct zatm_dev *zatm_dev;
1003 zatm_dev = ZATM_DEV(dev);
1004 zatm_dev->tx_map = kmalloc_array(zatm_dev->chans,
1005 sizeof(*zatm_dev->tx_map),
1007 if (!zatm_dev->tx_map) return -ENOMEM;
1008 zatm_dev->tx_bw = ATM_OC3_PCR;
1009 zatm_dev->free_shapers = (1 << NR_SHAPERS)-1;
1010 zatm_dev->ubr = -1;
1011 zatm_dev->ubr_ref_cnt = 0;
1013 for (i = 0; i < NR_SHAPERS; i++) zpokel(zatm_dev,0,uPD98401_PS(i));
1024 struct zatm_dev *zatm_dev;
1029 zatm_dev = ZATM_DEV(dev);
1046 zatm_dev->pool_info[i].rqa_count++;
1061 zatm_dev->pool_info[i].rqu_count++;
1101 static void eprom_set(struct zatm_dev *zatm_dev, unsigned long value,
1106 if ((error = pci_write_config_dword(zatm_dev->pci_dev,cmd,value)))
1112 static unsigned long eprom_get(struct zatm_dev *zatm_dev, unsigned short cmd)
1117 if ((error = pci_read_config_dword(zatm_dev->pci_dev,cmd,&value)))
1124 static void eprom_put_bits(struct zatm_dev *zatm_dev, unsigned long data,
1132 eprom_set(zatm_dev,value,cmd);
1133 eprom_set(zatm_dev,value | ZEPROM_SK,cmd);
1134 eprom_set(zatm_dev,value,cmd);
1139 static void eprom_get_byte(struct zatm_dev *zatm_dev, unsigned char *byte,
1146 eprom_set(zatm_dev,ZEPROM_CS,cmd);
1147 eprom_set(zatm_dev,ZEPROM_CS | ZEPROM_SK,cmd);
1149 if (eprom_get(zatm_dev,cmd) & ZEPROM_DO) *byte |= 1;
1150 eprom_set(zatm_dev,ZEPROM_CS,cmd);
1159 struct zatm_dev *zatm_dev;
1162 zatm_dev = ZATM_DEV(dev);
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 */
1188 struct zatm_dev *zatm_dev;
1195 zatm_dev = ZATM_DEV(dev);
1196 spin_lock_init(&zatm_dev->lock);
1197 pci_dev = zatm_dev->pci_dev;
1198 zatm_dev->base = pci_resource_start(pci_dev, 0);
1199 zatm_dev->irq = pci_dev->irq;
1213 dev->number,pci_dev->revision,zatm_dev->base,zatm_dev->irq);
1220 zpokel(zatm_dev,0x55555555,i);
1221 if (zpeekl(zatm_dev,i) != 0x55555555) last = i;
1223 zpokel(zatm_dev,0xAAAAAAAA,i);
1224 if (zpeekl(zatm_dev,i) != 0xAAAAAAAA) last = i;
1225 else zpokel(zatm_dev,i,i);
1229 if (zpeekl(zatm_dev,i) != i) break;
1230 zatm_dev->mem = i << 2;
1231 while (i) zpokel(zatm_dev,0,--i);
1238 printk("mem=%dkB,%s (",zatm_dev->mem >> 10,zatm_dev->copper ? "UTP" :
1245 spin_lock_irqsave(&zatm_dev->lock, flags);
1246 t0 = zpeekl(zatm_dev,uPD98401_TSR);
1248 t1 = zpeekl(zatm_dev,uPD98401_TSR);
1250 t2 = zpeekl(zatm_dev,uPD98401_TSR);
1251 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1254 zatm_dev->khz = t2-2*t1+t0;
1258 zin(VER) & uPD98401_MINOR,zatm_dev->khz/1000,zatm_dev->khz % 1000);
1265 struct zatm_dev *zatm_dev = ZATM_DEV(dev);
1266 struct pci_dev *pdev = zatm_dev->pci_dev;
1272 zatm_dev->rx_map = zatm_dev->tx_map = NULL;
1274 zatm_dev->mbx_start[i] = 0;
1275 error = request_irq(zatm_dev->irq, zatm_int, IRQF_SHARED, DEV_LABEL, dev);
1278 dev->number,zatm_dev->irq);
1285 vccs = (zatm_dev->mem-NR_SHAPERS*SHAPER_SIZE-pools*POOL_SIZE)/
1292 zatm_dev->chans = vccs; /* ??? */
1295 zpokel(zatm_dev,curr,uPD98401_PMA); /* receive pool */
1296 zatm_dev->pool_base = curr;
1299 zpokel(zatm_dev,curr,uPD98401_SMA); /* shapers */
1302 zpokel(zatm_dev,curr,uPD98401_TOS); /* free pool */
1305 (zatm_dev->mem-curr*4)/VC_SIZE);
1331 zatm_dev->mbx_start[i] = (unsigned long)mbx;
1332 zatm_dev->mbx_dma[i] = mbx_dma;
1333 zatm_dev->mbx_end[i] = (zatm_dev->mbx_start[i] + MBX_SIZE(i)) &
1337 zout(zatm_dev->mbx_end[i], MBA(i));
1357 kfree(zatm_dev->rx_map);
1359 kfree(zatm_dev->tx_map);
1363 (void *)zatm_dev->mbx_start[i],
1364 zatm_dev->mbx_dma[i]);
1366 free_irq(zatm_dev->irq, dev);
1443 struct zatm_dev *zatm_dev;
1446 zatm_dev = ZATM_DEV(dev);
1463 spin_lock_irqsave(&zatm_dev->lock, flags);
1464 info = zatm_dev->pool_info[pool];
1466 zatm_dev->pool_info[pool].rqa_count = 0;
1467 zatm_dev->pool_info[pool].rqu_count = 0;
1469 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1491 info.low_water = zatm_dev->
1494 info.high_water = zatm_dev->
1497 info.next_thres = zatm_dev->
1502 spin_lock_irqsave(&zatm_dev->lock, flags);
1503 zatm_dev->pool_info[pool].low_water =
1505 zatm_dev->pool_info[pool].high_water =
1507 zatm_dev->pool_info[pool].next_thres =
1509 spin_unlock_irqrestore(&zatm_dev->lock, flags);
1544 struct zatm_dev *zatm_dev;
1546 zatm_dev = ZATM_DEV(dev);
1556 struct zatm_dev *zatm_dev;
1558 zatm_dev = ZATM_DEV(dev);
1581 struct zatm_dev *zatm_dev;
1584 zatm_dev = kmalloc(sizeof(*zatm_dev), GFP_KERNEL);
1585 if (!zatm_dev) {
1606 zatm_dev->pci_dev = pci_dev;
1607 dev->dev_data = zatm_dev;
1608 zatm_dev->copper = (int)ent->driver_data;
1613 zatm_dev->more = zatm_boards;
1626 kfree(zatm_dev);