taglinefilesource code
lp65arch/i386/kernel/ldt.cunsigned long *lp;
lp94arch/i386/kernel/ldt.clp = (unsigned long *) &current->ldt[ldt_info.entry_number];
lp97arch/i386/kernel/ldt.c*lp = 0;
lp98arch/i386/kernel/ldt.c*(lp+1) = 0;
lp101arch/i386/kernel/ldt.c*lp = ((ldt_info.base_addr & 0x0000ffff) << 16) |
lp103arch/i386/kernel/ldt.c*(lp+1) = (ldt_info.base_addr & 0xff000000) |
lp9arch/ppc/kernel/mk_ramdisk.cunsigned char *lp;
lp38arch/ppc/kernel/mk_ramdisk.clp = (unsigned char *)buf;
lp45arch/ppc/kernel/mk_ramdisk.cfprintf(out, "0x%02X%02X%02X%02X", lp[0], lp[1], lp[2], lp[3]);
lp46arch/ppc/kernel/mk_ramdisk.clp += 4;
lp152drivers/char/lp.cstruct lp_struct *lp = &lp_table[0];
lp154drivers/char/lp.cwhile (irq != lp->irq) {
lp155drivers/char/lp.cif (++lp >= &lp_table[LP_NO])
lp159drivers/char/lp.cwake_up(&lp->lp_wait_q);
lp167drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp173drivers/char/lp.cmemcpy_fromfs(lp->lp_buffer, buf, copy_size);
lp176drivers/char/lp.cif (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
lp210drivers/char/lp.cinterruptible_sleep_on(&lp->lp_wait_q);
lp435drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp444drivers/char/lp.clp->lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
lp445drivers/char/lp.cif (!lp->lp_buffer)
lp460drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp461drivers/char/lp.clp->lp_buffer = NULL;
lp468drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp469drivers/char/lp.clp->lp_buffer = NULL;
lp123drivers/isdn/isdn_net.cisdn_net_bind_channel(isdn_net_local * lp, int idx)
lp129drivers/isdn/isdn_net.clp->isdn_device = dev->drvmap[idx];
lp130drivers/isdn/isdn_net.clp->isdn_channel = dev->chanmap[idx];
lp131drivers/isdn/isdn_net.cdev->rx_netdev[idx] = lp->netdev;
lp132drivers/isdn/isdn_net.cdev->st_netdev[idx] = lp->netdev;
lp198drivers/isdn/isdn_net.cisdn_net_local *lp = &(p->local);
lp202drivers/isdn/isdn_net.cif ((lp->flags & ISDN_NET_CONNECTED) &&
lp203drivers/isdn/isdn_net.c(!lp->dialstate)) {
lp204drivers/isdn/isdn_net.clp->stats.tx_packets++;
lp211drivers/isdn/isdn_net.cif (lp->dialstate == 4 || lp->dialstate == 7
lp212drivers/isdn/isdn_net.c|| lp->dialstate == 8) {
lp213drivers/isdn/isdn_net.clp->dialstate++;
lp219drivers/isdn/isdn_net.cif ((!lp->dialstate) && (lp->flags & ISDN_NET_CONNECTED)) {
lp220drivers/isdn/isdn_net.clp->flags &= ~ISDN_NET_CONNECTED;
lp221drivers/isdn/isdn_net.cisdn_free_channel(lp->isdn_device, lp->isdn_channel,
lp224drivers/isdn/isdn_net.cisdn_ppp_free(lp);
lp226drivers/isdn/isdn_net.cisdn_all_eaz(lp->isdn_device, lp->isdn_channel);
lp227drivers/isdn/isdn_net.cprintk(KERN_INFO "%s: remote hangup\n", lp->name);
lp228drivers/isdn/isdn_net.cprintk(KERN_INFO "%s: Chargesum is %d\n", lp->name,
lp229drivers/isdn/isdn_net.clp->charge);
lp230drivers/isdn/isdn_net.clp->isdn_device = -1;
lp231drivers/isdn/isdn_net.clp->isdn_channel = -1;
lp239drivers/isdn/isdn_net.cif (lp->dialstate >= 5 && lp->dialstate <= 10) {
lp240drivers/isdn/isdn_net.cif (lp->dialstate <= 6) {
lp245drivers/isdn/isdn_net.clp->dialstate = 0;
lp247drivers/isdn/isdn_net.cprintk(KERN_INFO "isdn_net: %s connected\n", lp->name);
lp251drivers/isdn/isdn_net.clp->chargetime = jiffies;
lp253drivers/isdn/isdn_net.cif (lp->first_skb) {
lp254drivers/isdn/isdn_net.cif (!(isdn_net_xmit(&p->dev,lp,lp->first_skb)))
lp255drivers/isdn/isdn_net.clp->first_skb = NULL;
lp262drivers/isdn/isdn_net.cif (lp->dialstate == 4) {
lp263drivers/isdn/isdn_net.clp->dialstate--;
lp272drivers/isdn/isdn_net.clp->charge++;
lp273drivers/isdn/isdn_net.cif (lp->hupflags & 2) {
lp274drivers/isdn/isdn_net.clp->hupflags &= ~1;
lp275drivers/isdn/isdn_net.clp->chargeint = jiffies - lp->chargetime - (2 * HZ);
lp277drivers/isdn/isdn_net.cif (lp->hupflags & 1)
lp278drivers/isdn/isdn_net.clp->hupflags |= 2;
lp279drivers/isdn/isdn_net.clp->chargetime = jiffies;
lp502drivers/isdn/isdn_net.cisdn_net_local *lp = (isdn_net_local *) d->priv;
lp508drivers/isdn/isdn_net.cif (lp->flags & ISDN_NET_CONNECTED) {
lp509drivers/isdn/isdn_net.cprintk(KERN_INFO "isdn_net: local hangup %s\n", lp->name);
lp510drivers/isdn/isdn_net.clp->dialstate = 0;
lp511drivers/isdn/isdn_net.cdev->rx_netdev[isdn_dc2minor(lp->isdn_device,lp->isdn_channel)] = NULL;
lp512drivers/isdn/isdn_net.cdev->st_netdev[isdn_dc2minor(lp->isdn_device,lp->isdn_channel)] = NULL;
lp513drivers/isdn/isdn_net.cisdn_free_channel(lp->isdn_device, lp->isdn_channel, ISDN_USAGE_NET);
lp515drivers/isdn/isdn_net.cisdn_ppp_free(lp);
lp517drivers/isdn/isdn_net.clp->flags &= ~ISDN_NET_CONNECTED;
lp518drivers/isdn/isdn_net.ccmd.driver = lp->isdn_device;
lp520drivers/isdn/isdn_net.ccmd.arg = lp->isdn_channel;
lp522drivers/isdn/isdn_net.cprintk(KERN_INFO "%s: Chargesum is %d\n", lp->name, lp->charge);
lp523drivers/isdn/isdn_net.cisdn_all_eaz(lp->isdn_device, lp->isdn_channel);
lp524drivers/isdn/isdn_net.clp->isdn_device = -1;
lp525drivers/isdn/isdn_net.clp->isdn_channel = -1;
lp536drivers/isdn/isdn_net.cisdn_net_log_packet(u_char * buf, isdn_net_local * lp)
lp546drivers/isdn/isdn_net.cswitch (lp->p_encap) {
lp562drivers/isdn/isdn_net.cif (lp->ppp_minor!=-1) {
lp563drivers/isdn/isdn_net.cif (ippp_table[lp->ppp_minor].mpppcfg &
lp565drivers/isdn/isdn_net.cif (ippp_table[lp->ppp_minor].mpppcfg &
lp631drivers/isdn/isdn_net.cisdn_net_send_skb(struct device *ndev, isdn_net_local *lp,
lp636drivers/isdn/isdn_net.clp->transcount += skb->len;
lp637drivers/isdn/isdn_net.cif (dev->drv[lp->isdn_device]->interface->writebuf_skb) 
lp638drivers/isdn/isdn_net.cret = dev->drv[lp->isdn_device]->interface->
lp639drivers/isdn/isdn_net.cwritebuf_skb(lp->isdn_device, lp->isdn_channel, skb);
lp641drivers/isdn/isdn_net.cif ((ret = isdn_net_send(skb->data, lp->isdn_device,
lp642drivers/isdn/isdn_net.clp->isdn_channel, skb->len)))
lp664drivers/isdn/isdn_net.cisdn_net_xmit(struct device *ndev, isdn_net_local *lp, struct sk_buff *skb) 
lp670drivers/isdn/isdn_net.cif (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
lp674drivers/isdn/isdn_net.clp->huptimer = 0;
lp675drivers/isdn/isdn_net.cif (lp->cps > 7000) {
lp682drivers/isdn/isdn_net.cif (lp->master)
lp684drivers/isdn/isdn_net.cret = isdn_net_send_skb(ndev, lp, skb);
lp686drivers/isdn/isdn_net.cisdn_net_local *slp = (isdn_net_local *) (lp->srobin->priv);
lp688drivers/isdn/isdn_net.cif (lp->srobin == ndev)
lp689drivers/isdn/isdn_net.cret = isdn_net_send_skb(ndev, lp, skb);
lp691drivers/isdn/isdn_net.cret = ndev->tbusy = isdn_net_start_xmit(skb, lp->srobin);
lp692drivers/isdn/isdn_net.clp->srobin = (slp->slave) ? slp->slave : ndev;
lp693drivers/isdn/isdn_net.cslp = (isdn_net_local *) (lp->srobin->priv);
lp695drivers/isdn/isdn_net.clp->srobin = ndev;
lp698drivers/isdn/isdn_net.cif (lp->slave) {
lp699drivers/isdn/isdn_net.cif (!lp->sqfull) {
lp701drivers/isdn/isdn_net.clp->sqfull = 1;
lp702drivers/isdn/isdn_net.clp->sqfull_stamp = jiffies;
lp706drivers/isdn/isdn_net.cif ((jiffies - lp->sqfull_stamp) > lp->slavedelay)
lp707drivers/isdn/isdn_net.cisdn_net_force_dial_lp((isdn_net_local *) lp->slave->priv);
lp713drivers/isdn/isdn_net.cret = isdn_net_send_skb(ndev, lp, skb);
lp714drivers/isdn/isdn_net.cif (lp->sqfull && ((jiffies - lp->sqfull_stamp) > (lp->slavedelay + (10*HZ) )))
lp715drivers/isdn/isdn_net.clp->sqfull = 0;
lp728drivers/isdn/isdn_net.cisdn_net_local *lp = (isdn_net_local *) ndev->priv;
lp734drivers/isdn/isdn_net.cif (!lp->dialstate)
lp735drivers/isdn/isdn_net.clp->stats.tx_errors++;
lp753drivers/isdn/isdn_net.cif (!(lp->flags & ISDN_NET_CONNECTED)) {
lp755drivers/isdn/isdn_net.cif (lp->phone[1]) {
lp762drivers/isdn/isdn_net.clp->l2_proto,
lp763drivers/isdn/isdn_net.clp->l3_proto,
lp764drivers/isdn/isdn_net.clp->pre_device,
lp765drivers/isdn/isdn_net.clp->pre_channel)) < 0) {
lp774drivers/isdn/isdn_net.cisdn_net_log_packet(buf, lp);
lp775drivers/isdn/isdn_net.clp->dialstate = 1;
lp776drivers/isdn/isdn_net.clp->flags |= ISDN_NET_CONNECTED;
lp778drivers/isdn/isdn_net.cisdn_net_bind_channel(lp, chi);
lp780drivers/isdn/isdn_net.cif (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
lp781drivers/isdn/isdn_net.cif (isdn_ppp_bind(lp) < 0) {
lp782drivers/isdn/isdn_net.clp->dialstate = 0;
lp783drivers/isdn/isdn_net.cisdn_free_channel(lp->isdn_device,
lp784drivers/isdn/isdn_net.clp->isdn_channel,
lp793drivers/isdn/isdn_net.clp->first_skb = skb;
lp821drivers/isdn/isdn_net.cif (!lp->dialstate) {
lp822drivers/isdn/isdn_net.cif (lp->first_skb) {
lp823drivers/isdn/isdn_net.cif (isdn_net_xmit(ndev,lp,lp->first_skb))
lp825drivers/isdn/isdn_net.clp->first_skb = NULL;
lp827drivers/isdn/isdn_net.creturn(isdn_net_xmit(ndev, lp, skb));
lp865drivers/isdn/isdn_net.cisdn_net_local *lp = (isdn_net_local *) dev->priv;
lp866drivers/isdn/isdn_net.creturn &lp->stats;
lp928drivers/isdn/isdn_net.cisdn_net_local *lp = (isdn_net_local *) ndev->priv;
lp930drivers/isdn/isdn_net.cisdn_net_local *olp = lp;  /* original 'lp' */
lp933drivers/isdn/isdn_net.clp->transcount += skb->len;
lp934drivers/isdn/isdn_net.clp->stats.rx_packets++;
lp935drivers/isdn/isdn_net.clp->huptimer = 0;
lp937drivers/isdn/isdn_net.cif (lp->master) {
lp941drivers/isdn/isdn_net.cndev = lp->master;
lp942drivers/isdn/isdn_net.clp = (isdn_net_local *) ndev->priv;
lp943drivers/isdn/isdn_net.clp->stats.rx_packets++;
lp944drivers/isdn/isdn_net.clp->huptimer = 0;
lp953drivers/isdn/isdn_net.cswitch (lp->p_encap) {
lp975drivers/isdn/isdn_net.cisdn_ppp_receive(lp->netdev, olp, skb);
lp980drivers/isdn/isdn_net.clp->name);
lp1000drivers/isdn/isdn_net.cisdn_net_local *lp = &p->local;
lp1001drivers/isdn/isdn_net.cif ((lp->flags & ISDN_NET_CONNECTED) &&
lp1002drivers/isdn/isdn_net.c(!lp->dialstate)) {
lp1026drivers/isdn/isdn_net.cisdn_net_local *lp = &p->local;
lp1027drivers/isdn/isdn_net.cif ((lp->flags & ISDN_NET_CONNECTED) &&
lp1028drivers/isdn/isdn_net.c(!lp->dialstate)) {
lp1087drivers/isdn/isdn_net.cisdn_net_local *lp = dev->priv;
lp1090drivers/isdn/isdn_net.cswitch (lp->p_encap) {
lp1115drivers/isdn/isdn_net.cif (lp->ppp_minor!=-1) {
lp1116drivers/isdn/isdn_net.cif (ippp_table[lp->ppp_minor].mpppcfg &
lp1118drivers/isdn/isdn_net.cif (ippp_table[lp->ppp_minor].mpppcfg &
lp1143drivers/isdn/isdn_net.cisdn_net_local *lp = dev->priv;
lp1146drivers/isdn/isdn_net.cif (lp->p_encap == ISDN_NET_ENCAP_ETHER) {
lp1177drivers/isdn/isdn_net.cisdn_net_local *lp = (isdn_net_local *)ndev->priv;
lp1190drivers/isdn/isdn_net.clp->org_hcb               = ndev->header_cache_bind;
lp1191drivers/isdn/isdn_net.clp->org_hcu               = ndev->header_cache_update;
lp1529drivers/isdn/isdn_net.cisdn_net_local *lp = &(p->local);
lp1539drivers/isdn/isdn_net.clp->name);
lp1545drivers/isdn/isdn_net.cif (lp->master) {
lp1546drivers/isdn/isdn_net.cisdn_net_local *mlp = (isdn_net_local *) lp->master->priv;
lp1547drivers/isdn/isdn_net.cprintk(KERN_DEBUG "ICALLslv: %s\n", lp->name);
lp1553drivers/isdn/isdn_net.cif ((isdn_net_local *) mlp->slave->priv == lp)
lp1566drivers/isdn/isdn_net.cif (lp->flags & ISDN_NET_CALLBACK) {
lp1569drivers/isdn/isdn_net.clp->name, nr, eaz);
lp1570drivers/isdn/isdn_net.cif (lp->phone[1]) {
lp1572drivers/isdn/isdn_net.cif ((chi = isdn_get_free_channel(ISDN_USAGE_NET, lp->l2_proto,
lp1573drivers/isdn/isdn_net.clp->l3_proto,
lp1574drivers/isdn/isdn_net.clp->pre_device,
lp1575drivers/isdn/isdn_net.clp->pre_channel)) < 0) {
lp1576drivers/isdn/isdn_net.cprintk(KERN_WARNING "isdn_net_find_icall: No channel for %s\n", lp->name);
lp1581drivers/isdn/isdn_net.clp->dialstate = 1;
lp1582drivers/isdn/isdn_net.clp->flags |= ISDN_NET_CONNECTED;
lp1584drivers/isdn/isdn_net.cisdn_net_bind_channel(lp, chi);
lp1586drivers/isdn/isdn_net.cif (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
lp1587drivers/isdn/isdn_net.cif (isdn_ppp_bind(lp) < 0) {
lp1590drivers/isdn/isdn_net.clp->dialstate = 0;
lp1599drivers/isdn/isdn_net.cprintk(KERN_WARNING "isdn_net: %s: No phone number\n", lp->name);
lp1603drivers/isdn/isdn_net.cprintk(KERN_DEBUG "%s: call from %s -> %s accepted\n", lp->name, nr,
lp1623drivers/isdn/isdn_net.cdev->st_netdev[idx] = lp->netdev;
lp1634drivers/isdn/isdn_net.cif (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
lp1635drivers/isdn/isdn_net.cif (isdn_ppp_bind(lp) < 0) {
lp1638drivers/isdn/isdn_net.clp->dialstate = 0;
lp1678drivers/isdn/isdn_net.cint isdn_net_force_dial_lp(isdn_net_local * lp)
lp1680drivers/isdn/isdn_net.cif ((!(lp->flags & ISDN_NET_CONNECTED)) && !lp->dialstate) {
lp1682drivers/isdn/isdn_net.cif (lp->phone[1]) {
lp1687drivers/isdn/isdn_net.cif ((chi = isdn_get_free_channel(ISDN_USAGE_NET, lp->l2_proto,
lp1688drivers/isdn/isdn_net.clp->l3_proto,
lp1689drivers/isdn/isdn_net.clp->pre_device,
lp1690drivers/isdn/isdn_net.clp->pre_channel)) < 0) {
lp1691drivers/isdn/isdn_net.cprintk(KERN_WARNING "isdn_net_force_dial: No channel for %s\n", lp->name);
lp1695drivers/isdn/isdn_net.clp->dialstate = 1;
lp1696drivers/isdn/isdn_net.clp->flags |= ISDN_NET_CONNECTED;
lp1698drivers/isdn/isdn_net.cisdn_net_bind_channel(lp, chi);
lp1700drivers/isdn/isdn_net.cif (lp->p_encap == ISDN_NET_ENCAP_SYNCPPP)
lp1701drivers/isdn/isdn_net.cif (isdn_ppp_bind(lp) < 0) {
lp1702drivers/isdn/isdn_net.clp->dialstate = 0;
lp1703drivers/isdn/isdn_net.cisdn_free_channel(lp->isdn_device, lp->isdn_channel, ISDN_USAGE_NET);
lp59drivers/isdn/isdn_ppp.cstatic void isdn_ppp_push_higher(isdn_net_dev * net_dev, isdn_net_local * lp,
lp76drivers/isdn/isdn_ppp.cint isdn_ppp_free(isdn_net_local * lp)
lp78drivers/isdn/isdn_ppp.cif (lp->ppp_minor < 0)
lp82drivers/isdn/isdn_ppp.cif(lp->master)
lp85drivers/isdn/isdn_ppp.clp->last->next = lp->next;
lp86drivers/isdn/isdn_ppp.clp->next->last = lp->last;
lp87drivers/isdn/isdn_ppp.cif(lp->netdev->queue == lp)
lp88drivers/isdn/isdn_ppp.clp->netdev->queue = lp->next;
lp89drivers/isdn/isdn_ppp.clp->next = lp->last = lp;
lp91drivers/isdn/isdn_ppp.cif(lp == &p->local) {
lp92drivers/isdn/isdn_ppp.clp->netdev = p;
lp98drivers/isdn/isdn_ppp.clp->netdev->ib.bundled = 0;
lp104drivers/isdn/isdn_ppp.cisdn_ppp_hangup(lp->ppp_minor);
lp106drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "isdn_ppp_free %d %lx %lx\n", lp->ppp_minor, (long) lp,(long) ippp_table[lp->ppp_minor].lp);
lp108drivers/isdn/isdn_ppp.cippp_table[lp->ppp_minor].lp = NULL;
lp112drivers/isdn/isdn_ppp.cint isdn_ppp_bind(isdn_net_local * lp)
lp119drivers/isdn/isdn_ppp.cif (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
lp131drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "find_minor, %d lp: %08lx\n", i, (long) lp);
lp142drivers/isdn/isdn_ppp.clp->ppp_minor = i;
lp143drivers/isdn/isdn_ppp.cippp_table[lp->ppp_minor].lp = lp;
lp145drivers/isdn/isdn_ppp.cname = lp->name;
lp147drivers/isdn/isdn_ppp.cippp_table[lp->ppp_minor].unit = unit;
lp149drivers/isdn/isdn_ppp.cippp_table[lp->ppp_minor].state = IPPP_OPEN | IPPP_CONNECT | IPPP_NOBLOCK;
lp156drivers/isdn/isdn_ppp.cif (ippp_table[lp->ppp_minor].wq)
lp157drivers/isdn/isdn_ppp.cwake_up_interruptible(&ippp_table[lp->ppp_minor].wq);
lp159drivers/isdn/isdn_ppp.creturn lp->ppp_minor;
lp186drivers/isdn/isdn_ppp.cippp_table[minor].lp = 0;
lp226drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "ippp: release, minor: %d %lx\n", minor, (long) ippp_table[minor].lp);
lp229drivers/isdn/isdn_ppp.cif (ippp_table[minor].lp) {  /* a lp address says: this link is still up */
lp232drivers/isdn/isdn_ppp.cif(&p->local == ippp_table[minor].lp)
lp238drivers/isdn/isdn_ppp.cp = ippp_table[minor].lp->netdev;
lp240drivers/isdn/isdn_ppp.cippp_table[minor].lp->ppp_minor = -1;
lp242drivers/isdn/isdn_ppp.cippp_table[minor].lp = NULL;
lp327drivers/isdn/isdn_ppp.cippp_table[minor].lp->netdev->dev.tbusy = 0;
lp489drivers/isdn/isdn_ppp.cisdn_net_local *lp;
lp494drivers/isdn/isdn_ppp.clp = ippp_table[minor].lp;
lp498drivers/isdn/isdn_ppp.cif (!lp)
lp501drivers/isdn/isdn_ppp.cif (lp->isdn_device < 0 || lp->isdn_channel < 0)
lp504drivers/isdn/isdn_ppp.cif (dev->drv[lp->isdn_device]->running && lp->dialstate == 0 &&
lp505drivers/isdn/isdn_ppp.c(lp->flags & ISDN_NET_CONNECTED))
lp506drivers/isdn/isdn_ppp.cdev->drv[lp->isdn_device]->interface->writebuf(
lp507drivers/isdn/isdn_ppp.clp->isdn_device,lp->isdn_channel, buf, count, 1);
lp551drivers/isdn/isdn_ppp.cvoid isdn_ppp_receive(isdn_net_dev * net_dev, isdn_net_local * lp, struct sk_buff *skb)
lp559drivers/isdn/isdn_ppp.celse if (ippp_table[lp->ppp_minor].pppcfg & SC_REJ_COMP_AC)
lp563drivers/isdn/isdn_ppp.cif (!(ippp_table[lp->ppp_minor].mpppcfg & SC_REJ_MP_PROT)) {
lp578drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "recv: %d/%04x/%d -> %02x %02x %02x %02x %02x %02x\n", lp->ppp_minor, proto ,
lp582drivers/isdn/isdn_ppp.cif (!(ippp_table[lp->ppp_minor].mpppcfg & SC_IN_SHORT_SEQ)) {
lp590drivers/isdn/isdn_ppp.cif ((tseq = ippp_table[lp->ppp_minor].last_link_seqno) >= sqno) {
lp591drivers/isdn/isdn_ppp.cint range = ippp_table[lp->ppp_minor].range;
lp596drivers/isdn/isdn_ppp.cippp_table[lp->ppp_minor].last_link_seqno = sqno;
lp599drivers/isdn/isdn_ppp.cippp_table[lp->ppp_minor].last_link_seqno = sqno;
lp629drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "ippp: trying ;) to fill mp_queue %d .. UNTESTED!!\n", lp->ppp_minor);
lp684drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, skb, -1);
lp690drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, q->skb, -1);
lp699drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, skb , proto);
lp702drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, skb , -1);
lp706drivers/isdn/isdn_ppp.cstatic void isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb,int proto)
lp763drivers/isdn/isdn_ppp.clp->stats.rx_dropped++;
lp773drivers/isdn/isdn_ppp.cisdn_ppp_fill_rq(skb->data, skb->len, lp->ppp_minor);  /* push data to pppd device */
lp781drivers/isdn/isdn_ppp.clp->huptimer = 0;
lp793drivers/isdn/isdn_ppp.cisdn_net_local *lp = nd->queue;
lp795drivers/isdn/isdn_ppp.cstruct ippp_struct *ipt = ippp_table + lp->ppp_minor;
lp796drivers/isdn/isdn_ppp.cstruct ippp_struct *ipts = ippp_table + lp->netdev->local.ppp_minor;
lp803drivers/isdn/isdn_ppp.creturn (isdn_net_send_skb(dev , lp , skb));
lp875drivers/isdn/isdn_ppp.clp->huptimer = 0;
lp877drivers/isdn/isdn_ppp.cprintk(KERN_INFO "isdn, xmit: Packet blocked: %d %d\n", lp->isdn_device, lp->isdn_channel);
lp881drivers/isdn/isdn_ppp.creturn (isdn_net_send_skb(dev , lp , skb));
lp902drivers/isdn/isdn_ppp.cisdn_net_local *lp,*nlp;
lp914drivers/isdn/isdn_ppp.cnlp = ippp_table[minor].lp;
lp916drivers/isdn/isdn_ppp.clp = p->queue;
lp918drivers/isdn/isdn_ppp.cnlp->last = lp->last;
lp919drivers/isdn/isdn_ppp.clp->last->next = nlp;
lp920drivers/isdn/isdn_ppp.clp->last = nlp;
lp921drivers/isdn/isdn_ppp.cnlp->next = lp;
lp924drivers/isdn/isdn_ppp.cnlp->netdev = lp->netdev;
lp926drivers/isdn/isdn_ppp.cippp_table[nlp->ppp_minor].unit = ippp_table[lp->ppp_minor].unit;
lp928drivers/isdn/isdn_ppp.cippp_table[nlp->ppp_minor].pppcfg |= ippp_table[lp->ppp_minor].pppcfg &
lp931drivers/isdn/isdn_ppp.cippp_table[nlp->ppp_minor].mpppcfg |= ippp_table[lp->ppp_minor].mpppcfg &
lp934drivers/isdn/isdn_ppp.cif (ippp_table[nlp->ppp_minor].mpppcfg != ippp_table[lp->ppp_minor].mpppcfg) {
lp936drivers/isdn/isdn_ppp.cippp_table[nlp->ppp_minor].mpppcfg, ippp_table[lp->ppp_minor].mpppcfg);
lp1127drivers/isdn/isdn_ppp.cisdn_net_local *lp = &net_dev->local;
lp1141drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, ql->skb, -1);
lp1160drivers/isdn/isdn_ppp.cisdn_net_local *lp = (isdn_net_local *) dev->priv;
lp1162drivers/isdn/isdn_ppp.cif (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
lp1204drivers/isdn/isdn_ppp.cisdn_net_local *lp;
lp1209drivers/isdn/isdn_ppp.clp = &ndev->local;
lp1210drivers/isdn/isdn_ppp.cif(!(lp->flags & ISDN_NET_CONNECTED))
lp1213drivers/isdn/isdn_ppp.csdev = lp->slave;
lp378drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp396drivers/net/3c501.clp->stats.tx_errors++;
lp436drivers/net/3c501.clp->tx_pkt_start = gp_start;
lp437drivers/net/3c501.clp->collisions = 0;
lp451drivers/net/3c501.clp->loading=1;
lp464drivers/net/3c501.cif(lp->loading==2)    /* A receive upset our load, despite our best efforts */
lp472drivers/net/3c501.clp->loading=0;
lp494drivers/net/3c501.cstruct net_local *lp;
lp505drivers/net/3c501.clp = (struct net_local *)dev->priv;
lp523drivers/net/3c501.cif(lp->loading==1 && !dev->tbusy)
lp528drivers/net/3c501.clp->loading=2;    /* So we can spot loading interruptions */
lp541drivers/net/3c501.cif(lp->loading==1)
lp548drivers/net/3c501.clp->loading=2;    /* Force a reload */
lp576drivers/net/3c501.clp->stats.tx_aborted_errors++;
lp591drivers/net/3c501.coutw(lp->tx_pkt_start, GP_LOW);
lp593drivers/net/3c501.clp->stats.collisions++;
lp602drivers/net/3c501.clp->stats.tx_packets++;
lp627drivers/net/3c501.clp->stats.rx_missed_errors++;
lp630drivers/net/3c501.clp->stats.rx_length_errors++;
lp675drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp689drivers/net/3c501.clp->stats.rx_over_errors++;
lp708drivers/net/3c501.clp->stats.rx_dropped++;
lp723drivers/net/3c501.clp->stats.rx_packets++;
lp777drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp778drivers/net/3c501.creturn &lp->stats;
lp453drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp468drivers/net/3c507.cif (lp->last_restart == lp->stats.tx_packets) {
lp477drivers/net/3c507.clp->last_restart = lp->stats.tx_packets;
lp519drivers/net/3c507.cstruct net_local *lp;
lp531drivers/net/3c507.clp = (struct net_local *)dev->priv;
lp544drivers/net/3c507.cwhile (lp->tx_reap != lp->tx_head) {
lp545drivers/net/3c507.cunsigned short tx_status = shmem[lp->tx_reap>>1];
lp548drivers/net/3c507.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp552drivers/net/3c507.clp->stats.tx_packets++;
lp553drivers/net/3c507.clp->stats.collisions += tx_status & 0xf;
lp557drivers/net/3c507.clp->stats.tx_errors++;
lp558drivers/net/3c507.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp559drivers/net/3c507.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp560drivers/net/3c507.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp561drivers/net/3c507.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp564drivers/net/3c507.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp565drivers/net/3c507.clp->tx_reap += TX_BUF_SIZE;
lp566drivers/net/3c507.cif (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
lp567drivers/net/3c507.clp->tx_reap = TX_BUF_START;
lp574drivers/net/3c507.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp648drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp652drivers/net/3c507.creturn &lp->stats;
lp659drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp663drivers/net/3c507.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp689drivers/net/3c507.clp->rx_tail = cur_rxbuf;
lp696drivers/net/3c507.c(dev->mem_start + lp->rx_tail + 2);
lp698drivers/net/3c507.c*write_ptr++ = lp->rx_head;        /* Link */
lp705drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp728drivers/net/3c507.clp->tx_cmd_link = IDLELOOP + 4;
lp729drivers/net/3c507.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp764drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp766drivers/net/3c507.cushort tx_block = lp->tx_head;
lp790drivers/net/3c507.c*(ushort*)(dev->mem_start + lp->tx_cmd_link) = tx_block;
lp791drivers/net/3c507.clp->tx_cmd_link = tx_block + 20;
lp794drivers/net/3c507.clp->tx_head = tx_block + TX_BUF_SIZE;
lp795drivers/net/3c507.cif (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
lp796drivers/net/3c507.clp->tx_head = TX_BUF_START;
lp800drivers/net/3c507.cdev->name, ioaddr, length, tx_block, lp->tx_head);
lp803drivers/net/3c507.cif (lp->tx_head != lp->tx_reap)
lp810drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp812drivers/net/3c507.cushort rx_head = lp->rx_head;
lp813drivers/net/3c507.cushort rx_tail = lp->rx_tail;
lp833drivers/net/3c507.clp->stats.rx_errors++;
lp834drivers/net/3c507.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp835drivers/net/3c507.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp836drivers/net/3c507.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp837drivers/net/3c507.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp838drivers/net/3c507.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp847drivers/net/3c507.clp->stats.rx_dropped++;
lp859drivers/net/3c507.clp->stats.rx_packets++;
lp874drivers/net/3c507.clp->rx_head = rx_head;
lp875drivers/net/3c507.clp->rx_tail = rx_tail;
lp384drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp456drivers/net/3c509.cif (tx_status & 0x38) lp->stats.tx_aborted_errors++;
lp529drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp536drivers/net/3c509.creturn &lp->stats;
lp546drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp554drivers/net/3c509.clp->stats.tx_carrier_errors   += inb(ioaddr + 0);
lp555drivers/net/3c509.clp->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
lp557drivers/net/3c509.clp->stats.collisions      += inb(ioaddr + 3);
lp558drivers/net/3c509.clp->stats.tx_window_errors    += inb(ioaddr + 4);
lp559drivers/net/3c509.clp->stats.rx_fifo_errors    += inb(ioaddr + 5);
lp560drivers/net/3c509.clp->stats.tx_packets      += inb(ioaddr + 6);
lp575drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp585drivers/net/3c509.clp->stats.rx_errors++;
lp587drivers/net/3c509.ccase 0x0000:    lp->stats.rx_over_errors++; break;
lp588drivers/net/3c509.ccase 0x0800:    lp->stats.rx_length_errors++; break;
lp589drivers/net/3c509.ccase 0x1000:    lp->stats.rx_frame_errors++; break;
lp590drivers/net/3c509.ccase 0x1800:    lp->stats.rx_length_errors++; break;
lp591drivers/net/3c509.ccase 0x2000:    lp->stats.rx_frame_errors++; break;
lp592drivers/net/3c509.ccase 0x2800:    lp->stats.rx_crc_errors++; break;
lp613drivers/net/3c509.clp->stats.rx_packets++;
lp619drivers/net/3c509.clp->stats.rx_dropped++;
lp746drivers/net/3c59x.cstruct vortex_private *lp;
lp762drivers/net/3c59x.clp = (struct vortex_private *)dev->priv;
lp197drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp201drivers/net/apricot.clp->scb.rfd = (struct i596_rfd *)I596_NULL;
lp217drivers/net/apricot.clp->rx_tail = rfd;
lp222drivers/net/apricot.crfd->next = lp->scb.rfd;
lp223drivers/net/apricot.clp->scb.rfd = rfd;
lp227drivers/net/apricot.clp->rx_tail->next = lp->scb.rfd;
lp235drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp236drivers/net/apricot.cstruct i596_rfd *rfd = lp->scb.rfd;
lp238drivers/net/apricot.clp->rx_tail->next = (struct i596_rfd *)I596_NULL;
lp242drivers/net/apricot.clp->scb.rfd = rfd->next;
lp244drivers/net/apricot.crfd = lp->scb.rfd;
lp246drivers/net/apricot.cwhile (rfd != lp->rx_tail);
lp252drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp260drivers/net/apricot.coutw(((((int)&lp->scp) & 0xffff) | 2), ioaddr);
lp261drivers/net/apricot.coutw((((int)&lp->scp)>>16) & 0xffff, ioaddr);
lp263drivers/net/apricot.clp->last_cmd = jiffies;
lp265drivers/net/apricot.clp->scp.sysbus = 0x00440000;
lp266drivers/net/apricot.clp->scp.iscp = &(lp->iscp);
lp267drivers/net/apricot.clp->iscp.scb = &(lp->scb);
lp268drivers/net/apricot.clp->iscp.stat = 0x0001;
lp269drivers/net/apricot.clp->cmd_backlog = 0;
lp271drivers/net/apricot.clp->cmd_head = lp->scb.cmd = (struct i596_cmd *) I596_NULL;
lp279drivers/net/apricot.cwhile (lp->iscp.stat)
lp283drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp287drivers/net/apricot.clp->scb.command = 0;
lp289drivers/net/apricot.cmemcpy (lp->i596_config, init_setup, 14);
lp290drivers/net/apricot.clp->set_conf.command = CmdConfigure;
lp291drivers/net/apricot.ci596_add_cmd(dev, &lp->set_conf);
lp293drivers/net/apricot.cmemcpy (lp->eth_addr, dev->dev_addr, 6);
lp294drivers/net/apricot.clp->set_add.command = CmdSASetup;
lp295drivers/net/apricot.ci596_add_cmd(dev, &lp->set_add);
lp297drivers/net/apricot.clp->tdr.command = CmdTDR;
lp298drivers/net/apricot.ci596_add_cmd(dev, &lp->tdr);
lp301drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp305drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp309drivers/net/apricot.clp->scb.command = RX_START;
lp313drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp317drivers/net/apricot.clp->scb.status, lp->scb.command);
lp327drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp332drivers/net/apricot.cwhile ((lp->scb.rfd->stat) & STAT_C)
lp334drivers/net/apricot.cif (i596_debug >2) print_eth(lp->scb.rfd->data);
lp336drivers/net/apricot.cif ((lp->scb.rfd->stat) & STAT_OK)
lp339drivers/net/apricot.cint pkt_len = lp->scb.rfd->count & 0x3fff;
lp347drivers/net/apricot.clp->stats.rx_dropped++;
lp352drivers/net/apricot.cmemcpy(skb_put(skb,pkt_len), lp->scb.rfd->data, pkt_len);
lp356drivers/net/apricot.clp->stats.rx_packets++;
lp362drivers/net/apricot.clp->stats.rx_errors++;
lp363drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0001) lp->stats.collisions++;
lp364drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0080) lp->stats.rx_length_errors++;
lp365drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0100) lp->stats.rx_over_errors++;
lp366drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0200) lp->stats.rx_fifo_errors++;
lp367drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0400) lp->stats.rx_frame_errors++;
lp368drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0800) lp->stats.rx_crc_errors++;
lp369drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x1000) lp->stats.rx_length_errors++;
lp372drivers/net/apricot.clp->scb.rfd->stat = 0;
lp373drivers/net/apricot.clp->rx_tail->cmd = 0;
lp374drivers/net/apricot.clp->rx_tail = lp->scb.rfd;
lp375drivers/net/apricot.clp->scb.rfd = lp->scb.rfd->next;
lp376drivers/net/apricot.clp->rx_tail->count = 0;
lp377drivers/net/apricot.clp->rx_tail->cmd = CMD_EOL;
lp387drivers/net/apricot.ci596_cleanup_cmd(struct i596_private *lp)
lp394drivers/net/apricot.cwhile (lp->cmd_head != (struct i596_cmd *) I596_NULL)
lp396drivers/net/apricot.cptr = lp->cmd_head;
lp398drivers/net/apricot.clp->cmd_head = lp->cmd_head->next;
lp399drivers/net/apricot.clp->cmd_backlog--;
lp410drivers/net/apricot.clp->stats.tx_errors++;
lp411drivers/net/apricot.clp->stats.tx_aborted_errors++;
lp430drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp434drivers/net/apricot.clp->scb.status, lp->scb.command);
lp438drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
lp442drivers/net/apricot.ci596_reset(struct device *dev, struct i596_private *lp, int ioaddr)
lp448drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp452drivers/net/apricot.clp->scb.status, lp->scb.command);
lp459drivers/net/apricot.clp->scb.command = CUC_ABORT|RX_ABORT;
lp465drivers/net/apricot.cwhile ((lp->scb.status, lp->scb.command) || lp->scb.command)
lp469drivers/net/apricot.clp->scb.status, lp->scb.command);
lp473drivers/net/apricot.ci596_cleanup_cmd(lp);
lp484drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp497drivers/net/apricot.cif (lp->cmd_head != (struct i596_cmd *) I596_NULL)
lp498drivers/net/apricot.clp->cmd_tail->next = cmd;
lp501drivers/net/apricot.clp->cmd_head = cmd;
lp502drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp506drivers/net/apricot.clp->scb.status, lp->scb.command);
lp510drivers/net/apricot.clp->scb.cmd = cmd;
lp511drivers/net/apricot.clp->scb.command = CUC_START;
lp514drivers/net/apricot.clp->cmd_tail = cmd;
lp515drivers/net/apricot.clp->cmd_backlog++;
lp517drivers/net/apricot.clp->cmd_head = lp->scb.cmd;
lp520drivers/net/apricot.cif (lp->cmd_backlog > 16) 
lp522drivers/net/apricot.cint tickssofar = jiffies - lp->last_cmd;
lp528drivers/net/apricot.ci596_reset(dev, lp, ioaddr);
lp571drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp584drivers/net/apricot.clp->stats.tx_errors++;
lp586drivers/net/apricot.cif (lp->last_restart == lp->stats.tx_packets) {
lp590drivers/net/apricot.ci596_reset(dev,lp, ioaddr);
lp595drivers/net/apricot.clp->scb.command = CUC_START|RX_START;
lp598drivers/net/apricot.clp->last_restart = lp->stats.tx_packets;
lp630drivers/net/apricot.clp->stats.tx_dropped++;
lp652drivers/net/apricot.clp->stats.tx_packets++;
lp681drivers/net/apricot.cstruct i596_private *lp;
lp736drivers/net/apricot.clp = (struct i596_private *)dev->priv;
lp737drivers/net/apricot.cmemset((void *)lp, 0, sizeof(struct i596_private));
lp738drivers/net/apricot.clp->scb.command = 0;
lp739drivers/net/apricot.clp->scb.cmd = (struct i596_cmd *) I596_NULL;
lp740drivers/net/apricot.clp->scb.rfd = (struct i596_rfd *)I596_NULL;
lp749drivers/net/apricot.cstruct i596_private *lp;
lp768drivers/net/apricot.clp = (struct i596_private *)dev->priv;
lp770drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp773drivers/net/apricot.cprintk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command);
lp776drivers/net/apricot.cstatus = lp->scb.status;
lp792drivers/net/apricot.cwhile ((lp->cmd_head != (struct i596_cmd *) I596_NULL) && (lp->cmd_head->status & STAT_C))
lp794drivers/net/apricot.cptr = lp->cmd_head;
lp796drivers/net/apricot.clp->cmd_head = lp->cmd_head->next;
lp797drivers/net/apricot.clp->cmd_backlog--;
lp814drivers/net/apricot.clp->stats.tx_errors++;
lp815drivers/net/apricot.cif ((ptr->status) & 0x0020) lp->stats.collisions++;
lp816drivers/net/apricot.cif (!((ptr->status) & 0x0040)) lp->stats.tx_heartbeat_errors++;
lp817drivers/net/apricot.cif ((ptr->status) & 0x0400) lp->stats.tx_carrier_errors++;
lp818drivers/net/apricot.cif ((ptr->status) & 0x0800) lp->stats.collisions++;
lp819drivers/net/apricot.cif ((ptr->status) & 0x1000) lp->stats.tx_aborted_errors++;
lp859drivers/net/apricot.clp->last_cmd = jiffies;
lp863drivers/net/apricot.cptr = lp->cmd_head;
lp864drivers/net/apricot.cwhile ((ptr != (struct i596_cmd *) I596_NULL) && (ptr != lp->cmd_tail))
lp870drivers/net/apricot.cif ((lp->cmd_head != (struct i596_cmd *) I596_NULL) && (dev->start)) ack_cmd |= CUC_START;
lp871drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
lp892drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp895drivers/net/apricot.cprintk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command);
lp898drivers/net/apricot.clp->scb.command = ack_cmd;
lp915drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp923drivers/net/apricot.cdev->name, lp->scb.status);
lp925drivers/net/apricot.clp->scb.command = CUC_ABORT|RX_ABORT;
lp928drivers/net/apricot.ci596_cleanup_cmd(lp);
lp930drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp934drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp948drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp950drivers/net/apricot.creturn &lp->stats;
lp959drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp988drivers/net/apricot.cif (lp->set_conf.next != (struct i596_cmd * ) I596_NULL) 
lp994drivers/net/apricot.clp->i596_config[8] &= ~0x01;
lp997drivers/net/apricot.clp->i596_config[8] |= 0x01;
lp999drivers/net/apricot.ci596_add_cmd(dev, &lp->set_conf);
lp350drivers/net/arcnet.c#define ADEV lp->adev
lp353drivers/net/arcnet.c#define EDEV lp->edev
lp355drivers/net/arcnet.c#define EDEV lp->adev
lp359drivers/net/arcnet.c#define SDEV lp->sdev
lp361drivers/net/arcnet.c#define SDEV lp->adev
lp384drivers/net/arcnet.c#define SETMASK outb(lp->intmask,INTMASK);
lp1104drivers/net/arcnet.cstruct arcnet_local *lp;
lp1148drivers/net/arcnet.clp=(struct arcnet_local *)(dev->priv);
lp1166drivers/net/arcnet.clp->sequence=1;
lp1167drivers/net/arcnet.clp->recbuf=0;
lp1175drivers/net/arcnet.clp->stationid = first_mirror[1];
lp1176drivers/net/arcnet.cif (lp->stationid==0)
lp1179drivers/net/arcnet.celse if (lp->stationid==255)
lp1182drivers/net/arcnet.cdev->dev_addr[0]=lp->stationid;
lp1186drivers/net/arcnet.clp->stationid,
lp1203drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp1205drivers/net/arcnet.cint delayval,recbuf=lp->recbuf;
lp1209drivers/net/arcnet.clp->intmask=0;
lp1234drivers/net/arcnet.crecbuf=lp->recbuf=0;
lp1235drivers/net/arcnet.clp->txbuf=2;
lp1250drivers/net/arcnet.clp->intmask|=NORXflag;
lp1252drivers/net/arcnet.clp->intmask|=RECONflag;
lp1309drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1336drivers/net/arcnet.clp->intx=0;
lp1337drivers/net/arcnet.clp->in_txhandler=0;
lp1340drivers/net/arcnet.clp->adev=dev;
lp1345drivers/net/arcnet.clp->edev=(struct device *)kmalloc(sizeof(struct device),GFP_KERNEL);
lp1346drivers/net/arcnet.cif (lp->edev == NULL)
lp1348drivers/net/arcnet.cmemcpy(lp->edev,dev,sizeof(struct device));
lp1349drivers/net/arcnet.clp->edev->name=(char *)kmalloc(10,GFP_KERNEL);
lp1350drivers/net/arcnet.cif (lp->edev->name == NULL) {
lp1351drivers/net/arcnet.ckfree(lp->edev);
lp1352drivers/net/arcnet.clp->edev = NULL;
lp1355drivers/net/arcnet.csprintf(lp->edev->name,"%se",dev->name);
lp1356drivers/net/arcnet.clp->edev->init=arcnetE_init;
lp1357drivers/net/arcnet.cregister_netdev(lp->edev);
lp1364drivers/net/arcnet.clp->sdev=(struct device *)kmalloc(sizeof(struct device),GFP_KERNEL);
lp1365drivers/net/arcnet.cmemcpy(lp->sdev,dev,sizeof(struct device));
lp1366drivers/net/arcnet.clp->sdev->name=(char *)kmalloc(10,GFP_KERNEL);
lp1367drivers/net/arcnet.csprintf(lp->sdev->name,"%ss",dev->name);
lp1368drivers/net/arcnet.clp->sdev->init=arcnetS_init;
lp1369drivers/net/arcnet.cregister_netdev(lp->sdev);
lp1400drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1409drivers/net/arcnet.clp->intmask=0;
lp1419drivers/net/arcnet.clp->adev=NULL;
lp1423drivers/net/arcnet.clp->edev->priv=NULL;
lp1424drivers/net/arcnet.cdev_close(lp->edev);
lp1425drivers/net/arcnet.cunregister_netdev(lp->edev);
lp1426drivers/net/arcnet.ckfree(lp->edev->name);
lp1427drivers/net/arcnet.ckfree(lp->edev);
lp1428drivers/net/arcnet.clp->edev=NULL;
lp1433drivers/net/arcnet.clp->sdev->priv=NULL;
lp1434drivers/net/arcnet.cdev_close(lp->sdev);
lp1435drivers/net/arcnet.cunregister_netdev(lp->sdev);
lp1436drivers/net/arcnet.ckfree(lp->sdev->name);
lp1437drivers/net/arcnet.ckfree(lp->sdev);
lp1438drivers/net/arcnet.clp->sdev=NULL;
lp1460drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1464drivers/net/arcnet.cinb(STATUS),lp->intx);
lp1466drivers/net/arcnet.cif (lp->in_txhandler)
lp1469drivers/net/arcnet.clp->stats.tx_dropped++;
lp1473drivers/net/arcnet.cif (lp->intx>1)
lp1476drivers/net/arcnet.clp->stats.tx_dropped++;
lp1491drivers/net/arcnet.cstatus,tickssofar,lp->outgoing.skb,
lp1492drivers/net/arcnet.clp->outgoing.numsegs,
lp1493drivers/net/arcnet.clp->outgoing.segnum);
lp1497drivers/net/arcnet.clp->intmask &= ~TXFREEflag;
lp1503drivers/net/arcnet.cstatus,tickssofar,lp->intmask,lp->lasttrans_dest);
lp1504drivers/net/arcnet.clp->stats.tx_errors++;
lp1509drivers/net/arcnet.cstatus,tickssofar,lp->intmask,lp->lasttrans_dest);
lp1510drivers/net/arcnet.clp->stats.tx_errors++;
lp1511drivers/net/arcnet.clp->stats.tx_aborted_errors++;
lp1516drivers/net/arcnet.cif (lp->outgoing.skb)
lp1518drivers/net/arcnet.cdev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
lp1519drivers/net/arcnet.clp->stats.tx_dropped++;
lp1521drivers/net/arcnet.clp->outgoing.skb=NULL;
lp1524drivers/net/arcnet.clp->txready=0;
lp1525drivers/net/arcnet.clp->sending=0;
lp1535drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp1536drivers/net/arcnet.clp->stats.tx_errors++;
lp1541drivers/net/arcnet.cif (lp->txready)  /* transmit already in progress! */
lp1545drivers/net/arcnet.clp->intmask &= ~TXFREEflag;
lp1549drivers/net/arcnet.clp->stats.tx_errors++;
lp1550drivers/net/arcnet.clp->stats.tx_fifo_errors++;
lp1551drivers/net/arcnet.clp->txready=0;  /* we definitely need this line! */
lp1561drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp1562drivers/net/arcnet.clp->stats.tx_errors++;
lp1563drivers/net/arcnet.clp->stats.tx_fifo_errors++;
lp1576drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1578drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1580drivers/net/arcnet.clp->intx++;
lp1585drivers/net/arcnet.clp->intx--;
lp1597drivers/net/arcnet.cout->hdr->sequence=(lp->sequence++);
lp1643drivers/net/arcnet.cif (!lp->txready)
lp1670drivers/net/arcnet.clp->intx--;
lp1673drivers/net/arcnet.clp->intmask |= TXFREEflag;
lp1686drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1688drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1691drivers/net/arcnet.cinb(STATUS),lp->intx,lp->in_txhandler,lp->intmask);
lp1693drivers/net/arcnet.cif (lp->txready)
lp1734drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1737drivers/net/arcnet.c(union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
lp1744drivers/net/arcnet.clp->txbuf=lp->txbuf^1;  /* XOR with 1 to alternate between 2 and 3 */
lp1754drivers/net/arcnet.cmemset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
lp1823drivers/net/arcnet.clp->lastload_dest=daddr;
lp1824drivers/net/arcnet.clp->txready=lp->txbuf;  /* packet is ready for sending */
lp1840drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp1844drivers/net/arcnet.cinb(STATUS),lp->intmask,lp->txready,lp->sending);
lp1846drivers/net/arcnet.cif (lp->sending || !lp->txready)
lp1848drivers/net/arcnet.cif (enable_irq && lp->sending)
lp1850drivers/net/arcnet.clp->intmask |= TXFREEflag;
lp1857drivers/net/arcnet.coutb(TXcmd|(lp->txready<<3),COMMAND);
lp1859drivers/net/arcnet.clp->stats.tx_packets++;
lp1860drivers/net/arcnet.clp->txready=0;
lp1861drivers/net/arcnet.clp->sending++;
lp1863drivers/net/arcnet.clp->lasttrans_dest=lp->lastload_dest;
lp1864drivers/net/arcnet.clp->lastload_dest=0;
lp1866drivers/net/arcnet.clp->intmask |= TXFREEflag;
lp1923drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp1936drivers/net/arcnet.cinb(STATUS),lp->intmask);
lp1959drivers/net/arcnet.cif (status & lp->intmask & NORXflag)
lp1961drivers/net/arcnet.cint recbuf=lp->recbuf=!lp->recbuf;
lp1976drivers/net/arcnet.cif (status & lp->intmask & TXFREEflag)
lp1978drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1979drivers/net/arcnet.cint was_sending=lp->sending;
lp1981drivers/net/arcnet.clp->intmask &= ~TXFREEflag;
lp1983drivers/net/arcnet.clp->in_txhandler++;
lp1984drivers/net/arcnet.cif (was_sending) lp->sending--;
lp1991drivers/net/arcnet.cif (lp->lasttrans_dest != 0)
lp1994drivers/net/arcnet.cstatus,lp->lasttrans_dest);
lp1995drivers/net/arcnet.clp->stats.tx_errors++;
lp1996drivers/net/arcnet.clp->stats.tx_carrier_errors++;
lp2002drivers/net/arcnet.clp->lasttrans_dest);
lp2010drivers/net/arcnet.cif (lp->intx)
lp2013drivers/net/arcnet.cinb(STATUS),lp->intx);
lp2014drivers/net/arcnet.clp->in_txhandler--;
lp2018drivers/net/arcnet.cif (!lp->outgoing.skb)
lp2023drivers/net/arcnet.cif (!lp->txready && IF_TBUSY)
lp2028drivers/net/arcnet.clp->in_txhandler--;
lp2051drivers/net/arcnet.cif (!lp->txready && IF_TBUSY)
lp2059drivers/net/arcnet.clp->in_txhandler--;
lp2061drivers/net/arcnet.celse if (lp->txready && !lp->sending && !lp->intx)
lp2070drivers/net/arcnet.cif (status & (lp->intmask) & RECONflag)
lp2073drivers/net/arcnet.clp->stats.tx_carrier_errors++;
lp2082drivers/net/arcnet.cif (!lp->first_recon || !lp->last_recon || 
lp2083drivers/net/arcnet.cjiffies-lp->last_recon > HZ*10)
lp2085drivers/net/arcnet.cif (lp->network_down)
lp2087drivers/net/arcnet.clp->first_recon=lp->last_recon=jiffies;
lp2088drivers/net/arcnet.clp->num_recons=lp->network_down=0;
lp2094drivers/net/arcnet.clp->last_recon=jiffies;
lp2095drivers/net/arcnet.clp->num_recons++;
lp2098drivers/net/arcnet.clp->num_recons,
lp2099drivers/net/arcnet.c(lp->last_recon-lp->first_recon)/HZ,
lp2100drivers/net/arcnet.clp->network_down);
lp2109drivers/net/arcnet.cif (!lp->network_down
lp2110drivers/net/arcnet.c&& (lp->last_recon-lp->first_recon)<=HZ*60
lp2111drivers/net/arcnet.c&& lp->num_recons >= RECON_THRESHOLD)
lp2113drivers/net/arcnet.clp->network_down=1;
lp2116drivers/net/arcnet.celse if (!lp->network_down
lp2117drivers/net/arcnet.c&& lp->last_recon-lp->first_recon > HZ*60)
lp2122drivers/net/arcnet.clp->first_recon=lp->last_recon;
lp2123drivers/net/arcnet.clp->num_recons=1;
lp2129drivers/net/arcnet.celse if (lp->network_down && jiffies-lp->last_recon > HZ*10)
lp2131drivers/net/arcnet.cif (lp->network_down)
lp2133drivers/net/arcnet.clp->first_recon=lp->last_recon=0;
lp2134drivers/net/arcnet.clp->num_recons=lp->network_down=0;
lp2166drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2174drivers/net/arcnet.clp->stats.rx_packets++;
lp2184drivers/net/arcnet.clp->stats.rx_errors++;
lp2214drivers/net/arcnet.carcnetA_rx(lp->adev,arcsoft,length,saddr,daddr);
lp2218drivers/net/arcnet.carcnetE_rx(lp->edev,arcsoft,length,saddr,daddr);
lp2224drivers/net/arcnet.carcnetS_rx(lp->sdev,arcsoft,length,saddr,daddr);
lp2231drivers/net/arcnet.clp->stats.rx_errors++;
lp2232drivers/net/arcnet.clp->stats.rx_crc_errors++;
lp2259drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2284drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp2295drivers/net/arcnet.clp->stats.rx_errors++;
lp2296drivers/net/arcnet.clp->stats.rx_missed_errors++;
lp2305drivers/net/arcnet.clp->stats.rx_dropped++;
lp2338drivers/net/arcnet.clp->stats.rx_crc_errors++;
lp2351drivers/net/arcnet.clp->stats.rx_errors++;
lp2352drivers/net/arcnet.clp->stats.rx_crc_errors++;
lp2381drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp2393drivers/net/arcnet.clp->stats.rx_errors++;
lp2394drivers/net/arcnet.clp->stats.rx_missed_errors++;
lp2407drivers/net/arcnet.clp->stats.rx_errors++;
lp2408drivers/net/arcnet.clp->stats.rx_missed_errors++;
lp2420drivers/net/arcnet.clp->stats.rx_errors++;
lp2421drivers/net/arcnet.clp->stats.rx_length_errors++;
lp2430drivers/net/arcnet.clp->stats.rx_dropped++;
lp2460drivers/net/arcnet.clp->stats.rx_errors++;
lp2461drivers/net/arcnet.clp->stats.rx_missed_errors++;
lp2473drivers/net/arcnet.clp->stats.rx_errors++;
lp2474drivers/net/arcnet.clp->stats.rx_frame_errors++;
lp2484drivers/net/arcnet.clp->stats.rx_errors++;
lp2485drivers/net/arcnet.clp->stats.rx_missed_errors++;
lp2544drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2546drivers/net/arcnet.creturn &lp->stats;
lp2560drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp2581drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp2611drivers/net/arcnet.clp->stats.tx_errors++;
lp2612drivers/net/arcnet.clp->stats.tx_aborted_errors++;
lp2654drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp2665drivers/net/arcnet.clp->stats.tx_errors++;
lp2666drivers/net/arcnet.clp->stats.tx_aborted_errors++;
lp2695drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *) (dev->priv);
lp2724drivers/net/arcnet.clp->stats.rx_errors++;
lp2725drivers/net/arcnet.clp->stats.rx_crc_errors++;
lp2744drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2748drivers/net/arcnet.cdev->dev_addr[5]=lp->stationid;
lp2765drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2768drivers/net/arcnet.c(union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
lp2772drivers/net/arcnet.clp->intx++;
lp2777drivers/net/arcnet.clp->intx--;
lp2790drivers/net/arcnet.clp->intx--;
lp2796drivers/net/arcnet.clp->txbuf=lp->txbuf^1; /* XOR with 1 to alternate btw 2 & 3 */
lp2801drivers/net/arcnet.cmemset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
lp2844drivers/net/arcnet.clp->lastload_dest=daddr;
lp2845drivers/net/arcnet.clp->txready=lp->txbuf;  /* packet is ready for sending */
lp2857drivers/net/arcnet.clp->intx--;
lp2860drivers/net/arcnet.clp->intmask |= TXFREEflag;
lp2873drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2882drivers/net/arcnet.clp->stats.rx_dropped++;
lp2911drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2916drivers/net/arcnet.cdev->dev_addr[0]=lp->stationid;
lp2936drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2940drivers/net/arcnet.clp->intx++;
lp2945drivers/net/arcnet.clp->intx--;
lp2980drivers/net/arcnet.clp->stats.tx_dropped++;
lp2986drivers/net/arcnet.clp->intx--;
lp2989drivers/net/arcnet.clp->intmask |= TXFREEflag;
lp3002drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp3019drivers/net/arcnet.clp->stats.rx_dropped++;
lp3054drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp3070drivers/net/arcnet.clp->stats.tx_errors++;
lp3071drivers/net/arcnet.clp->stats.tx_aborted_errors++;
lp3109drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp3119drivers/net/arcnet.clp->stats.tx_errors++;
lp3120drivers/net/arcnet.clp->stats.tx_aborted_errors++;
lp3144drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *) (dev->priv);
lp3169drivers/net/arcnet.clp->stats.rx_errors++;
lp3170drivers/net/arcnet.clp->stats.rx_crc_errors++;
lp321drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp346drivers/net/at1700.clp->tx_started = 0;
lp347drivers/net/at1700.clp->tx_queue = 0;
lp348drivers/net/at1700.clp->tx_queue_len = 0;
lp366drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp382drivers/net/at1700.clp->stats.tx_errors++;
lp390drivers/net/at1700.clp->tx_started = 0;
lp391drivers/net/at1700.clp->tx_queue = 0;
lp392drivers/net/at1700.clp->tx_queue_len = 0;
lp417drivers/net/at1700.clp->tx_queue++;
lp418drivers/net/at1700.clp->tx_queue_len += length + 2;
lp420drivers/net/at1700.cif (lp->tx_started == 0) {
lp422drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp423drivers/net/at1700.clp->tx_queue = 0;
lp424drivers/net/at1700.clp->tx_queue_len = 0;
lp426drivers/net/at1700.clp->tx_started = 1;
lp428drivers/net/at1700.c} else if (lp->tx_queue_len < 4096 - 1502)
lp446drivers/net/at1700.cstruct net_local *lp;
lp456drivers/net/at1700.clp = (struct net_local *)dev->priv;
lp468drivers/net/at1700.clp->stats.tx_packets++;
lp469drivers/net/at1700.cif (lp->tx_queue) {
lp470drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp471drivers/net/at1700.clp->tx_queue = 0;
lp472drivers/net/at1700.clp->tx_queue_len = 0;
lp477drivers/net/at1700.clp->tx_started = 0;
lp494drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp513drivers/net/at1700.clp->stats.rx_errors++;
lp514drivers/net/at1700.cif (status & 0x08) lp->stats.rx_length_errors++;
lp515drivers/net/at1700.cif (status & 0x04) lp->stats.rx_frame_errors++;
lp516drivers/net/at1700.cif (status & 0x02) lp->stats.rx_crc_errors++;
lp517drivers/net/at1700.cif (status & 0x01) lp->stats.rx_over_errors++;
lp528drivers/net/at1700.clp->stats.rx_errors++;
lp538drivers/net/at1700.clp->stats.rx_dropped++;
lp547drivers/net/at1700.clp->stats.rx_packets++;
lp598drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp604drivers/net/at1700.creturn &lp->stats;
lp236drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp237drivers/net/atp.clp->addr_mode = CMR2h_Normal;
lp344drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp353drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp370drivers/net/atp.clp->tx_unit_busy = 0;
lp371drivers/net/atp.clp->pac_cnt_in_tx_buf = 0;
lp372drivers/net/atp.clp->saved_tx_size = 0;
lp418drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp430drivers/net/atp.clp->stats.tx_errors++;
lp464drivers/net/atp.clp->pac_cnt_in_tx_buf++;
lp465drivers/net/atp.cif (lp->tx_unit_busy == 0) {
lp467drivers/net/atp.clp->saved_tx_size = 0;         /* Redundant */
lp468drivers/net/atp.clp->re_tx = 0;
lp469drivers/net/atp.clp->tx_unit_busy = 1;
lp471drivers/net/atp.clp->saved_tx_size = length;
lp490drivers/net/atp.cstruct net_local *lp;
lp501drivers/net/atp.clp = (struct net_local *)dev->priv;
lp524drivers/net/atp.clp->stats.rx_over_errors++;
lp530drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp544drivers/net/atp.clp->stats.collisions++;
lp545drivers/net/atp.cif (++lp->re_tx > 15) {
lp546drivers/net/atp.clp->stats.tx_aborted_errors++;
lp555drivers/net/atp.clp->stats.tx_packets++;
lp556drivers/net/atp.clp->pac_cnt_in_tx_buf--;
lp557drivers/net/atp.cif ( lp->saved_tx_size) {
lp558drivers/net/atp.ctrigger_send(ioaddr, lp->saved_tx_size);
lp559drivers/net/atp.clp->saved_tx_size = 0;
lp560drivers/net/atp.clp->re_tx = 0;
lp562drivers/net/atp.clp->tx_unit_busy = 0;
lp574drivers/net/atp.clp->stats.rx_missed_errors++;
lp624drivers/net/atp.cstruct net_local *lp = (struct net_local *)atp_timed_dev->priv;
lp627drivers/net/atp.clp->stats.tx_errors++;
lp629drivers/net/atp.clp->stats.tx_dropped++;
lp631drivers/net/atp.clp->stats.collisions++;
lp633drivers/net/atp.clp->stats.rx_errors++;
lp648drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp663drivers/net/atp.clp->stats.rx_errors++;
lp678drivers/net/atp.clp->stats.rx_dropped++;
lp696drivers/net/atp.clp->stats.rx_packets++;
lp727drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp734drivers/net/atp.clp->addr_mode = CMR2h_OFF;
lp753drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp754drivers/net/atp.creturn &lp->stats;
lp763drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp776drivers/net/atp.clp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
lp777drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp354drivers/net/de4x5.cimr |= lp->irq_en;\
lp360drivers/net/de4x5.cimr &= ~lp->irq_en;\
lp365drivers/net/de4x5.cimr |= lp->irq_mask;\
lp371drivers/net/de4x5.cimr &= ~lp->irq_mask;\
lp524drivers/net/de4x5.c#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
lp525drivers/net/de4x5.clp->tx_old+lp->txRingSize-lp->tx_new-1:\
lp526drivers/net/de4x5.clp->tx_old               -lp->tx_new-1)
lp580drivers/net/de4x5.cstatic int     PCI_signature(char *name, struct bus_type *lp);
lp582drivers/net/de4x5.cstatic int     de4x5_bad_srom(struct bus_type *lp);
lp680drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp682drivers/net/de4x5.cint i, media = *((char *)&(lp->srom) + *((char *)&(lp->srom) + 19) * 3);
lp686drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp700drivers/net/de4x5.cif (lp->bus == PCI) {
lp701drivers/net/de4x5.cPCI_signature(name, lp);
lp711drivers/net/de4x5.cif (lp->bus == EISA) {
lp716drivers/net/de4x5.ciobase, lp->bus_num, lp->device);
lp726drivers/net/de4x5.ctmpbus = lp->bus;
lp727drivers/net/de4x5.ctmpchs = lp->chipset;
lp733drivers/net/de4x5.cstruct de4x5_private *lp;
lp750drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp752drivers/net/de4x5.clp->bus = tmpbus;
lp753drivers/net/de4x5.clp->chipset = tmpchs;
lp754drivers/net/de4x5.clp->cache.priv = tmp;
lp772drivers/net/de4x5.clp->autosense = AUTO;
lp774drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp775drivers/net/de4x5.cif ((lp->chipset == DC21040) && (de4x5_autosense & TP_NW)) {
lp778drivers/net/de4x5.cif ((lp->chipset == DC21041) && (de4x5_autosense & BNC_AUI)) {
lp781drivers/net/de4x5.clp->autosense = de4x5_autosense & 0x001f;
lp783drivers/net/de4x5.clp->autosense = de4x5_autosense & 0x00c0;
lp787drivers/net/de4x5.csprintf(lp->adapter_name,"%s (%s)", name, dev->name);
lp794drivers/net/de4x5.clp->cache.buf = tmp;
lp797drivers/net/de4x5.clp->rx_ring[i].status = 0;
lp798drivers/net/de4x5.clp->rx_ring[i].des1 = RX_BUFF_SZ;
lp799drivers/net/de4x5.clp->rx_ring[i].buf = virt_to_bus(tmp + i * RX_BUFF_SZ);
lp800drivers/net/de4x5.clp->rx_ring[i].next = (u32)NULL;
lp804drivers/net/de4x5.crequest_region(iobase, (lp->bus == PCI ? DE4X5_PCI_TOTAL_SIZE :
lp806drivers/net/de4x5.clp->adapter_name);
lp808drivers/net/de4x5.clp->rxRingSize = NUM_RX_DESC;
lp809drivers/net/de4x5.clp->txRingSize = NUM_TX_DESC;
lp812drivers/net/de4x5.clp->rx_ring[lp->rxRingSize - 1].des1 |= RD_RER;
lp813drivers/net/de4x5.clp->tx_ring[lp->txRingSize - 1].des1 |= TD_TER;
lp816drivers/net/de4x5.coutl(virt_to_bus(lp->rx_ring), DE4X5_RRBA);
lp817drivers/net/de4x5.coutl(virt_to_bus(lp->tx_ring), DE4X5_TRBA);
lp820drivers/net/de4x5.clp->irq_mask = IMR_RIM | IMR_TIM | IMR_TUM ;
lp821drivers/net/de4x5.clp->irq_en   = IMR_NIM | IMR_AIM;
lp824drivers/net/de4x5.ccreate_packet(dev, lp->frame, sizeof(lp->frame));
lp827drivers/net/de4x5.clp->state = CLOSED;
lp830drivers/net/de4x5.c((lp->bus == PCI) ? "PCI BIOS" : "EISA CNFG"));
lp835drivers/net/de4x5.crelease_region(iobase, (lp->bus == PCI ? 
lp838drivers/net/de4x5.cif (lp->rx_ring[0].buf) {
lp839drivers/net/de4x5.ckfree(bus_to_virt(lp->rx_ring[0].buf));
lp866drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp878drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp886drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp891drivers/net/de4x5.clp->state = OPEN;
lp900drivers/net/de4x5.cif (request_irq(dev->irq, (void *)de4x5_interrupt, 0, lp->adapter_name, dev)) {
lp954drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp960drivers/net/de4x5.cif (lp->phy[lp->active].id == 0) {
lp971drivers/net/de4x5.cbmr = (lp->chipset==DC21140 ? PBL_8 : PBL_4) | DESC_SKIP_LEN | CACHE_ALIGN;
lp975drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp977drivers/net/de4x5.clp->setup_f = HASH_PERF;
lp979drivers/net/de4x5.comr |= OMR_SDP | OMR_SB | (!lp->phy[lp->active].id ? OMR_SF : 0);
lp980drivers/net/de4x5.clp->setup_f = PERFECT;
lp982drivers/net/de4x5.coutl(virt_to_bus(lp->rx_ring), DE4X5_RRBA);
lp983drivers/net/de4x5.coutl(virt_to_bus(lp->tx_ring), DE4X5_TRBA);
lp985drivers/net/de4x5.clp->rx_new = lp->rx_old = 0;
lp986drivers/net/de4x5.clp->tx_new = lp->tx_old = 0;
lp988drivers/net/de4x5.cfor (i = 0; i < lp->rxRingSize; i++) {
lp989drivers/net/de4x5.clp->rx_ring[i].status = R_OWN;
lp992drivers/net/de4x5.cfor (i = 0; i < lp->txRingSize; i++) {
lp993drivers/net/de4x5.clp->tx_ring[i].status = 0;
lp1001drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp1002drivers/net/de4x5.cload_packet(dev, lp->setup_frame, HASH_F|TD_SET|SETUP_FRAME_LEN, NULL);
lp1004drivers/net/de4x5.cload_packet(dev, lp->setup_frame, PERFECT_F|TD_SET|SETUP_FRAME_LEN, NULL);
lp1012drivers/net/de4x5.cif (lp->tx_ring[lp->tx_new].status >= 0) j=1;
lp1022drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1023drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp1034drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1043drivers/net/de4x5.cif (lp->tx_enable == NO) {                   /* Cannot send for now */
lp1059drivers/net/de4x5.cif (dev->tbusy || lp->skb[lp->tx_new]) {
lp1066drivers/net/de4x5.cprintk("%s: transmit busy, lost media or stale skb found:\n  STS:%08x\n  tbusy:%ld\n  lostMedia:%d\n  IMR:%08x\n  OMR:%08x\n Stale skb: %s\n",dev->name, inl(DE4X5_STS), dev->tbusy, lp->lostMedia, inl(DE4X5_IMR), inl(DE4X5_OMR), (lp->skb[lp->tx_new] ? "YES" : "NO"));
lp1070drivers/net/de4x5.cif (lp->cache.skb && !dev->interrupt) {
lp1075drivers/net/de4x5.cwhile (skb && !dev->tbusy && !lp->skb[lp->tx_new]) {
lp1083drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1093drivers/net/de4x5.cif (skb && (dev->tbusy || lp->skb[lp->tx_new])) {
lp1116drivers/net/de4x5.cstruct de4x5_private *lp;
lp1124drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp1137drivers/net/de4x5.cif (!(sts & lp->irq_mask)) break;/* All done */
lp1146drivers/net/de4x5.clp->lostMedia = LOST_MEDIA_THRESHOLD + 1;
lp1147drivers/net/de4x5.clp->irq_mask &= ~IMR_LFM;
lp1159drivers/net/de4x5.cwhile (lp->cache.skb && !dev->tbusy && lp->tx_enable) {
lp1172drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1177drivers/net/de4x5.cfor (entry=lp->rx_new; lp->rx_ring[entry].status>=0;entry=lp->rx_new) {
lp1178drivers/net/de4x5.cstatus = lp->rx_ring[entry].status;
lp1181drivers/net/de4x5.clp->rx_old = entry;
lp1185drivers/net/de4x5.clp->linkOK++;
lp1187drivers/net/de4x5.clp->stats.rx_errors++;        /* Update the error stats. */
lp1188drivers/net/de4x5.cif (status & (RD_RF | RD_TL)) lp->stats.rx_frame_errors++;
lp1189drivers/net/de4x5.cif (status & RD_CE)           lp->stats.rx_crc_errors++;
lp1190drivers/net/de4x5.cif (status & RD_OF)           lp->stats.rx_fifo_errors++;
lp1191drivers/net/de4x5.cif (status & RD_TL)           lp->stats.rx_length_errors++;
lp1192drivers/net/de4x5.cif (status & RD_RF)           lp->pktStats.rx_runt_frames++;
lp1193drivers/net/de4x5.cif (status & RD_CS)           lp->pktStats.rx_collision++;
lp1194drivers/net/de4x5.cif (status & RD_DB)           lp->pktStats.rx_dribble++;
lp1195drivers/net/de4x5.cif (status & RD_OF)           lp->pktStats.rx_overflow++;
lp1198drivers/net/de4x5.cshort pkt_len = (short)(lp->rx_ring[entry].status >> 16) - 4;
lp1203drivers/net/de4x5.clp->stats.rx_dropped++;   /* Really, deferred. */
lp1209drivers/net/de4x5.cif (entry < lp->rx_old) {     /* Wrapped buffer */
lp1210drivers/net/de4x5.cshort len = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
lp1211drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
lp1212drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
lp1214drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), pkt_len);
lp1222drivers/net/de4x5.clp->stats.rx_packets++;
lp1225drivers/net/de4x5.clp->pktStats.bins[i]++;
lp1232drivers/net/de4x5.clp->pktStats.broadcast++;
lp1234drivers/net/de4x5.clp->pktStats.multicast++;
lp1238drivers/net/de4x5.clp->pktStats.unicast++;
lp1241drivers/net/de4x5.clp->pktStats.bins[0]++;       /* Duplicates stats.rx_packets */
lp1242drivers/net/de4x5.cif (lp->pktStats.bins[0] == 0) { /* Reset counters */
lp1243drivers/net/de4x5.cmemset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
lp1248drivers/net/de4x5.cfor (;lp->rx_old!=entry;lp->rx_old=(++lp->rx_old)%lp->rxRingSize) {
lp1249drivers/net/de4x5.clp->rx_ring[lp->rx_old].status = R_OWN;
lp1252drivers/net/de4x5.clp->rx_ring[entry].status = R_OWN;
lp1259drivers/net/de4x5.clp->rx_new = (++lp->rx_new) % lp->rxRingSize;
lp1271drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1276drivers/net/de4x5.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
lp1277drivers/net/de4x5.cstatus = lp->tx_ring[entry].status;
lp1281drivers/net/de4x5.clp->stats.tx_errors++; 
lp1282drivers/net/de4x5.cif (status & TD_NC)  lp->stats.tx_carrier_errors++;
lp1283drivers/net/de4x5.cif (status & TD_LC)  lp->stats.tx_window_errors++;
lp1284drivers/net/de4x5.cif (status & TD_UF)  lp->stats.tx_fifo_errors++;
lp1285drivers/net/de4x5.cif (status & TD_LC)  lp->stats.collisions++;
lp1286drivers/net/de4x5.cif (status & TD_EC)  lp->pktStats.excessive_collisions++;
lp1287drivers/net/de4x5.cif (status & TD_DE)  lp->stats.tx_aborted_errors++;
lp1291drivers/net/de4x5.clp->lostMedia++;
lp1296drivers/net/de4x5.clp->stats.tx_packets++;
lp1297drivers/net/de4x5.clp->lostMedia = 0;                /* Remove transient problem */
lp1300drivers/net/de4x5.cif (lp->skb[entry] != NULL) {
lp1301drivers/net/de4x5.cdev_kfree_skb(lp->skb[entry], FREE_WRITE);
lp1302drivers/net/de4x5.clp->skb[entry] = NULL;
lp1306drivers/net/de4x5.clp->tx_old = (++lp->tx_old) % lp->txRingSize;
lp1320drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1325drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp1327drivers/net/de4x5.c} else if (lp->chipset == DC21041) {
lp1329drivers/net/de4x5.c} else if (lp->chipset == DC21040) {
lp1332drivers/net/de4x5.clp->linkOK = 0;
lp1341drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1365drivers/net/de4x5.clp->state = CLOSED;
lp1370drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp1381drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1384drivers/net/de4x5.clp->stats.rx_missed_errors = (int)(inl(DE4X5_MFC) & (MFC_OVFL | MFC_CNTR));
lp1386drivers/net/de4x5.creturn &lp->stats;
lp1391drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1393drivers/net/de4x5.clp->tx_ring[lp->tx_new].buf = virt_to_bus(buf);
lp1394drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 &= TD_TER;
lp1395drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 |= flags;
lp1396drivers/net/de4x5.clp->skb[lp->tx_new] = skb;
lp1398drivers/net/de4x5.clp->tx_ring[lp->tx_new].status = T_OWN;
lp1410drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1414drivers/net/de4x5.cif (lp->state == OPEN) {
lp1422drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp1423drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp1426drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET | 
lp1430drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1446drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1461drivers/net/de4x5.c} else if (lp->setup_f == HASH_PERF) {   /* Hash Filtering */
lp1482drivers/net/de4x5.clp->setup_frame[byte] |= bit;
lp1510drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1515drivers/net/de4x5.clp->bus = EISA;
lp1533drivers/net/de4x5.clp->chipset = device;
lp1578drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1584drivers/net/de4x5.clp->bus = PCI;
lp1605drivers/net/de4x5.clp->device = dev_num;
lp1606drivers/net/de4x5.clp->bus_num = pb;
lp1609drivers/net/de4x5.clp->chipset = device;
lp1763drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1767drivers/net/de4x5.clp->linkOK = 0;
lp1768drivers/net/de4x5.clp->c_media = AUTO;                     /* Bogus last media */
lp1771drivers/net/de4x5.clp->media = INIT;
lp1772drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp1774drivers/net/de4x5.c} else if (lp->chipset == DC21041) {
lp1776drivers/net/de4x5.c} else if (lp->chipset == DC21140) {
lp1779drivers/net/de4x5.cif (lp->autosense == AUTO) enable_ast(dev, next_tick);
lp1781drivers/net/de4x5.creturn (lp->media);
lp1798drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1803drivers/net/de4x5.cswitch (lp->media) {
lp1806drivers/net/de4x5.clp->tx_enable = NO;
lp1807drivers/net/de4x5.clp->timeout = -1;
lp1809drivers/net/de4x5.cif ((lp->autosense == AUTO) || (lp->autosense == TP)) {
lp1810drivers/net/de4x5.clp->media = TP;
lp1811drivers/net/de4x5.c} else if ((lp->autosense == BNC) || (lp->autosense == AUI) || (lp->autosense == BNC_AUI)) {
lp1812drivers/net/de4x5.clp->media = BNC_AUI;
lp1813drivers/net/de4x5.c} else if (lp->autosense == EXT_SIA) {
lp1814drivers/net/de4x5.clp->media = EXT_SIA;
lp1816drivers/net/de4x5.clp->media = NC;
lp1818drivers/net/de4x5.clp->local_state = 0;
lp1859drivers/net/de4x5.clp->media = INIT;
lp1860drivers/net/de4x5.clp->tx_enable = NO;
lp1872drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1876drivers/net/de4x5.cswitch (lp->local_state) {
lp1879drivers/net/de4x5.clp->local_state++;
lp1884drivers/net/de4x5.cif (!lp->tx_enable) {
lp1889drivers/net/de4x5.cif (linkBad && (lp->autosense == AUTO)) {
lp1890drivers/net/de4x5.clp->local_state = 0;
lp1891drivers/net/de4x5.clp->media = next_state;
lp1896drivers/net/de4x5.c} else if (!lp->linkOK && (lp->autosense == AUTO)) {
lp1897drivers/net/de4x5.clp->media = suspect_state;
lp1911drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1915drivers/net/de4x5.cswitch (lp->local_state) {
lp1917drivers/net/de4x5.cif (lp->linkOK && !LOST_MEDIA) {
lp1918drivers/net/de4x5.clp->media = prev_state;
lp1920drivers/net/de4x5.clp->local_state++;
lp1930drivers/net/de4x5.clp->local_state--;
lp1931drivers/net/de4x5.clp->media = prev_state;
lp1933drivers/net/de4x5.clp->media = INIT;
lp1951drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1956drivers/net/de4x5.cswitch (lp->media) {
lp1959drivers/net/de4x5.clp->tx_enable = NO;
lp1960drivers/net/de4x5.clp->timeout = -1;
lp1962drivers/net/de4x5.cif ((lp->autosense == AUTO) || (lp->autosense == TP_NW)) {
lp1963drivers/net/de4x5.clp->media = TP;            /* On chip auto negotiation is broken */
lp1964drivers/net/de4x5.c} else if (lp->autosense == TP) {
lp1965drivers/net/de4x5.clp->media = TP;
lp1966drivers/net/de4x5.c} else if (lp->autosense == BNC) {
lp1967drivers/net/de4x5.clp->media = BNC;
lp1968drivers/net/de4x5.c} else if (lp->autosense == AUI) {
lp1969drivers/net/de4x5.clp->media = AUI;
lp1971drivers/net/de4x5.clp->media = NC;
lp1973drivers/net/de4x5.clp->local_state = 0;
lp1978drivers/net/de4x5.cif (lp->timeout < 0) {
lp1989drivers/net/de4x5.clp->media = ANS;
lp1991drivers/net/de4x5.clp->media = AUI;
lp1998drivers/net/de4x5.cif (!lp->tx_enable) {
lp2005drivers/net/de4x5.cif (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
lp2006drivers/net/de4x5.clp->media = TP;
lp2012drivers/net/de4x5.c} else if (!lp->linkOK && (lp->autosense == AUTO)) {
lp2013drivers/net/de4x5.clp->media = ANS_SUSPECT;
lp2023drivers/net/de4x5.cif (!lp->tx_enable) {
lp2024drivers/net/de4x5.cif (lp->timeout < 0) {
lp2034drivers/net/de4x5.cif (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
lp2036drivers/net/de4x5.clp->media = AUI;       /* Non selected port activity */
lp2038drivers/net/de4x5.clp->media = BNC;
lp2045drivers/net/de4x5.c} else if (!lp->linkOK && (lp->autosense == AUTO)) {
lp2046drivers/net/de4x5.clp->media = TP_SUSPECT;
lp2056drivers/net/de4x5.cif (!lp->tx_enable) {
lp2057drivers/net/de4x5.cif (lp->timeout < 0) {
lp2067drivers/net/de4x5.cif (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
lp2068drivers/net/de4x5.clp->media = BNC;
lp2074drivers/net/de4x5.c} else if (!lp->linkOK && (lp->autosense == AUTO)) {
lp2075drivers/net/de4x5.clp->media = AUI_SUSPECT;
lp2085drivers/net/de4x5.cswitch (lp->local_state) {
lp2087drivers/net/de4x5.cif (lp->timeout < 0) {
lp2097drivers/net/de4x5.cif (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
lp2098drivers/net/de4x5.clp->media = NC;
lp2100drivers/net/de4x5.clp->local_state++;         /* Ensure media connected */
lp2107drivers/net/de4x5.cif (!lp->tx_enable) {
lp2112drivers/net/de4x5.clp->local_state = 0;
lp2113drivers/net/de4x5.clp->media = NC;
lp2118drivers/net/de4x5.c} else if (!lp->linkOK && (lp->autosense == AUTO)) {
lp2119drivers/net/de4x5.clp->media = BNC_SUSPECT;
lp2135drivers/net/de4x5.clp->media = INIT;
lp2136drivers/net/de4x5.clp->tx_enable = NO;
lp2145drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2150drivers/net/de4x5.cswitch(lp->media) {
lp2153drivers/net/de4x5.clp->tx_enable = FALSE;
lp2154drivers/net/de4x5.clp->timeout = -1;
lp2160drivers/net/de4x5.cif (lp->autosense == _100Mb) {
lp2161drivers/net/de4x5.clp->media = _100Mb;
lp2162drivers/net/de4x5.c} else if (lp->autosense == _10Mb) {
lp2163drivers/net/de4x5.clp->media = _10Mb;
lp2164drivers/net/de4x5.c} else if ((lp->autosense == AUTO) && (sr=is_anc_capable(dev))) {
lp2167drivers/net/de4x5.cmii_wr(ana, MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
lp2168drivers/net/de4x5.clp->media = ANS;
lp2169drivers/net/de4x5.c} else if (lp->autosense == AUTO) {
lp2170drivers/net/de4x5.clp->media = SPD_DET;
lp2172drivers/net/de4x5.clp->media = _100Mb;
lp2174drivers/net/de4x5.clp->media = NC;
lp2176drivers/net/de4x5.clp->local_state = 0;
lp2182drivers/net/de4x5.cswitch (lp->local_state) {
lp2184drivers/net/de4x5.cif (lp->timeout < 0) {
lp2185drivers/net/de4x5.cmii_wr(MII_CR_ASSE | MII_CR_RAN, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
lp2192drivers/net/de4x5.clp->local_state = 0;
lp2193drivers/net/de4x5.clp->media = SPD_DET;
lp2195drivers/net/de4x5.clp->local_state++;
lp2205drivers/net/de4x5.clp->media = SPD_DET;
lp2206drivers/net/de4x5.clp->local_state = 0;
lp2208drivers/net/de4x5.canlpa = mii_rd(MII_ANLPA, lp->phy[lp->active].addr, DE4X5_MII);
lp2209drivers/net/de4x5.cana = mii_rd(MII_ANA, lp->phy[lp->active].addr, DE4X5_MII);
lp2214drivers/net/de4x5.clp->media = _100Mb;
lp2217drivers/net/de4x5.clp->media = _10Mb;
lp2228drivers/net/de4x5.cif (!lp->phy[lp->active].id) {
lp2232drivers/net/de4x5.clp->media = _100Mb;
lp2234drivers/net/de4x5.clp->media = _10Mb;
lp2236drivers/net/de4x5.clp->media = NC;
lp2243drivers/net/de4x5.cif (!lp->tx_enable) {
lp2247drivers/net/de4x5.cif (!lp->linkOK && (lp->autosense == AUTO)) {
lp2249drivers/net/de4x5.clp->media = INIT;
lp2258drivers/net/de4x5.cif (!lp->tx_enable) {
lp2262drivers/net/de4x5.cif (!lp->linkOK && (lp->autosense == AUTO)) {
lp2264drivers/net/de4x5.clp->media = INIT;
lp2274drivers/net/de4x5.clp->media = INIT;
lp2275drivers/net/de4x5.clp->tx_enable = FALSE;
lp2284drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2292drivers/net/de4x5.clp->lostMedia = 0;
lp2293drivers/net/de4x5.clp->tx_enable = YES;
lp2302drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2306drivers/net/de4x5.cif (lp->phy[lp->active].id) {
lp2307drivers/net/de4x5.cif (lp->timeout < 0) {
lp2312drivers/net/de4x5.cmii_wr(MII_CR_RST, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);
lp2323drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2327drivers/net/de4x5.cif (lp->timeout < 0) {
lp2328drivers/net/de4x5.clp->timeout = msec/100;
lp2339drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp2347drivers/net/de4x5.cif (!(sts & irqs) && --lp->timeout) {
lp2350drivers/net/de4x5.clp->timeout = -1;
lp2358drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2362drivers/net/de4x5.cif (lp->timeout < 0) {
lp2363drivers/net/de4x5.clp->timeout = msec/100;
lp2368drivers/net/de4x5.cif (sisr && --lp->timeout) {
lp2371drivers/net/de4x5.clp->timeout = -1;
lp2383drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2386drivers/net/de4x5.cif (lp->timeout < 0) {
lp2387drivers/net/de4x5.clp->timeout = msec/100;
lp2391drivers/net/de4x5.creg = mii_rd(reg, lp->phy[lp->active].addr, DE4X5_MII) & mask;
lp2394drivers/net/de4x5.cif (test && --lp->timeout) {
lp2397drivers/net/de4x5.clp->timeout = -1;
lp2405drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2409drivers/net/de4x5.cif (lp->phy[lp->active].id) {
lp2410drivers/net/de4x5.cspd = mii_rd(lp->phy[lp->active].spd.reg, lp->phy[lp->active].addr, DE4X5_MII);
lp2411drivers/net/de4x5.cspd = ~(spd ^ lp->phy[lp->active].spd.value);
lp2412drivers/net/de4x5.cspd &= lp->phy[lp->active].spd.mask;
lp2422drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2425drivers/net/de4x5.cif (lp->phy[lp->active].id) {
lp2427drivers/net/de4x5.cmii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
lp2428drivers/net/de4x5.creturn (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
lp2436drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2439drivers/net/de4x5.cif (lp->phy[lp->active].id) {
lp2441drivers/net/de4x5.cmii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);
lp2442drivers/net/de4x5.creturn (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_LKS);
lp2450drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2453drivers/net/de4x5.cif (lp->phy[lp->active].id) {
lp2454drivers/net/de4x5.creturn (mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII) & MII_SR_ANC);
lp2466drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2470drivers/net/de4x5.cif (lp->timeout < 0) {
lp2471drivers/net/de4x5.clp->timeout = msec/100;
lp2473drivers/net/de4x5.clp->tmp = lp->tx_new;                /* Remember the ring position */
lp2474drivers/net/de4x5.cload_packet(dev, lp->frame, TD_LS | TD_FS | sizeof(lp->frame), NULL);
lp2475drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp2481drivers/net/de4x5.cif ((!(sisr & SISR_NCR)) && (lp->tx_ring[lp->tmp].status < 0) && (--lp->timeout)) {
lp2485drivers/net/de4x5.c!(lp->tx_ring[lp->tmp].status & (T_OWN | TD_ES)) && lp->timeout) {
lp2490drivers/net/de4x5.clp->timeout = -1;
lp2505drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2510drivers/net/de4x5.cif (!lp->cache.save_cnt) {
lp2513drivers/net/de4x5.cfor (i=lp->tx_new; i!=lp->tx_old; i--) {
lp2514drivers/net/de4x5.cif (lp->skb[i]) {
lp2515drivers/net/de4x5.cde4x5_putb_cache(dev, lp->skb[i]);
lp2516drivers/net/de4x5.clp->skb[i] = NULL;
lp2518drivers/net/de4x5.cif (i==0) i=lp->txRingSize;
lp2520drivers/net/de4x5.cif (lp->skb[i]) {
lp2521drivers/net/de4x5.cde4x5_putb_cache(dev, lp->skb[i]);
lp2522drivers/net/de4x5.clp->skb[i] = NULL;
lp2529drivers/net/de4x5.clp->cache.save_cnt++;
lp2538drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2544drivers/net/de4x5.cif (lp->cache.save_cnt) {
lp2551drivers/net/de4x5.cfor (i=0; TX_BUFFS_AVAIL && lp->cache.skb; i++) {
lp2554drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp2559drivers/net/de4x5.clp->cache.save_cnt--;
lp2568drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2574drivers/net/de4x5.clp->cache.csr0 = inl(DE4X5_BMR);
lp2575drivers/net/de4x5.clp->cache.csr6 = (inl(DE4X5_OMR) & ~(OMR_ST | OMR_SR));
lp2576drivers/net/de4x5.clp->cache.csr7 = inl(DE4X5_IMR);
lp2577drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp2578drivers/net/de4x5.clp->cache.csr13 = inl(DE4X5_SICR);
lp2579drivers/net/de4x5.clp->cache.csr14 = inl(DE4X5_STRR);
lp2580drivers/net/de4x5.clp->cache.csr15 = inl(DE4X5_SIGR);
lp2585drivers/net/de4x5.coutl(lp->cache.csr0, DE4X5_BMR);
lp2586drivers/net/de4x5.coutl(lp->cache.csr6, DE4X5_OMR);
lp2587drivers/net/de4x5.coutl(lp->cache.csr7, DE4X5_IMR);
lp2588drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp2590drivers/net/de4x5.cgep = (lp->media == _100Mb ? GEP_MODE : 0);
lp2591drivers/net/de4x5.cif (!lp->phy[lp->active].id && !de4x5_full_duplex) {
lp2596drivers/net/de4x5.creset_init_sia(dev, lp->cache.csr13, lp->cache.csr14, 
lp2597drivers/net/de4x5.clp->cache.csr15);
lp2607drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2610drivers/net/de4x5.cif (lp->cache.skb) {
lp2611drivers/net/de4x5.cfor (p=lp->cache.skb; p->next; p=p->next);
lp2614drivers/net/de4x5.clp->cache.skb = skb;
lp2623drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2624drivers/net/de4x5.cstruct sk_buff *p = lp->cache.skb;
lp2626drivers/net/de4x5.clp->cache.skb = skb;
lp2634drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2635drivers/net/de4x5.cstruct sk_buff *p = lp->cache.skb;
lp2638drivers/net/de4x5.clp->cache.skb = p->next;
lp2651drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2655drivers/net/de4x5.cif (lp->timeout < 0) {
lp2656drivers/net/de4x5.clp->timeout = msec/100;
lp2667drivers/net/de4x5.cif (!(sts & irqs) && (ans ^ ANS_NWOK) && --lp->timeout) {
lp2670drivers/net/de4x5.clp->timeout = -1;
lp2678drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2698drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2792drivers/net/de4x5.cstatic int PCI_signature(char *name, struct bus_type *lp)
lp2797drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2800drivers/net/de4x5.cint i = *((char *)&lp->srom + 19) * 3;
lp2801drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp2802drivers/net/de4x5.cstrncpy(name, (char *)&lp->srom + 26 + i, 8);
lp2803drivers/net/de4x5.c} else if (lp->chipset == DC21140) {
lp2804drivers/net/de4x5.cstrncpy(name, (char *)&lp->srom + 26 + i, 8);
lp2829drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp2831drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2834drivers/net/de4x5.cshort *p = (short *)&lp->srom;
lp2838drivers/net/de4x5.cde4x5_dbg_srom((struct de4x5_srom *)&lp->srom);
lp2849drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp2851drivers/net/de4x5.cbroken = de4x5_bad_srom(lp);
lp2856drivers/net/de4x5.cif (lp->bus == PCI) {
lp2857drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2865drivers/net/de4x5.cdev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
lp2866drivers/net/de4x5.cdev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
lp2868drivers/net/de4x5.cdev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
lp2869drivers/net/de4x5.cdev->dev_addr[i] = *((u_char *)&lp->srom + i); i++;
lp2882drivers/net/de4x5.cif (lp->bus == PCI) {
lp2883drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2903drivers/net/de4x5.cstatic int de4x5_bad_srom(struct bus_type *lp)
lp2908drivers/net/de4x5.cif (!de4x5_strncmp((char *)&lp->srom, (char *)&enet_det[i], 3) &&
lp2909drivers/net/de4x5.c!de4x5_strncmp((char *)&lp->srom+0x10, (char *)&enet_det[i], 3)) {
lp3197drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3209drivers/net/de4x5.clp->active = 0;
lp3210drivers/net/de4x5.cfor (lp->mii_cnt=0, i=1; i<DE4X5_MAX_MII; i++) {
lp3215drivers/net/de4x5.cfor (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++);
lp3217drivers/net/de4x5.cmemcpy((char *)&lp->phy[k],
lp3219drivers/net/de4x5.clp->phy[k].addr = i;
lp3220drivers/net/de4x5.clp->mii_cnt++;
lp3227drivers/net/de4x5.cif (lp->phy[lp->active].id) {                  /* Reset the PHY devices */
lp3228drivers/net/de4x5.cfor (k=0; lp->phy[k].id && (k < DE4X5_MAX_PHY); k++) { /*For each PHY*/
lp3229drivers/net/de4x5.cmii_wr(MII_CR_RST, MII_CR, lp->phy[k].addr, DE4X5_MII);
lp3230drivers/net/de4x5.cwhile (mii_rd(MII_CR, lp->phy[k].addr, DE4X5_MII) & MII_CR_RST);
lp3236drivers/net/de4x5.creturn lp->mii_cnt;
lp3241drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3243drivers/net/de4x5.cchar *pa = lp->setup_frame;
lp3247drivers/net/de4x5.cmemset(lp->setup_frame, 0, SETUP_FRAME_LEN);
lp3250drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp3251drivers/net/de4x5.cfor (pa=lp->setup_frame+IMPERF_PA_OFFSET, i=0; i<ETH_ALEN; i++) {
lp3255drivers/net/de4x5.c*(lp->setup_frame + (HASH_TABLE_LEN >> 3) - 3) = 0x80;
lp3279drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3281drivers/net/de4x5.cdel_timer(&lp->timer);
lp3288drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3301drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp3314drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3327drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp3340drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3344drivers/net/de4x5.cdel_timer(&lp->timer);
lp3351drivers/net/de4x5.clp->timer.expires = jiffies + dt;
lp3352drivers/net/de4x5.clp->timer.function = fn;
lp3353drivers/net/de4x5.clp->timer.data = data;
lp3354drivers/net/de4x5.cadd_timer(&lp->timer);
lp3361drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3372drivers/net/de4x5.cprintk("\t0x%8.8lx  0x%8.8lx\n",(u_long)lp->rx_ring,(u_long)lp->tx_ring);
lp3374drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp3376drivers/net/de4x5.cprintk("0x%8.8lx  ",(u_long)&lp->rx_ring[i].status);
lp3379drivers/net/de4x5.cprintk("...0x%8.8lx\n",(u_long)&lp->rx_ring[i].status);
lp3381drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp3383drivers/net/de4x5.cprintk("0x%8.8lx  ", (u_long)&lp->tx_ring[i].status);
lp3386drivers/net/de4x5.cprintk("...0x%8.8lx\n", (u_long)&lp->tx_ring[i].status);
lp3388drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp3390drivers/net/de4x5.cprintk("0x%8.8x  ",lp->rx_ring[i].buf);
lp3393drivers/net/de4x5.cprintk("...0x%8.8x\n",lp->rx_ring[i].buf);
lp3395drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp3397drivers/net/de4x5.cprintk("0x%8.8x  ", lp->tx_ring[i].buf);
lp3400drivers/net/de4x5.cprintk("...0x%8.8x\n", lp->tx_ring[i].buf);
lp3402drivers/net/de4x5.c(short)lp->rxRingSize, 
lp3403drivers/net/de4x5.c(short)lp->txRingSize); 
lp3411drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3415drivers/net/de4x5.cprintk("\nMII CR:  %x\n",mii_rd(MII_CR,lp->phy[k].addr,DE4X5_MII));
lp3416drivers/net/de4x5.cprintk("MII SR:  %x\n",mii_rd(MII_SR,lp->phy[k].addr,DE4X5_MII));
lp3417drivers/net/de4x5.cprintk("MII ID0: %x\n",mii_rd(MII_ID0,lp->phy[k].addr,DE4X5_MII));
lp3418drivers/net/de4x5.cprintk("MII ID1: %x\n",mii_rd(MII_ID1,lp->phy[k].addr,DE4X5_MII));
lp3419drivers/net/de4x5.cif (lp->phy[k].id != BROADCOM_T4) {
lp3420drivers/net/de4x5.cprintk("MII ANA: %x\n",mii_rd(0x04,lp->phy[k].addr,DE4X5_MII));
lp3421drivers/net/de4x5.cprintk("MII ANC: %x\n",mii_rd(0x05,lp->phy[k].addr,DE4X5_MII));
lp3423drivers/net/de4x5.cprintk("MII 16:  %x\n",mii_rd(0x10,lp->phy[k].addr,DE4X5_MII));
lp3424drivers/net/de4x5.cif (lp->phy[k].id != BROADCOM_T4) {
lp3425drivers/net/de4x5.cprintk("MII 17:  %x\n",mii_rd(0x11,lp->phy[k].addr,DE4X5_MII));
lp3426drivers/net/de4x5.cprintk("MII 18:  %x\n",mii_rd(0x12,lp->phy[k].addr,DE4X5_MII));
lp3428drivers/net/de4x5.cprintk("MII 20:  %x\n",mii_rd(0x14,lp->phy[k].addr,DE4X5_MII));
lp3437drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3439drivers/net/de4x5.cif (lp->media != lp->c_media) {
lp3441drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp3443drivers/net/de4x5.c(lp->media == NC  ? "unconnected!" :
lp3444drivers/net/de4x5.c(lp->media == TP  ? "TP." :
lp3445drivers/net/de4x5.c(lp->media == ANS ? "TP/Nway." :
lp3446drivers/net/de4x5.c(lp->media == BNC ? "BNC." : 
lp3447drivers/net/de4x5.c(lp->media == BNC_AUI ? "BNC/AUI." : 
lp3448drivers/net/de4x5.c(lp->media == EXT_SIA ? "EXT SIA." : 
lp3453drivers/net/de4x5.c(lp->media == NC ? "link down or incompatible connection.":
lp3454drivers/net/de4x5.c(lp->media == _100Mb  ? "100Mb/s." :
lp3455drivers/net/de4x5.c(lp->media == _10Mb   ? "10Mb/s." :
lp3460drivers/net/de4x5.clp->c_media = lp->media;
lp3495drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp3533drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp3534drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp3537drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET | 
lp3540drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp3573drivers/net/de4x5.cmemcpy_tofs(ioc->data, lp->setup_frame, ioc->len); 
lp3613drivers/net/de4x5.cioc->len = sizeof(lp->pktStats);
lp3619drivers/net/de4x5.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
lp3626drivers/net/de4x5.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp3675drivers/net/de4x5.ctmp.addr[j++] = lp->rxRingSize;
lp3676drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->rx_ring; j+=4;
lp3677drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->tx_ring; j+=4;
lp3679drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp3681drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp3684drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp3685drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp3687drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp3690drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp3692drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp3694drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->rx_ring[i].buf; j+=4;
lp3697drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->rx_ring[i].buf; j+=4;
lp3698drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp3700drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->tx_ring[i].buf; j+=4;
lp3703drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->tx_ring[i].buf; j+=4;
lp3705drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize;i++){
lp3706drivers/net/de4x5.ctmp.lval[j>>2] = lp->rx_ring[i].status; j+=4;
lp3708drivers/net/de4x5.cfor (i=0;i<lp->txRingSize;i++){
lp3709drivers/net/de4x5.ctmp.lval[j>>2] = lp->tx_ring[i].status; j+=4;
lp3720drivers/net/de4x5.ctmp.lval[j>>2] = lp->chipset; j+=4; 
lp3721drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp3729drivers/net/de4x5.ctmp.lval[j>>2] = lp->phy[lp->active].id; j+=4; 
lp3730drivers/net/de4x5.cif (lp->phy[lp->active].id) {
lp3731drivers/net/de4x5.ctmp.lval[j>>2] = lp->active; j+=4; 
lp3732drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(MII_CR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3733drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(MII_SR,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3734drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(MII_ID0,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3735drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(MII_ID1,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3736drivers/net/de4x5.cif (lp->phy[lp->active].id != BROADCOM_T4) {
lp3737drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(MII_ANA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3738drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(MII_ANLPA,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3740drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(0x10,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3741drivers/net/de4x5.cif (lp->phy[lp->active].id != BROADCOM_T4) {
lp3742drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(0x11,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3743drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(0x12,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3745drivers/net/de4x5.ctmp.lval[j>>2]=mii_rd(0x14,lp->phy[lp->active].addr,DE4X5_MII); j+=4;
lp3749drivers/net/de4x5.ctmp.addr[j++] = lp->txRingSize;
lp3804drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *) thisDE4X5.priv;
lp3821drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)p->priv;
lp3822drivers/net/de4x5.cif (lp->cache.buf) {                /* MAC buffers allocated?    */
lp3823drivers/net/de4x5.ckfree(lp->cache.buf);           /* Free the MAC buffers      */
lp3825drivers/net/de4x5.crelease_region(p->base_addr, (lp->bus == PCI ? 
lp3828drivers/net/de4x5.ckfree(lp->cache.priv);              /* Free the private area     */
lp3835drivers/net/de4x5.cif (lp->cache.buf) {                    /* Are MAC buffers allocated */
lp3836drivers/net/de4x5.ckfree(lp->cache.buf);
lp3839drivers/net/de4x5.c(lp->bus == PCI ? 
lp3842drivers/net/de4x5.ckfree(lp->cache.priv);
lp16drivers/net/de4x5.h#define DE4X5_BMR    iobase+(0x000 << lp->bus)  /* Bus Mode Register */
lp17drivers/net/de4x5.h#define DE4X5_TPD    iobase+(0x008 << lp->bus)  /* Transmit Poll Demand Reg */
lp18drivers/net/de4x5.h#define DE4X5_RPD    iobase+(0x010 << lp->bus)  /* Receive Poll Demand Reg */
lp19drivers/net/de4x5.h#define DE4X5_RRBA   iobase+(0x018 << lp->bus)  /* RX Ring Base Address Reg */
lp20drivers/net/de4x5.h#define DE4X5_TRBA   iobase+(0x020 << lp->bus)  /* TX Ring Base Address Reg */
lp21drivers/net/de4x5.h#define DE4X5_STS    iobase+(0x028 << lp->bus)  /* Status Register */
lp22drivers/net/de4x5.h#define DE4X5_OMR    iobase+(0x030 << lp->bus)  /* Operation Mode Register */
lp23drivers/net/de4x5.h#define DE4X5_IMR    iobase+(0x038 << lp->bus)  /* Interrupt Mask Register */
lp24drivers/net/de4x5.h#define DE4X5_MFC    iobase+(0x040 << lp->bus)  /* Missed Frame Counter */
lp25drivers/net/de4x5.h#define DE4X5_APROM  iobase+(0x048 << lp->bus)  /* Ethernet Address PROM */
lp26drivers/net/de4x5.h#define DE4X5_BROM   iobase+(0x048 << lp->bus)  /* Boot ROM Register */
lp27drivers/net/de4x5.h#define DE4X5_SROM   iobase+(0x048 << lp->bus)  /* Serial ROM Register */
lp28drivers/net/de4x5.h#define DE4X5_MII    iobase+(0x048 << lp->bus)  /* MII Interface Register */
lp29drivers/net/de4x5.h#define DE4X5_DDR    iobase+(0x050 << lp->bus)  /* Data Diagnostic Register */
lp30drivers/net/de4x5.h#define DE4X5_FDR    iobase+(0x058 << lp->bus)  /* Full Duplex Register */
lp31drivers/net/de4x5.h#define DE4X5_GPT    iobase+(0x058 << lp->bus)  /* General Purpose Timer Reg.*/
lp32drivers/net/de4x5.h#define DE4X5_GEP    iobase+(0x060 << lp->bus)  /* General Purpose Register */
lp33drivers/net/de4x5.h#define DE4X5_SISR   iobase+(0x060 << lp->bus)  /* SIA Status Register */
lp34drivers/net/de4x5.h#define DE4X5_SICR   iobase+(0x068 << lp->bus)  /* SIA Connectivity Register */
lp35drivers/net/de4x5.h#define DE4X5_STRR   iobase+(0x070 << lp->bus)  /* SIA TX/RX Register */
lp36drivers/net/de4x5.h#define DE4X5_SIGR   iobase+(0x078 << lp->bus)  /* SIA General Register */
lp696drivers/net/de4x5.h#define LOST_MEDIA           (lp->lostMedia > LOST_MEDIA_THRESHOLD)
lp745drivers/net/de4x5.hif (lp->phy[lp->active].id) {\
lp746drivers/net/de4x5.hmii_wr(MII_CR_10|MII_CR_ASSE,MII_CR,lp->phy[lp->active].addr,DE4X5_MII);\
lp760drivers/net/de4x5.hif (lp->phy[lp->active].id) {\
lp761drivers/net/de4x5.hmii_wr(MII_CR_100|MII_CR_ASSE, MII_CR, lp->phy[lp->active].addr, DE4X5_MII);\
lp763drivers/net/de4x5.hsr = mii_rd(MII_SR, lp->phy[lp->active].addr, DE4X5_MII);\
lp375drivers/net/depca.c#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
lp376drivers/net/depca.clp->tx_old+lp->txRingMask-lp->tx_new:\
lp377drivers/net/depca.clp->tx_old               -lp->tx_new-1)
lp472drivers/net/depca.cstruct depca_private *lp;
lp545drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp547drivers/net/depca.clp->adapter = adapter;
lp548drivers/net/depca.csprintf(lp->adapter_name,"%s (%s)", name, dev->name);
lp549drivers/net/depca.crequest_region(ioaddr, DEPCA_TOTAL_SIZE, lp->adapter_name);
lp552drivers/net/depca.clp->sh_mem = mem_start;
lp557drivers/net/depca.clp->rx_ring = (struct depca_rx_desc *)mem_start;
lp560drivers/net/depca.clp->tx_ring = (struct depca_tx_desc *)mem_start;
lp563drivers/net/depca.clp->bus_offset = mem_start & 0x00ff0000;
lp566drivers/net/depca.clp->dma_buffs = mem_start;
lp569drivers/net/depca.clp->rxRingMask = NUM_RX_DESC - 1;
lp570drivers/net/depca.clp->txRingMask = NUM_TX_DESC - 1;
lp573drivers/net/depca.cfor (i=0, j = lp->rxRingMask; j>0; i++) {
lp576drivers/net/depca.clp->rx_rlen = (s32)(i << 29);
lp577drivers/net/depca.cfor (i=0, j = lp->txRingMask; j>0; i++) {
lp580drivers/net/depca.clp->tx_rlen = (s32)(i << 29);
lp600drivers/net/depca.cswitch (lp->adapter) {
lp686drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp707drivers/net/depca.cif (request_irq(dev->irq, &depca_interrupt, 0, lp->adapter_name, NULL)) {
lp738drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp745drivers/net/depca.clp->rx_new = lp->tx_new = 0;
lp746drivers/net/depca.clp->rx_old = lp->tx_old = 0;
lp749drivers/net/depca.cfor (i = 0; i <= lp->rxRingMask; i++) {
lp750drivers/net/depca.cwritel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
lp751drivers/net/depca.cwritew(-RX_BUFF_SZ, &lp->rx_ring[i].buf_length);
lp752drivers/net/depca.clp->rx_memcpy[i]=(char *)(p+lp->bus_offset);
lp754drivers/net/depca.cfor (i = 0; i <= lp->txRingMask; i++) {
lp755drivers/net/depca.cwritel((p=lp->dma_buffs+(i+lp->txRingMask+1)*TX_BUFF_SZ) & 0x00ffffff,
lp756drivers/net/depca.c&lp->tx_ring[i].base);
lp757drivers/net/depca.clp->tx_memcpy[i]=(char *)(p+lp->bus_offset);
lp761drivers/net/depca.clp->init_block.rx_ring = ((u32)((u_long)lp->rx_ring)&LA_MASK) | lp->rx_rlen;
lp762drivers/net/depca.clp->init_block.tx_ring = ((u32)((u_long)lp->tx_ring)&LA_MASK) | lp->tx_rlen;
lp767drivers/net/depca.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp770drivers/net/depca.clp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */
lp781drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp842drivers/net/depca.cstruct depca_private *lp;
lp849drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp892drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp896drivers/net/depca.cfor (entry=lp->rx_new; 
lp897drivers/net/depca.c!(readl(&lp->rx_ring[entry].base) & R_OWN);
lp898drivers/net/depca.centry=lp->rx_new){
lp899drivers/net/depca.cstatus = readl(&lp->rx_ring[entry].base) >> 16 ;
lp901drivers/net/depca.clp->rx_old = entry;
lp905drivers/net/depca.clp->stats.rx_errors++;                 /* Update the error stats. */
lp906drivers/net/depca.cif (status & R_FRAM) lp->stats.rx_frame_errors++;
lp907drivers/net/depca.cif (status & R_OFLO) lp->stats.rx_over_errors++;
lp908drivers/net/depca.cif (status & R_CRC)  lp->stats.rx_crc_errors++;
lp909drivers/net/depca.cif (status & R_BUFF) lp->stats.rx_fifo_errors++;
lp911drivers/net/depca.cshort len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
lp920drivers/net/depca.cif (entry < lp->rx_old) {         /* Wrapped buffer */
lp921drivers/net/depca.clen = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
lp922drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], len);
lp923drivers/net/depca.cmemcpy_fromio(buf + len, lp->rx_memcpy[0], pkt_len-len);
lp925drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], pkt_len);
lp938drivers/net/depca.clp->stats.rx_packets++;
lp941drivers/net/depca.clp->pktStats.bins[i]++;
lp949drivers/net/depca.clp->pktStats.broadcast++;
lp951drivers/net/depca.clp->pktStats.multicast++;
lp956drivers/net/depca.clp->pktStats.unicast++;
lp959drivers/net/depca.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp960drivers/net/depca.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp961drivers/net/depca.cmemset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
lp965drivers/net/depca.clp->stats.rx_dropped++;  /* Really, deferred. */
lp970drivers/net/depca.cfor (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)&lp->rxRingMask) {
lp971drivers/net/depca.cwritel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, 
lp972drivers/net/depca.c&lp->rx_ring[lp->rx_old].base);
lp974drivers/net/depca.cwritel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
lp980drivers/net/depca.clp->rx_new = (++lp->rx_new) & lp->rxRingMask;
lp992drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp997drivers/net/depca.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
lp998drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].base) >> 16 ;
lp1003drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].misc);
lp1004drivers/net/depca.clp->stats.tx_errors++;
lp1005drivers/net/depca.cif (status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
lp1006drivers/net/depca.cif (status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
lp1007drivers/net/depca.cif (status & TMD3_LCOL) lp->stats.tx_window_errors++;
lp1008drivers/net/depca.cif (status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
lp1015drivers/net/depca.clp->stats.collisions++;
lp1017drivers/net/depca.clp->stats.tx_packets++;
lp1021drivers/net/depca.clp->tx_old = (++lp->tx_old) & lp->txRingMask;
lp1030drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1053drivers/net/depca.cif (lp->adapter != DEPCA) {
lp1072drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1076drivers/net/depca.coutw((u16)(lp->sh_mem & LA_MASK), DEPCA_DATA);
lp1078drivers/net/depca.coutw((u16)((lp->sh_mem & LA_MASK) >> 16), DEPCA_DATA);
lp1089drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1094drivers/net/depca.cmemcpy_toio((char *)lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
lp1107drivers/net/depca.cdev->name, i, lp->sh_mem, inw(DEPCA_DATA));
lp1111drivers/net/depca.cdev->name, i, lp->sh_mem, inw(DEPCA_DATA));
lp1121drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1125drivers/net/depca.creturn &lp->stats;
lp1134drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1140drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1146drivers/net/depca.clp->init_block.mode |= PROM;
lp1149drivers/net/depca.clp->init_block.mode &= ~PROM;   /* Unset promiscuous mode */
lp1166drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1175drivers/net/depca.clp->init_block.mcast_table[i] = (char)0xff;
lp1179drivers/net/depca.clp->init_block.mcast_table[i]=0;
lp1201drivers/net/depca.clp->init_block.mcast_table[byte] |= bit;
lp1534drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1537drivers/net/depca.centry = lp->tx_new;                     /* Ring around buffer number. */
lp1538drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
lp1539drivers/net/depca.cif (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
lp1545drivers/net/depca.clen = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
lp1546drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
lp1547drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
lp1549drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
lp1554drivers/net/depca.cfor (i = entry; i != end; i = (++i) & lp->txRingMask) {
lp1556drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
lp1557drivers/net/depca.cwritew(0x0000, &lp->tx_ring[i].misc);    /* clears other error flags */
lp1558drivers/net/depca.cwritew(-TX_BUFF_SZ, &lp->tx_ring[i].length);/* packet length in buffer */
lp1562drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
lp1563drivers/net/depca.cwritew(0x0000, &lp->tx_ring[end].misc);    /* clears other error flags */
lp1564drivers/net/depca.cwritew(-len, &lp->tx_ring[end].length);    /* packet length in last buff */
lp1567drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
lp1569drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
lp1573drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
lp1574drivers/net/depca.cif (i == 0) i=lp->txRingMask+1;
lp1576drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
lp1578drivers/net/depca.clp->tx_new = (++end) & lp->txRingMask;     /* update current pointers */
lp1622drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1624drivers/net/depca.cstruct depca_init *p = (struct depca_init *)lp->sh_mem;
lp1629drivers/net/depca.cmemcpy_toio((char *)lp->sh_mem,&lp->init_block,sizeof(struct depca_init));
lp1633drivers/net/depca.cprintk("\t0x%lx  0x%lx\n",(u_long)lp->rx_ring, (u_long)lp->tx_ring);
lp1635drivers/net/depca.cfor (i=0;i<lp->rxRingMask;i++){
lp1637drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
lp1640drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
lp1642drivers/net/depca.cfor (i=0;i<lp->txRingMask;i++){
lp1644drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
lp1647drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
lp1649drivers/net/depca.cfor (i=0;i<lp->rxRingMask;i++){
lp1651drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->rx_ring[i].base));
lp1654drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
lp1656drivers/net/depca.cfor (i=0;i<lp->txRingMask;i++){
lp1658drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->tx_ring[i].base));
lp1661drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
lp1662drivers/net/depca.cprintk("Initialisation block at 0x%8.8lx\n",lp->sh_mem);
lp1676drivers/net/depca.cprintk("dma_buffs: 0x%8.8lx\n",lp->dma_buffs);
lp1678drivers/net/depca.c(int)lp->rxRingMask + 1, 
lp1679drivers/net/depca.clp->rx_rlen);
lp1681drivers/net/depca.c(int)lp->txRingMask + 1, 
lp1682drivers/net/depca.clp->tx_rlen);
lp1701drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1731drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);/* Wait for the ring to empty */
lp1748drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1752drivers/net/depca.clp->init_block.mode |= PROM;      /* Set promiscuous mode */
lp1766drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1770drivers/net/depca.clp->init_block.mode &= ~PROM;     /* Clear promiscuous mode */
lp1787drivers/net/depca.cmemcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len); 
lp1820drivers/net/depca.cioc->len = sizeof(lp->pktStats);
lp1822drivers/net/depca.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
lp1830drivers/net/depca.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1842drivers/net/depca.cmemcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
lp502drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp510drivers/net/eepro.clp->eepro = 1; /* Yes, an Intel EtherExpress Pro/10 */
lp511drivers/net/eepro.celse lp->eepro = 0; /* No, it is a generic 82585 lan card */
lp567drivers/net/eepro.clp->rx_start = (RCV_LOWER_LIMIT << 8) ;
lp578drivers/net/eepro.clp->tx_start = lp->tx_end = XMT_LOWER_LIMIT << 8; /* or = RCV_RAM */
lp579drivers/net/eepro.clp->tx_last = 0;  
lp597drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp612drivers/net/eepro.clp->stats.tx_errors++;
lp620drivers/net/eepro.clp->tx_start = lp->tx_end = RCV_RAM; 
lp621drivers/net/eepro.clp->tx_last = 0;
lp717drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp734drivers/net/eepro.clp->tx_start = lp->tx_end = RCV_RAM ;
lp735drivers/net/eepro.clp->tx_last = 0;  
lp766drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp768drivers/net/eepro.creturn &lp->stats;
lp776drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp824drivers/net/eepro.coutw(lp->tx_end, ioaddr + HOST_ADDRESS_REG);
lp841drivers/net/eepro.coutw(lp->tx_end, ioaddr + XMT_BAR);
lp845drivers/net/eepro.ci = lp->tx_end + XMT_HEADER + 6*(dev->mc_count + 1);
lp846drivers/net/eepro.cif (lp->tx_start != lp->tx_end) 
lp850drivers/net/eepro.coutw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
lp852drivers/net/eepro.coutw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
lp855drivers/net/eepro.clp->tx_end = i ;
lp857drivers/net/eepro.celse lp->tx_start = lp->tx_end = i ;
lp936drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp946drivers/net/eepro.cif (lp->tx_end > lp->tx_start)
lp947drivers/net/eepro.ctx_available = XMT_RAM - (lp->tx_end - lp->tx_start);
lp948drivers/net/eepro.celse if (lp->tx_end < lp->tx_start)
lp949drivers/net/eepro.ctx_available = lp->tx_start - lp->tx_end;
lp961drivers/net/eepro.clast = lp->tx_end;
lp981drivers/net/eepro.cif (lp->tx_start != lp->tx_end) { 
lp984drivers/net/eepro.cif (lp->tx_end != last) {
lp985drivers/net/eepro.coutw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
lp988drivers/net/eepro.coutw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
lp999drivers/net/eepro.cif (lp->tx_start == lp->tx_end) {
lp1002drivers/net/eepro.clp->tx_start = last;   /* I don't like to change tx_start here */
lp1006drivers/net/eepro.clp->tx_last = last;
lp1007drivers/net/eepro.clp->tx_end = end;
lp1026drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp1029drivers/net/eepro.cshort rcv_car = lp->rx_start;
lp1052drivers/net/eepro.clp->stats.rx_dropped++;
lp1062drivers/net/eepro.clp->stats.rx_packets++;
lp1066drivers/net/eepro.clp->stats.rx_errors++;
lp1068drivers/net/eepro.clp->stats.rx_over_errors++;
lp1070drivers/net/eepro.clp->stats.rx_frame_errors++;
lp1072drivers/net/eepro.clp->stats.rx_crc_errors++;
lp1077drivers/net/eepro.clp->stats.rx_length_errors++;
lp1081drivers/net/eepro.crcv_car = lp->rx_start + RCV_HEADER + rcv_size;
lp1082drivers/net/eepro.clp->rx_start = rcv_next_frame;
lp1098drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp1103drivers/net/eepro.cwhile (lp->tx_start != lp->tx_end) { 
lp1105drivers/net/eepro.coutw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
lp1109drivers/net/eepro.clp->tx_start = inw(ioaddr+IO_PORT);
lp1117drivers/net/eepro.clp->stats.tx_packets++;
lp1119drivers/net/eepro.clp->stats.tx_errors++;
lp1121drivers/net/eepro.clp->stats.tx_carrier_errors++;
lp1126drivers/net/eepro.clp->stats.collisions += (xmt_status & 0x000f);
lp1128drivers/net/eepro.clp->stats.tx_heartbeat_errors++;
lp337drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp345drivers/net/eexpress.creturn &lp->stats;
lp355drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp373drivers/net/eexpress.cif (lp->tx_link==lp->last_tx_restart) 
lp379drivers/net/eexpress.clp->last_tx_restart = 0;
lp380drivers/net/eexpress.coutw(lp->tx_link,ioaddr+SCB_CBL);
lp391drivers/net/eexpress.coutw(lp->tx_link,ioaddr+SCB_CBL);
lp427drivers/net/eexpress.cif ((jiffies-lp->init_time)>10)
lp447drivers/net/eexpress.clp->stats.tx_errors++;
lp458drivers/net/eexpress.clp->stats.tx_dropped++;
lp484drivers/net/eexpress.cstruct net_local *lp;
lp500drivers/net/eexpress.clp = (struct net_local *)dev->priv;
lp514drivers/net/eexpress.coutw(lp->tx_link,ioaddr+SCB_CBL);
lp533drivers/net/eexpress.clp->stats.rx_errors++;
lp561drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp565drivers/net/eexpress.cunsigned short rx_block = lp->rx_first;
lp597drivers/net/eexpress.clp->stats.rx_errors++;
lp599drivers/net/eexpress.clp->stats.rx_crc_errors++;
lp601drivers/net/eexpress.clp->stats.rx_frame_errors++;
lp603drivers/net/eexpress.clp->stats.rx_fifo_errors++;
lp605drivers/net/eexpress.clp->stats.rx_over_errors++;
lp607drivers/net/eexpress.clp->stats.rx_length_errors++;
lp617drivers/net/eexpress.clp->stats.rx_dropped++;
lp626drivers/net/eexpress.clp->stats.rx_packets++;
lp647drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp651drivers/net/eexpress.coutw(lp->tx_head,ioaddr+WRITE_PTR);
lp654drivers/net/eexpress.coutw(lp->tx_head+0x08,ioaddr);
lp655drivers/net/eexpress.coutw(lp->tx_head+0x0e,ioaddr);
lp658drivers/net/eexpress.coutw(lp->tx_head+0x08,ioaddr);
lp661drivers/net/eexpress.coutw(lp->tx_head+0x16,ioaddr);
lp664drivers/net/eexpress.coutw(lp->tx_tail+0x0c,ioaddr+WRITE_PTR);
lp665drivers/net/eexpress.coutw(lp->tx_head,ioaddr);
lp667drivers/net/eexpress.clp->tx_tail = lp->tx_head;
lp668drivers/net/eexpress.cif (lp->tx_head==TX_BUF_START+((NUM_TX_BUFS-1)*TX_BUF_SIZE)) 
lp669drivers/net/eexpress.clp->tx_head = TX_BUF_START;
lp671drivers/net/eexpress.clp->tx_head += TX_BUF_SIZE;
lp672drivers/net/eexpress.cif (lp->tx_head != lp->tx_reap) 
lp841drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp845drivers/net/eexpress.cunsigned short tx_block = lp->tx_reap;
lp848drivers/net/eexpress.cif (!test_bit(0,(void *)&dev->tbusy) && lp->tx_head==lp->tx_reap) 
lp857drivers/net/eexpress.clp->tx_link = tx_block;
lp864drivers/net/eexpress.clp->last_tx_restart = 0;
lp865drivers/net/eexpress.clp->stats.collisions += Stat_NoColl(status);
lp869drivers/net/eexpress.clp->stats.tx_aborted_errors++;
lp871drivers/net/eexpress.clp->stats.tx_carrier_errors++;
lp873drivers/net/eexpress.clp->stats.tx_fifo_errors++;
lp876drivers/net/eexpress.clp->stats.tx_packets++;
lp879drivers/net/eexpress.clp->tx_reap = tx_block = TX_BUF_START;
lp881drivers/net/eexpress.clp->tx_reap = tx_block += TX_BUF_SIZE;
lp885drivers/net/eexpress.cwhile (lp->tx_reap != lp->tx_head);
lp887drivers/net/eexpress.clp->tx_link = lp->tx_tail + 0x08;
lp903drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp906drivers/net/eexpress.clp->last_tx_restart = lp->tx_link;
lp907drivers/net/eexpress.coutw(lp->tx_link,ioaddr+SCB_CBL);
lp922drivers/net/eexpress.coutw(lp->tx_link,ioaddr+SCB_CBL);
lp956drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp978drivers/net/eexpress.clp->tx_head = TX_BUF_START;
lp979drivers/net/eexpress.clp->tx_reap = TX_BUF_START;
lp980drivers/net/eexpress.clp->tx_tail = tx_block - TX_BUF_SIZE;
lp981drivers/net/eexpress.clp->tx_link = lp->tx_tail + 0x08;
lp1004drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp1010drivers/net/eexpress.clp->rx_first = rx_block;
lp1025drivers/net/eexpress.clp->rx_last = rx_block;
lp1029drivers/net/eexpress.coutw(lp->rx_last+4,ioaddr+WRITE_PTR);
lp1030drivers/net/eexpress.coutw(lp->rx_first,ioaddr);
lp1043drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp1050drivers/net/eexpress.coutw((rx_buf==lp->rx_last)?lp->rx_first:(rx_buf+RX_BUF_SIZE),ioaddr);
lp1072drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp1152drivers/net/eexpress.clp->init_time = jiffies;
lp791drivers/net/eth16i.cstruct eth16i_local *lp = (struct eth16i_local *)dev->priv;
lp803drivers/net/eth16i.clp->tx_buf_size = eth16i_tx_buf_map[ETH16I_TX_BUF_SIZE & 0x03];
lp806drivers/net/eth16i.cprintk("%s: transmit buffer size %d\n", dev->name, lp->tx_buf_size);
lp814drivers/net/eth16i.clp->open_time = jiffies;
lp815drivers/net/eth16i.clp->tx_started = 0;
lp816drivers/net/eth16i.clp->tx_queue = 0;
lp817drivers/net/eth16i.clp->tx_queue_len = 0;
lp835drivers/net/eth16i.cstruct eth16i_local *lp = (struct eth16i_local *)dev->priv;
lp838drivers/net/eth16i.clp->open_time = 0;
lp861drivers/net/eth16i.cstruct eth16i_local *lp = (struct eth16i_local *)dev->priv;
lp887drivers/net/eth16i.cprintk("lp->tx_queue = %d\n", lp->tx_queue);
lp888drivers/net/eth16i.cprintk("lp->tx_queue_len = %d\n", lp->tx_queue_len);
lp889drivers/net/eth16i.cprintk("lp->tx_started = %d\n", lp->tx_started);
lp893drivers/net/eth16i.clp->stats.tx_errors++;
lp903drivers/net/eth16i.clp->tx_started = 0;
lp904drivers/net/eth16i.clp->tx_queue = 0;
lp905drivers/net/eth16i.clp->tx_queue_len = 0;
lp951drivers/net/eth16i.clp->tx_queue++;
lp952drivers/net/eth16i.clp->tx_queue_len += length + 2;
lp954drivers/net/eth16i.cif(lp->tx_started == 0) {
lp956drivers/net/eth16i.coutb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
lp957drivers/net/eth16i.clp->tx_queue = 0;
lp958drivers/net/eth16i.clp->tx_queue_len = 0;
lp960drivers/net/eth16i.clp->tx_started = 1;
lp963drivers/net/eth16i.celse if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
lp980drivers/net/eth16i.cstruct eth16i_local *lp = (struct eth16i_local *)dev->priv;
lp996drivers/net/eth16i.clp->stats.rx_errors++;
lp997drivers/net/eth16i.cif( status & PKT_SHORT     ) lp->stats.rx_length_errors++;
lp998drivers/net/eth16i.cif( status & PKT_ALIGN_ERR ) lp->stats.rx_frame_errors++;
lp999drivers/net/eth16i.cif( status & PKT_CRC_ERR   ) lp->stats.rx_crc_errors++;
lp1000drivers/net/eth16i.cif( status & PKT_RX_BUF_OVERFLOW) lp->stats.rx_over_errors++;
lp1012drivers/net/eth16i.clp->stats.rx_dropped++;
lp1021drivers/net/eth16i.clp->stats.rx_dropped++;
lp1053drivers/net/eth16i.clp->stats.rx_packets++;
lp1092drivers/net/eth16i.cstruct eth16i_local *lp;
lp1107drivers/net/eth16i.clp = (struct eth16i_local *)dev->priv;
lp1117drivers/net/eth16i.clp->stats.tx_packets++;
lp1119drivers/net/eth16i.cif(lp->tx_queue) {           /* Is there still packets ? */
lp1122drivers/net/eth16i.coutb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
lp1123drivers/net/eth16i.clp->tx_queue = 0;
lp1124drivers/net/eth16i.clp->tx_queue_len = 0;
lp1130drivers/net/eth16i.clp->tx_started = 0;
lp1165drivers/net/eth16i.cstruct eth16i_local *lp = (struct eth16i_local *)dev->priv;
lp1167drivers/net/eth16i.creturn &lp->stats;
lp224drivers/net/ewrk3.cicr |= lp->irq_mask;\
lp230drivers/net/ewrk3.cicr &= ~lp->irq_mask;\
lp378drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp513drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp515drivers/net/ewrk3.clp->shmem_base = mem_start;
lp516drivers/net/ewrk3.clp->shmem_length = shmem_length;
lp517drivers/net/ewrk3.clp->lemac = lemac;
lp518drivers/net/ewrk3.clp->hard_strapped = hard_strapped;
lp520drivers/net/ewrk3.clp->mPage = 64;
lp521drivers/net/ewrk3.cif (cmr & CMR_DRAM) lp->mPage <<= 1 ;/* 2 DRAMS on module */ 
lp523drivers/net/ewrk3.csprintf(lp->adapter_name,"%s (%s)", name, dev->name);
lp524drivers/net/ewrk3.crequest_region(iobase, EWRK3_TOTAL_SIZE, lp->adapter_name);
lp526drivers/net/ewrk3.clp->irq_mask = ICR_TNEM|ICR_TXDM|ICR_RNEM|ICR_RXDM;
lp616drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp626drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp646drivers/net/ewrk3.cif (lp->shmem_length == 0) {
lp649drivers/net/ewrk3.cprintk("  start of shared memory: 0x%08lx\n",lp->shmem_base);
lp650drivers/net/ewrk3.cprintk("  window length: 0x%04lx\n",lp->shmem_length);
lp689drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp709drivers/net/ewrk3.cfor (page=1;page<lp->mPage;page++) {      /* Write the free page numbers */
lp713drivers/net/ewrk3.clp->lock = 0;                             /* Ensure there are no locks */
lp724drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp730drivers/net/ewrk3.cif (dev->tbusy || lp->lock) {
lp734drivers/net/ewrk3.c} else if (!lp->hard_strapped) {
lp778drivers/net/ewrk3.cif ((page = inb(EWRK3_FMQ)) < lp->mPage) {
lp782drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp783drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp785drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp786drivers/net/ewrk3.cbuf = lp->shmem_base;
lp788drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp789drivers/net/ewrk3.cbuf = ((((short)page << 11) & 0x7800) + lp->shmem_base);
lp791drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp792drivers/net/ewrk3.cbuf = ((((short)page << 11) & 0xf800) + lp->shmem_base);
lp806drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp823drivers/net/ewrk3.cif (lp->txc) {
lp849drivers/net/ewrk3.clp->lock = 0;         /* unlock the page register */
lp877drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp884drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp917drivers/net/ewrk3.clp->irq_mask |= ICR_TXDM|ICR_RXDM;/* enable the interrupt source */
lp923drivers/net/ewrk3.clp->irq_mask &= ~(ICR_TXDM|ICR_RXDM);/* disable the interrupt source */
lp940drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp947drivers/net/ewrk3.cif ((page = inb(EWRK3_RQ)) < lp->mPage) {/* Get next entry's buffer page */
lp952drivers/net/ewrk3.cif ((tmpLock = set_bit(0, (void *)&lp->lock)) == 1) {   /* Assert lock */
lp953drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {              /* Get existing page */
lp963drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp965drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp966drivers/net/ewrk3.cbuf = lp->shmem_base;
lp968drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp969drivers/net/ewrk3.cbuf = ((((short)page << 11) & 0x7800) + lp->shmem_base);
lp971drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp972drivers/net/ewrk3.cbuf = ((((short)page << 11) & 0xf800) + lp->shmem_base);
lp983drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp995drivers/net/ewrk3.clp->stats.rx_errors++;            /* Update the error stats. */
lp996drivers/net/ewrk3.cif (rx_status & R_DBE) lp->stats.rx_frame_errors++;
lp997drivers/net/ewrk3.cif (rx_status & R_CRC) lp->stats.rx_crc_errors++;
lp998drivers/net/ewrk3.cif (rx_status & R_PLL) lp->stats.rx_fifo_errors++;
lp1008drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1027drivers/net/ewrk3.clp->stats.rx_packets++;
lp1030drivers/net/ewrk3.clp->pktStats.bins[i]++;
lp1037drivers/net/ewrk3.clp->pktStats.broadcast++;
lp1039drivers/net/ewrk3.clp->pktStats.multicast++;
lp1043drivers/net/ewrk3.clp->pktStats.unicast++;
lp1046drivers/net/ewrk3.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1047drivers/net/ewrk3.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1048drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1052drivers/net/ewrk3.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1063drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {    /* Replace old page */
lp1069drivers/net/ewrk3.clp->lock = 0;                           /* Unlock the page register */
lp1084drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1091drivers/net/ewrk3.clp->stats.tx_errors++;
lp1092drivers/net/ewrk3.cif (tx_status & T_NCL)    lp->stats.tx_carrier_errors++;
lp1093drivers/net/ewrk3.cif (tx_status & T_LCL)    lp->stats.tx_window_errors++;
lp1096drivers/net/ewrk3.clp->pktStats.tx_underruns++;
lp1098drivers/net/ewrk3.clp->pktStats.excessive_underruns++;
lp1102drivers/net/ewrk3.clp->stats.collisions++;
lp1104drivers/net/ewrk3.clp->pktStats.excessive_collisions++;
lp1108drivers/net/ewrk3.clp->stats.tx_packets++;
lp1119drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1148drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp1162drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1166drivers/net/ewrk3.creturn &lp->stats;
lp1175drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1182drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1183drivers/net/ewrk3.clp->mctbl = (char *) PAGE0_HTE;
lp1185drivers/net/ewrk3.clp->mctbl = (char *)(lp->shmem_base + PAGE0_HTE);
lp1210drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1215drivers/net/ewrk3.cshort *p = (short *) lp->mctbl;
lp1219drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1221drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1223drivers/net/ewrk3.coutw(EEPROM_OFFSET(lp->mctbl), EWRK3_PIR1);
lp1230drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1239drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1248drivers/net/ewrk3.cmemset_io(lp->mctbl, 0, (HASH_TABLE_LEN >> 3));
lp1249drivers/net/ewrk3.cwriteb(0x80, (char *)(lp->mctbl + (HASH_TABLE_LEN >> 4) - 1));
lp1269drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1272drivers/net/ewrk3.coutw((short)((long)lp->mctbl) + byte, EWRK3_PIR1);
lp1275drivers/net/ewrk3.coutw((short)((long)lp->mctbl) + byte, EWRK3_PIR1);
lp1278drivers/net/ewrk3.cwriteb(readb(lp->mctbl + byte) | bit, lp->mctbl + byte);
lp1284drivers/net/ewrk3.clp->lock = 0;                              /* Unlock the page register */
lp1674drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1743drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1744drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1752drivers/net/ewrk3.cmemcpy_fromio(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
lp1757drivers/net/ewrk3.clp->lock = 0;                               /* Unlock the page register */
lp1792drivers/net/ewrk3.cioc->len = sizeof(lp->pktStats);
lp1794drivers/net/ewrk3.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
lp1802drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1870drivers/net/ewrk3.clp->txc = 1;
lp1878drivers/net/ewrk3.clp->txc = 0;
lp307drivers/net/hp100.cstruct hp100_private *lp;
lp410drivers/net/hp100.clp = (struct hp100_private *)dev -> priv;
lp411drivers/net/hp100.clp -> id = eid;
lp412drivers/net/hp100.clp -> mem_mapped = mem_mapped;
lp413drivers/net/hp100.clp -> mem_ptr_phys = mem_ptr_phys;
lp414drivers/net/hp100.clp -> mem_ptr_virt = mem_ptr_virt;
lp416drivers/net/hp100.clp -> soft_model = hp100_inb( SOFT_MODEL );
lp417drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;
lp418drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;
lp424drivers/net/hp100.clp -> memory_size = 0x200 << ( ( hp100_inb( SRAM ) & 0xe0 ) >> 5 );
lp425drivers/net/hp100.clp -> rx_ratio = hp100_rx_ratio;
lp443drivers/net/hp100.clp -> lan_type = hp100_sense_lan( dev );
lp446drivers/net/hp100.cdev -> name, lp -> id -> name, ioaddr, dev -> irq );
lp453drivers/net/hp100.clp -> memory_size >> ( 10 - 4 ), lp -> rx_ratio );
lp463drivers/net/hp100.cif ( lp -> lan_type != HP100_LAN_ERR )
lp465drivers/net/hp100.cswitch ( lp -> lan_type ) {
lp489drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp491drivers/net/hp100.cif ( request_irq( dev -> irq, hp100_interrupt, SA_INTERRUPT, lp -> id -> name, NULL ) )
lp505drivers/net/hp100.clp -> lan_type = hp100_sense_lan( dev );
lp506drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;
lp507drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;
lp536drivers/net/hp100.chp100_outw( ( lp -> memory_size * lp -> rx_ratio ) / 100, RX_MEM_STOP );
lp537drivers/net/hp100.chp100_outw( lp -> memory_size - 1, TX_MEM_STOP );
lp540drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp541drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp551drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp558drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )  /* relogin */
lp579drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp581drivers/net/hp100.cif ( lp -> lan_type < 0 )
lp584drivers/net/hp100.cif ( ( lp -> lan_type = hp100_sense_lan( dev ) ) < 0 )
lp590drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp591drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp601drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 && lp -> hub_status < 0 )
lp606drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp618drivers/net/hp100.cif ( lp -> lan_type != i )
lp622drivers/net/hp100.clp -> lan_type = i;
lp624drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp625drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp664drivers/net/hp100.cif ( lp -> mem_mapped )
lp666drivers/net/hp100.cif ( lp -> mem_ptr_virt )
lp668drivers/net/hp100.cmemcpy( lp -> mem_ptr_virt, skb -> data, skb -> len );
lp670drivers/net/hp100.cmemset( lp -> mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb -> len );
lp674drivers/net/hp100.cmemcpy_toio( lp -> mem_ptr_phys, skb -> data, skb -> len );
lp676drivers/net/hp100.cmemset_io( lp -> mem_ptr_phys, 0, HP100_MIN_PACKET_SIZE - skb -> len );
lp687drivers/net/hp100.clp -> stats.tx_packets++;
lp708drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp713drivers/net/hp100.cif ( lp -> lan_type < 0 )
lp715drivers/net/hp100.cif ( ( lp -> lan_type = hp100_sense_lan( dev ) ) == HP100_LAN_100 )
lp716drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp734drivers/net/hp100.cif ( lp -> mem_mapped )
lp736drivers/net/hp100.cif ( lp -> mem_ptr_virt )
lp737drivers/net/hp100.cheader = *(__u32 *)lp -> mem_ptr_virt;
lp739drivers/net/hp100.cheader = readl( lp -> mem_ptr_phys );
lp759drivers/net/hp100.clp -> stats.rx_dropped++;
lp767drivers/net/hp100.cif ( lp -> mem_mapped )
lp769drivers/net/hp100.cif ( lp -> mem_ptr_virt )
lp770drivers/net/hp100.cmemcpy( ptr, lp -> mem_ptr_virt, ( pkt_len + 3 ) & ~3 );
lp772drivers/net/hp100.cmemcpy_fromio( ptr, lp -> mem_ptr_phys, ( pkt_len + 3 ) & ~3 );
lp778drivers/net/hp100.clp -> stats.rx_packets++;
lp789drivers/net/hp100.clp -> stats.multicast++; break;
lp815drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp819drivers/net/hp100.clp -> stats.rx_errors += val;
lp820drivers/net/hp100.clp -> stats.rx_over_errors += val;
lp822drivers/net/hp100.clp -> stats.rx_errors += val;
lp823drivers/net/hp100.clp -> stats.rx_crc_errors += val;
lp825drivers/net/hp100.clp -> stats.tx_errors += val;
lp826drivers/net/hp100.clp -> stats.tx_aborted_errors += val;
lp852drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp864drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE6;  /* promiscuous mode, all good */
lp865drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE6;  /* packets on the net */
lp870drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE5;  /* multicast mode, packets for me */
lp871drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE5;  /* broadcasts and all multicasts */
lp875drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;  /* normal mode, packets for me */
lp876drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;  /* and broadcasts */
lp879drivers/net/hp100.chp100_outb( lp -> mac2_mode, MAC_CFG_2 );
lp881drivers/net/hp100.chp100_orb( lp -> mac1_mode |
lp896drivers/net/hp100.cstruct hp100_private *lp;
lp922drivers/net/hp100.clp = (struct hp100_private *)dev -> priv;
lp940drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp945drivers/net/hp100.chp100_outb( lp -> mac2_mode, MAC_CFG_2 );
lp947drivers/net/hp100.chp100_orb( lp -> mac1_mode |
lp953drivers/net/hp100.cif ( lp -> mem_mapped )
lp1001drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp1011drivers/net/hp100.cif ( lp -> id -> id == 0x02019F022 ) /* HP J27248B doesn't have 100Mb/s interface */
lp336drivers/net/lance.cstruct lance_private *lp;
lp406drivers/net/lance.clp = (struct lance_private *) kmalloc(sizeof(*lp), GFP_DMA | GFP_KERNEL);
lp407drivers/net/lance.cmemset(lp, 0, sizeof(*lp));
lp408drivers/net/lance.cdev->priv = lp;
lp409drivers/net/lance.clp->name = chipname;
lp410drivers/net/lance.clp->rx_buffs = (unsigned long) kmalloc(PKT_BUF_SZ*RX_RING_SIZE, GFP_DMA | GFP_KERNEL);
lp411drivers/net/lance.clp->tx_bounce_buffs = NULL;
lp413drivers/net/lance.clp->tx_bounce_buffs = kmalloc(PKT_BUF_SZ*TX_RING_SIZE, GFP_DMA | GFP_KERNEL);
lp415drivers/net/lance.clp->chip_version = lance_version;
lp417drivers/net/lance.clp->init_block.mode = 0x0003;    /* Disable Rx and Tx. */
lp419drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp420drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp421drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp422drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp423drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp427drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp430drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp538drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
lp562drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp567drivers/net/lance.crequest_irq(dev->irq, &lance_interrupt, 0, lp->name, NULL)) {
lp586drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_MUST_UNRESET)
lp589drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
lp597drivers/net/lance.cdev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
lp598drivers/net/lance.c(int) &lp->init_block);
lp603drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp605drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp628drivers/net/lance.cdev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
lp648drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp652drivers/net/lance.cif (lp->tx_skbuff[i]) {
lp653drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[i],FREE_WRITE);
lp654drivers/net/lance.clp->tx_skbuff[i] = NULL;
lp664drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp667drivers/net/lance.clp->lock = 0, lp->tx_full = 0;
lp668drivers/net/lance.clp->cur_rx = lp->cur_tx = 0;
lp669drivers/net/lance.clp->dirty_rx = lp->dirty_tx = 0;
lp672drivers/net/lance.clp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
lp673drivers/net/lance.clp->rx_ring[i].buf_length = -PKT_BUF_SZ;
lp678drivers/net/lance.clp->tx_ring[i].base = 0;
lp681drivers/net/lance.clp->init_block.mode = 0x0000;
lp683drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp684drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp685drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp686drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp687drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp693drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp696drivers/net/lance.c(chip_table[lp->chip_version].flags & LANCE_MUST_REINIT_RING)) {
lp707drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp721drivers/net/lance.clp->stats.tx_errors++;
lp726drivers/net/lance.clp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
lp727drivers/net/lance.clp->cur_rx);
lp730drivers/net/lance.clp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
lp731drivers/net/lance.clp->rx_ring[i].msg_length);
lp734drivers/net/lance.clp->tx_ring[i].base, -lp->tx_ring[i].length,
lp735drivers/net/lance.clp->tx_ring[i].misc);
lp769drivers/net/lance.cif (set_bit(0, (void*)&lp->lock) != 0) {
lp779drivers/net/lance.centry = lp->cur_tx & TX_RING_MOD_MASK;
lp785drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_MUST_PAD) {
lp786drivers/net/lance.clp->tx_ring[entry].length =
lp789drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
lp791drivers/net/lance.clp->tx_ring[entry].misc = 0x0000;
lp799drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
lp800drivers/net/lance.clp->tx_ring[entry].base =
lp801drivers/net/lance.c(int)(lp->tx_bounce_buffs + entry) | 0x83000000;
lp804drivers/net/lance.clp->tx_skbuff[entry] = skb;
lp805drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
lp807drivers/net/lance.clp->cur_tx++;
lp817drivers/net/lance.clp->lock = 0;
lp818drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
lp821drivers/net/lance.clp->tx_full = 1;
lp832drivers/net/lance.cstruct lance_private *lp;
lp842drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp864drivers/net/lance.cint dirty_tx = lp->dirty_tx;
lp866drivers/net/lance.cwhile (dirty_tx < lp->cur_tx) {
lp868drivers/net/lance.cint status = lp->tx_ring[entry].base;
lp873drivers/net/lance.clp->tx_ring[entry].base = 0;
lp877drivers/net/lance.cint err_status = lp->tx_ring[entry].misc;
lp878drivers/net/lance.clp->stats.tx_errors++;
lp879drivers/net/lance.cif (err_status & 0x0400) lp->stats.tx_aborted_errors++;
lp880drivers/net/lance.cif (err_status & 0x0800) lp->stats.tx_carrier_errors++;
lp881drivers/net/lance.cif (err_status & 0x1000) lp->stats.tx_window_errors++;
lp884drivers/net/lance.clp->stats.tx_fifo_errors++;
lp893drivers/net/lance.clp->stats.collisions++;
lp894drivers/net/lance.clp->stats.tx_packets++;
lp899drivers/net/lance.cif (lp->tx_skbuff[entry]) {
lp900drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
lp901drivers/net/lance.clp->tx_skbuff[entry] = 0;
lp907drivers/net/lance.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp909drivers/net/lance.cdirty_tx, lp->cur_tx, lp->tx_full);
lp914drivers/net/lance.cif (lp->tx_full && dev->tbusy
lp915drivers/net/lance.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp917drivers/net/lance.clp->tx_full = 0;
lp922drivers/net/lance.clp->dirty_tx = dirty_tx;
lp926drivers/net/lance.cif (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
lp927drivers/net/lance.cif (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
lp959drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp960drivers/net/lance.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
lp964drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
lp965drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
lp973drivers/net/lance.clp->stats.rx_errors++; /* end of a packet.*/
lp974drivers/net/lance.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp975drivers/net/lance.cif (status & 0x10) lp->stats.rx_over_errors++;
lp976drivers/net/lance.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp977drivers/net/lance.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp978drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
lp983drivers/net/lance.cshort pkt_len = (lp->rx_ring[entry].msg_length & 0xfff)-4;
lp989drivers/net/lance.clp->stats.rx_errors++;
lp998drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
lp1003drivers/net/lance.clp->stats.rx_dropped++;
lp1004drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp1005drivers/net/lance.clp->cur_rx++;
lp1013drivers/net/lance.c(unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
lp1017drivers/net/lance.clp->stats.rx_packets++;
lp1022drivers/net/lance.clp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
lp1023drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp1024drivers/net/lance.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
lp1037drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp1042drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
lp1044drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp1069drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp1074drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
lp1079drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp1084drivers/net/lance.creturn &lp->stats;
lp156drivers/net/pi2.cstatic void rts(struct pi_local *lp, int x);
lp157drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp);
lp158drivers/net/pi2.cstatic void b_txint(struct pi_local *lp);
lp159drivers/net/pi2.cstatic void b_exint(struct pi_local *lp);
lp160drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp);
lp161drivers/net/pi2.cstatic void a_txint(struct pi_local *lp);
lp162drivers/net/pi2.cstatic void a_exint(struct pi_local *lp);
lp200drivers/net/pi2.cstatic void switchbuffers(struct pi_local *lp)
lp202drivers/net/pi2.cif (lp->rcvbuf == lp->rxdmabuf1)
lp203drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf2;
lp205drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf1;
lp208drivers/net/pi2.cstatic void hardware_send_packet(struct pi_local *lp, struct sk_buff *skb)
lp213drivers/net/pi2.clp->stats.tx_packets++;
lp217drivers/net/pi2.ckickflag = (skb_peek(&lp->sndq) == NULL) && (lp->sndbuf == NULL);
lp220drivers/net/pi2.cskb_queue_tail(&lp->sndq, skb);
lp223drivers/net/pi2.cswitch (lp->base & 2) {
lp225drivers/net/pi2.ca_txint(lp);  /* process interrupt */
lp230drivers/net/pi2.cif (lp->tstate == IDLE)
lp231drivers/net/pi2.cb_txint(lp);
lp238drivers/net/pi2.cstatic void setup_rx_dma(struct pi_local *lp)
lp248drivers/net/pi2.cdma_abs = (unsigned long) (lp->rcvbuf->data);
lp249drivers/net/pi2.cdmachan = lp->dmachan;
lp250drivers/net/pi2.ccmd = lp->base + CTL;
lp256drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | WT_RDY_RT | INT_ERR_Rx | EXT_INT_ENAB);
lp266drivers/net/pi2.cset_dma_count(dmachan, lp->bufsiz);
lp272drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Rx_CRC);
lp275drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1,
lp281drivers/net/pi2.cstatic void setup_tx_dma(struct pi_local *lp, int length)
lp290drivers/net/pi2.cdmachan = lp->dmachan;
lp291drivers/net/pi2.cdma_abs = (unsigned long) (lp->txdmabuf);
lp309drivers/net/pi2.cstatic void tdelay(struct pi_local *lp, int time)
lp315drivers/net/pi2.cif (lp->base & 2) {    /* If A channel */
lp318drivers/net/pi2.cport = lp->cardbase + TMR1;
lp322drivers/net/pi2.cport = lp->cardbase + TMR2;
lp323drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R1, INT_ALL_Rx | EXT_INT_ENAB);
lp327drivers/net/pi2.coutb_p(sc | LSB_MSB | MODE0, lp->cardbase + TMRCMD);
lp334drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R15, CTSIE);
lp335drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_EXT_INT);
lp343drivers/net/pi2.cstatic void a_txint(struct pi_local *lp)
lp351drivers/net/pi2.ccmd = CTL + lp->base;
lp353drivers/net/pi2.cswitch (lp->tstate) {
lp356drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp357drivers/net/pi2.crts(lp, OFF);
lp367drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp368drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp369drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp370drivers/net/pi2.clp->tstate = DEFER;
lp371drivers/net/pi2.ctdelay(lp, 100);
lp373drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp377drivers/net/pi2.cif (random() > lp->persist) {
lp378drivers/net/pi2.clp->tstate = DEFER;
lp379drivers/net/pi2.ctdelay(lp, lp->slotime);
lp384drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp385drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp386drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp387drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp397drivers/net/pi2.cstatic void a_exint(struct pi_local *lp)
lp407drivers/net/pi2.cst = rdscc(lp->cardbase, lp->base + CTL, R0);  /* Fetch status */
lp410drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R0, RES_EXT_INT);
lp411drivers/net/pi2.ccmd = lp->base + CTL;
lp413drivers/net/pi2.cif ((lp->rstate >= ACTIVE) && (st & BRK_ABRT)) {
lp414drivers/net/pi2.csetup_rx_dma(lp);
lp415drivers/net/pi2.clp->rstate = ACTIVE;
lp417drivers/net/pi2.cswitch (lp->tstate) {
lp419drivers/net/pi2.cfree_p(lp->sndbuf);
lp420drivers/net/pi2.clp->sndbuf = NULL;
lp421drivers/net/pi2.clp->tstate = FLAGOUT;
lp422drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp425drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp427drivers/net/pi2.clp->tstate = IDLE;
lp428drivers/net/pi2.crts(lp, OFF);
lp435drivers/net/pi2.cdisable_dma(lp->dmachan);
lp438drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp443drivers/net/pi2.clength = lp->sndbuf->len - 1;
lp444drivers/net/pi2.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
lp448drivers/net/pi2.csetup_tx_dma(lp, length);
lp452drivers/net/pi2.cenable_dma(lp->dmachan);
lp455drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC | RES_Tx_P);
lp458drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
lp461drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_RDY_ENAB | WT_FN_RDYFN | EXT_INT_ENAB);
lp464drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
lp468drivers/net/pi2.clp->tstate = ACTIVE;
lp474drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp475drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp476drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp477drivers/net/pi2.clp->tstate = DEFER;
lp478drivers/net/pi2.ctdelay(lp, 100);
lp480drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R15, CTSIE | DCDIE);
lp484drivers/net/pi2.cif (random() > lp->persist) {
lp485drivers/net/pi2.clp->tstate = DEFER;
lp486drivers/net/pi2.ctdelay(lp, lp->slotime);
lp491drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp492drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp493drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp494drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp504drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp)
lp517drivers/net/pi2.ccmd = lp->base + CTL;
lp519drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* Get special condition bits from R1 */
lp521drivers/net/pi2.clp->rstate = RXERROR;
lp526drivers/net/pi2.cclear_dma_ff(lp->dmachan);
lp527drivers/net/pi2.cbytecount = lp->bufsiz - get_dma_residue(lp->dmachan);
lp529drivers/net/pi2.cif ((rse & CRC_ERR) || (lp->rstate > ACTIVE) || (bytecount < 10)) {
lp531drivers/net/pi2.clp->stats.rx_crc_errors++;
lp533drivers/net/pi2.cif (lp->rstate == RXERROR) {
lp534drivers/net/pi2.clp->stats.rx_errors++;
lp535drivers/net/pi2.clp->stats.rx_over_errors++;
lp538drivers/net/pi2.clp->rstate = ACTIVE;
lp539drivers/net/pi2.csetup_rx_dma(lp);
lp543drivers/net/pi2.cpkt_len = lp->rcvbuf->cnt = bytecount - 2 + 1;
lp546drivers/net/pi2.ccur_buf = lp->rcvbuf;
lp547drivers/net/pi2.cswitchbuffers(lp);
lp548drivers/net/pi2.csetup_rx_dma(lp);
lp557drivers/net/pi2.clp->stats.rx_dropped++;
lp573drivers/net/pi2.clp->stats.rx_packets++;
lp576drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, ERR_RES);  /* error reset */
lp580drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp)
lp592drivers/net/pi2.ccmd = CTL + lp->base;
lp594drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
lp596drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0)) & Rx_CH_AV) {
lp603drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp604drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp606drivers/net/pi2.clp->rstate = RXERROR;  /* set error flag */
lp607drivers/net/pi2.clp->stats.rx_errors++;
lp608drivers/net/pi2.clp->stats.rx_over_errors++;
lp609drivers/net/pi2.c} else if (lp->rcvbuf->cnt >= lp->bufsiz) {
lp612drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp613drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp614drivers/net/pi2.clp->rstate = TOOBIG;/* when set, chars are not stored */
lp617drivers/net/pi2.cif (lp->rstate == ACTIVE) {  /* If no errors... */
lp618drivers/net/pi2.c*lp->rcp++ = rdscc(lp->cardbase, cmd, R8);  /* char to rcv buff */
lp619drivers/net/pi2.clp->rcvbuf->cnt++;  /* bump count */
lp622drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp623drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
lp624drivers/net/pi2.clp->rstate = ACTIVE;
lp629drivers/net/pi2.cif (lp->rcvbuf->cnt > 0) {
lp630drivers/net/pi2.cif ((rse & CRC_ERR) || (lp->rstate > ACTIVE) || (lp->rcvbuf->cnt < 10)) {
lp631drivers/net/pi2.cif ((lp->rcvbuf->cnt >= 10) && (rse & CRC_ERR)) {
lp632drivers/net/pi2.clp->stats.rx_crc_errors++;
lp634drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp635drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp638drivers/net/pi2.cpkt_len = lp->rcvbuf->cnt -= 2;  /* Toss 2 crc bytes */
lp646drivers/net/pi2.clp->stats.rx_dropped++;
lp656drivers/net/pi2.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
lp661drivers/net/pi2.clp->stats.rx_packets++;
lp663drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp664drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp668drivers/net/pi2.clp->rstate = ACTIVE;  /* and clear error status */
lp674drivers/net/pi2.cstatic void b_txint(struct pi_local *lp)
lp682drivers/net/pi2.ccmd = CTL + lp->base;
lp684drivers/net/pi2.cswitch (lp->tstate) {
lp686drivers/net/pi2.clp->tstate = FLAGOUT;
lp687drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp692drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp696drivers/net/pi2.crts(lp, OFF);
lp701drivers/net/pi2.clp->txptr = lp->sndbuf->data;
lp702drivers/net/pi2.clp->txptr++;    /* Ignore KISS control byte */
lp703drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
lp708drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp709drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp710drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp711drivers/net/pi2.clp->tstate = DEFER;
lp712drivers/net/pi2.ctdelay(lp, 100);
lp714drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp718drivers/net/pi2.cif (random() > lp->persist) {
lp719drivers/net/pi2.clp->tstate = DEFER;
lp720drivers/net/pi2.ctdelay(lp, lp->slotime);
lp724drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp725drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp726drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp732drivers/net/pi2.cif (lp->txcnt--) {
lp733drivers/net/pi2.cc = *lp->txptr++;
lp735drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp739drivers/net/pi2.cfree_p(lp->sndbuf);
lp740drivers/net/pi2.clp->sndbuf = NULL;
lp741drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & 0x40)) {
lp744drivers/net/pi2.clp->stats.tx_errors++;
lp745drivers/net/pi2.clp->stats.tx_fifo_errors++;
lp746drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp747drivers/net/pi2.clp->tstate = FLAGOUT;
lp748drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp752drivers/net/pi2.clp->tstate = UNDERRUN;  /* Now we expect to underrun */
lp754drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp755drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
lp757drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
lp759drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_P);  /* reset Tx Int Pend */
lp774drivers/net/pi2.cstatic void b_exint(struct pi_local *lp)
lp781drivers/net/pi2.ccmd = CTL + lp->base;
lp784drivers/net/pi2.cst = rdscc(lp->cardbase, cmd, R0);  /* Fetch status */
lp786drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp789drivers/net/pi2.cswitch (lp->tstate) {
lp791drivers/net/pi2.cfree_p(lp->sndbuf);
lp792drivers/net/pi2.clp->sndbuf = NULL;
lp793drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp794drivers/net/pi2.clp->tstate = FLAGOUT;
lp795drivers/net/pi2.clp->stats.tx_errors++;
lp796drivers/net/pi2.clp->stats.tx_fifo_errors++;
lp797drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp801drivers/net/pi2.clp->tstate = CRCOUT;
lp806drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp810drivers/net/pi2.crts(lp, OFF);
lp811drivers/net/pi2.clp->tstate = IDLE;
lp815drivers/net/pi2.clp->txptr = lp->sndbuf->data;
lp816drivers/net/pi2.clp->txptr++;    /* Ignore KISS control byte */
lp817drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
lp819drivers/net/pi2.clp->txcnt--;
lp820drivers/net/pi2.cc = *lp->txptr++;
lp821drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
lp824drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp825drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
lp827drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
lp830drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
lp831drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
lp835drivers/net/pi2.cif (lp->txcnt) {
lp836drivers/net/pi2.clp->txcnt--;
lp837drivers/net/pi2.cc = *lp->txptr++;
lp839drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
lp841drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp847drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
lp848drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp849drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);  /* Tx/Ext ints */
lp851drivers/net/pi2.clp->tstate = ACTIVE;  /* char going out now */
lp859drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp860drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp861drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp862drivers/net/pi2.clp->tstate = DEFER;
lp863drivers/net/pi2.ctdelay(lp, 100);
lp865drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp869drivers/net/pi2.cif (random() > lp->persist) {
lp870drivers/net/pi2.clp->tstate = DEFER;
lp871drivers/net/pi2.ctdelay(lp, lp->slotime);
lp875drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp876drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp877drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp884drivers/net/pi2.clp->txcnt--;
lp885drivers/net/pi2.cc = *lp->txptr++;
lp886drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
lp889drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp890drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
lp892drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
lp895drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
lp896drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
lp900drivers/net/pi2.cif (lp->txcnt) {
lp901drivers/net/pi2.clp->txcnt--;
lp902drivers/net/pi2.cc = *lp->txptr++;
lp904drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
lp906drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp912drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
lp913drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp915drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);
lp917drivers/net/pi2.clp->tstate = ACTIVE;  /* char going out now */
lp927drivers/net/pi2.cif ((lp->rstate == ACTIVE) && (st & BRK_ABRT)) {
lp928drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp929drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp930drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp931drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp932drivers/net/pi2.clp->rcvbuf->cnt = 0;  /* rewind on DCD transition */
lp998drivers/net/pi2.cstatic void rts(struct pi_local *lp, int x)
lp1006drivers/net/pi2.ccmd = CTL + lp->base;
lp1011drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
lp1012drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Rx off */
lp1013drivers/net/pi2.clp->rstate = IDLE;
lp1016drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp1018drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);  /* No interrupts */
lp1021drivers/net/pi2.cif (!lp->clockmode) {
lp1022drivers/net/pi2.cif (lp->speed) {  /* if internally clocked */
lp1023drivers/net/pi2.cbr = lp->speed;  /* get desired speed */
lp1024drivers/net/pi2.ctc = (lp->xtal / br) - 2;  /* calc 1X BRG divisor */
lp1025drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1026drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1029drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | TxENAB | Tx8 | DTR);
lp1032drivers/net/pi2.clp->tstate = IDLE;
lp1033drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);  /*  TX off */
lp1035drivers/net/pi2.cif (!lp->clockmode) {
lp1036drivers/net/pi2.cif (lp->speed) {  /* if internally clocked */
lp1039drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
lp1040drivers/net/pi2.cbr = lp->speed;  /* get desired speed */
lp1042drivers/net/pi2.ctc = ((lp->xtal / 32) / br) - 2;
lp1043drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1044drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1046drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);
lp1048drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);
lp1052drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Make sure rx is off */
lp1053drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
lp1054drivers/net/pi2.cdummy = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
lp1055drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1056drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1058drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1061drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | Rx8);
lp1062drivers/net/pi2.clp->rstate = ACTIVE;  /* Normal state */
lp1065drivers/net/pi2.csetup_rx_dma(lp);
lp1068drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp1069drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp1070drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
lp1072drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* allow ABORT int */
lp1093drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1101drivers/net/pi2.ccmd = CTL + lp->base;
lp1107drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRA);  /* Reset channel A */
lp1108drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R2, 0xff);  /* Initialize interrupt vector */
lp1111drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRB);  /* Reset channel B */
lp1116drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);
lp1119drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
lp1122drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R4, SDLC | X1CLK);
lp1125drivers/net/pi2.cif (lp->speed) {    /* Use internal clocking */
lp1126drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
lp1127drivers/net/pi2.cif (!lp->clockmode)
lp1129drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCBR | RCDPLL | TRxCDP | TRxCOI);
lp1132drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCDPLL | RCDPLL | TRxCBR | TRxCOI);
lp1134drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
lp1136drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCTRxCP);
lp1140drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R6, 0);
lp1143drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R7, FLAG);
lp1148drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
lp1151drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* 8 bits/char */
lp1154drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);  /* BRG off, keep Pclk source */
lp1158drivers/net/pi2.cif (lp->speed) {
lp1159drivers/net/pi2.cbr = lp->speed;    /* get desired speed */
lp1160drivers/net/pi2.ctc = ((lp->xtal / 32) / br) - 2;  /* calc 32X BRG divisor */
lp1165drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1166drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1169drivers/net/pi2.crts(lp, OFF);    /* TX OFF and RX ON */
lp1171drivers/net/pi2.cif (lp->speed) {
lp1173drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSBR);
lp1176drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSRTxC);
lp1178drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);  /* SEARCH mode, keep BRG src */
lp1179drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);  /* Enable the BRG */
lp1182drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
lp1184drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* ABORT int */
lp1187drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | RxCRC_ENAB | Rx8);
lp1303drivers/net/pi2.cstruct pi_local *lp;
lp1314drivers/net/pi2.clp = (struct pi_local *) dev->priv;
lp1320drivers/net/pi2.clp->txdmabuf = get_dma_buffer(&mem_ptr);
lp1321drivers/net/pi2.clp->rxdmabuf1 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp1322drivers/net/pi2.clp->rxdmabuf2 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp1325drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf1;
lp1326drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp1327drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp1330drivers/net/pi2.cskb_queue_head_init(&lp->sndq);
lp1334drivers/net/pi2.clp->xtal = (unsigned long) SINGLE / 2;
lp1336drivers/net/pi2.clp->xtal = (unsigned long) DOUBLE / 2;
lp1337drivers/net/pi2.clp->base = dev->base_addr;
lp1338drivers/net/pi2.clp->cardbase = dev->base_addr & 0x3f0;
lp1340drivers/net/pi2.clp->speed = DEF_A_SPEED;
lp1342drivers/net/pi2.clp->txdelay = DEF_A_TXDELAY;
lp1343drivers/net/pi2.clp->persist = DEF_A_PERSIST;
lp1344drivers/net/pi2.clp->slotime = DEF_A_SLOTIME;
lp1345drivers/net/pi2.clp->squeldelay = DEF_A_SQUELDELAY;
lp1346drivers/net/pi2.clp->clockmode = DEF_A_CLOCKMODE;
lp1349drivers/net/pi2.clp->speed = DEF_B_SPEED;
lp1351drivers/net/pi2.clp->txdelay = DEF_B_TXDELAY;
lp1352drivers/net/pi2.clp->persist = DEF_B_PERSIST;
lp1353drivers/net/pi2.clp->slotime = DEF_B_SLOTIME;
lp1354drivers/net/pi2.clp->squeldelay = DEF_B_SQUELDELAY;
lp1355drivers/net/pi2.clp->clockmode = DEF_B_CLOCKMODE;
lp1357drivers/net/pi2.clp->bufsiz = DMA_BUFF_SIZE;
lp1358drivers/net/pi2.clp->tstate = IDLE;
lp1365drivers/net/pi2.clp->dmachan = dev->dma;
lp1366drivers/net/pi2.cif (lp->dmachan < 1 || lp->dmachan > 3)
lp1367drivers/net/pi2.cprintk("PI: DMA channel %d out of range\n", lp->dmachan);
lp1375drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R1, EXT_INT_ENAB);
lp1377drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
lp1380drivers/net/pi2.ctdelay(lp, 1);
lp1388drivers/net/pi2.cwrtscc(lp->cardbase, dev->base_addr + CTL, R9, FHWRES);  /* Hardware reset */
lp1390drivers/net/pi2.cwrtscc(lp->cardbase, dev->base_addr + CTL, R9, 0);
lp1459drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1472drivers/net/pi2.clp->tstate = IDLE;
lp1481drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
lp1484drivers/net/pi2.clp->open_time = jiffies;
lp1495drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1504drivers/net/pi2.chardware_send_packet(lp, skb);
lp1515drivers/net/pi2.cstruct pi_local *lp;
lp1530drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;  /* Assume channel A */
lp1531drivers/net/pi2.cwhile ((st = rdscc(lp->cardbase, pi0a.base_addr | CHANA | CTL, R3)) != 0) {
lp1534drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1535drivers/net/pi2.cb_txint(lp);
lp1538drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1539drivers/net/pi2.ca_rxint(&pi0a, lp);
lp1542drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1543drivers/net/pi2.ca_txint(lp);
lp1546drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1547drivers/net/pi2.ca_exint(lp);
lp1550drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1551drivers/net/pi2.cb_rxint(&pi0b, lp);
lp1554drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1555drivers/net/pi2.cb_exint(lp);
lp1560drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_H_IUS);
lp1570drivers/net/pi2.cstruct pi_local *lp;
lp1576drivers/net/pi2.clp = (struct pi_local *) dev->priv;
lp1580drivers/net/pi2.cdisable_dma(lp->dmachan);
lp1582drivers/net/pi2.clp->open_time = 0;
lp1588drivers/net/pi2.cwhile ((ptr = skb_dequeue(&lp->sndq)) != NULL)
lp1599drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1617drivers/net/pi2.clp->txdelay = rq.txdelay;
lp1618drivers/net/pi2.clp->persist = rq.persist;
lp1619drivers/net/pi2.clp->slotime = rq.slotime;
lp1620drivers/net/pi2.clp->squeldelay = rq.squeldelay;
lp1621drivers/net/pi2.clp->clockmode = rq.clockmode;
lp1622drivers/net/pi2.clp->speed = rq.speed;
lp1639drivers/net/pi2.cfree_dma(lp->dmachan);
lp1640drivers/net/pi2.cdev->dma = lp->dmachan = rq.dmachan;
lp1641drivers/net/pi2.cif (request_dma(lp->dmachan,"pi2")) 
lp1656drivers/net/pi2.crq.speed = lp->speed;
lp1657drivers/net/pi2.crq.txdelay = lp->txdelay;
lp1658drivers/net/pi2.crq.persist = lp->persist;
lp1659drivers/net/pi2.crq.slotime = lp->slotime;
lp1660drivers/net/pi2.crq.squeldelay = lp->squeldelay;
lp1661drivers/net/pi2.crq.clockmode = lp->clockmode;
lp1662drivers/net/pi2.crq.dmachan = lp->dmachan;
lp1679drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1681drivers/net/pi2.creturn &lp->stats;
lp127drivers/net/pt.cstatic void pt_rts(struct pt_local *lp, int x);
lp129drivers/net/pt.cstatic void pt_txisr(struct pt_local *lp);
lp130drivers/net/pt.cstatic void pt_exisr(struct pt_local *lp);
lp131drivers/net/pt.cstatic void pt_tmrisr(struct pt_local *lp);
lp135drivers/net/pt.cstatic void tdelay(struct pt_local *lp, int time);
lp136drivers/net/pt.cstatic void empty_scc(struct pt_local *lp);
lp169drivers/net/pt.cstatic void switchbuffers(struct pt_local *lp)
lp171drivers/net/pt.cif (lp->rcvbuf == lp->rxdmabuf1)
lp172drivers/net/pt.clp->rcvbuf = lp->rxdmabuf2;
lp174drivers/net/pt.clp->rcvbuf = lp->rxdmabuf1;
lp177drivers/net/pt.cstatic void hardware_send_packet(struct pt_local *lp, struct sk_buff *skb)
lp190drivers/net/pt.cif ((struct pt_local*)(&pt0b.priv) == lp)
lp199drivers/net/pt.clp->txdelay = ptr[1] * 10;
lp200drivers/net/pt.csend_kiss(dev, PARAM_TXDELAY, (u_char)(lp->txdelay/10));
lp203drivers/net/pt.clp->persist = ptr[1];
lp204drivers/net/pt.csend_kiss(dev, PARAM_PERSIST, (u_char)(lp->persist));
lp207drivers/net/pt.clp->slotime = ptr[1];
lp208drivers/net/pt.csend_kiss(dev, PARAM_SLOTTIME, (u_char)(lp->slotime/10));
lp221drivers/net/pt.clp->stats.tx_packets++;
lp225drivers/net/pt.ckickflag = (skb_peek(&lp->sndq) == NULL) && (lp->sndbuf == NULL);
lp229drivers/net/pt.cprintk("PTd hardware_send_packet(): kickflag = %d (%d).\n", kickflag, lp->base & CHANA);
lp231drivers/net/pt.cskb_queue_tail(&lp->sndq, skb);
lp234drivers/net/pt.cif (lp->dmachan)
lp236drivers/net/pt.cpt_txisr(lp);
lp240drivers/net/pt.cif (lp->tstate == IDLE)
lp241drivers/net/pt.cpt_txisr(lp); 
lp247drivers/net/pt.cstatic void setup_rx_dma(struct pt_local *lp)
lp257drivers/net/pt.cdma_abs = (unsigned long) (lp->rcvbuf->data);
lp258drivers/net/pt.cdmachan = lp->dmachan;
lp259drivers/net/pt.ccmd = lp->base + CTL;
lp265drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | WT_RDY_RT | INT_ERR_Rx | EXT_INT_ENAB);
lp275drivers/net/pt.cset_dma_count(dmachan, lp->bufsiz);
lp281drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Rx_CRC);
lp284drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1,
lp290drivers/net/pt.cstatic void setup_tx_dma(struct pt_local *lp, int length)
lp299drivers/net/pt.cdmachan = lp->dmachan;
lp300drivers/net/pt.cdma_abs = (unsigned long) (lp->txdmabuf);
lp323drivers/net/pt.cstatic void pt_loopback(struct pt_local *lp, int onoff)
lp325drivers/net/pt.cif (lp->base & CHANA) {
lp327drivers/net/pt.coutb_p(pt_sercfg |= PT_LOOPA_ON, lp->cardbase + SERIAL_CFG);
lp329drivers/net/pt.coutb_p(pt_sercfg &= ~PT_LOOPA_ON, lp->cardbase + SERIAL_CFG);
lp332drivers/net/pt.coutb_p(pt_sercfg |= PT_LOOPB_ON, lp->cardbase + SERIAL_CFG);
lp334drivers/net/pt.coutb_p(pt_sercfg &= ~PT_LOOPB_ON, lp->cardbase + SERIAL_CFG);
lp364drivers/net/pt.cstruct pt_local *lp = (struct pt_local*) dev->priv;
lp365drivers/net/pt.cregister int cmd = lp->base + CTL;
lp369drivers/net/pt.cprintk("PTd scc_init(): (%d).\n", lp->base & CHANA);
lp378drivers/net/pt.cwrtscc(lp->cardbase, cmd, R9, CHRA);    /* Reset channel A */
lp379drivers/net/pt.cwrtscc(lp->cardbase, cmd, R2, 0xff);    /* Initialise interrupt vector */
lp381drivers/net/pt.cwrtscc(lp->cardbase, cmd, R9, CHRB);    /* Reset channel B */
lp385drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, 0);
lp388drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, 0);
lp391drivers/net/pt.cwrtscc(lp->cardbase, cmd, R4, SDLC | X1CLK);
lp394drivers/net/pt.cif (lp->nrzi)
lp397drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);    
lp400drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS);    
lp404drivers/net/pt.cif (lp->speed)    /* Use internal clocking */
lp407drivers/net/pt.cwrtscc(lp->cardbase, cmd, R11, TCBR | RCDPLL | TRxCDP | TRxCOI);
lp411drivers/net/pt.cwrtscc(lp->cardbase, cmd, R11, TCTRxCP | RCRTxCP | TRxCBR);
lp412drivers/net/pt.cwrtscc(lp->cardbase,cmd, R14, 0);  /* wiz1 */
lp416drivers/net/pt.cwrtscc(lp->cardbase, cmd, R6, 0);
lp419drivers/net/pt.cwrtscc(lp->cardbase, cmd, R7, FLAG);
lp422drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
lp425drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, AUTO_ENAB | Rx8);
lp428drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
lp431drivers/net/pt.cif (lp->speed)
lp433drivers/net/pt.cbr = lp->speed;
lp434drivers/net/pt.ctc = ((lp->xtal / 32) / (br * 2)) - 2;
lp435drivers/net/pt.cwrtscc(lp->cardbase, cmd, R12, tc & 0xff);    /* lower byte */
lp436drivers/net/pt.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xff);  /* upper byte */      
lp440drivers/net/pt.cpt_rts(lp, OFF);
lp443drivers/net/pt.cif (lp->speed)
lp446drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSBR);
lp447drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);  /* SEARCH mode, keep BRG src */
lp448drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);  /* Enable the BRG */
lp451drivers/net/pt.cif (lp->base & CHANA)
lp452drivers/net/pt.coutb_p( (pt_sercfg &= ~PT_EXTCLKA), (lp->cardbase + SERIAL_CFG) );
lp454drivers/net/pt.coutb_p( (pt_sercfg &= ~PT_EXTCLKB), (lp->cardbase + SERIAL_CFG) );              
lp459drivers/net/pt.cif (lp->base & CHANA)
lp460drivers/net/pt.coutb_p( (pt_sercfg |= PT_EXTCLKA), (lp->cardbase + SERIAL_CFG) );
lp462drivers/net/pt.coutb_p( (pt_sercfg |= PT_EXTCLKB), (lp->cardbase + SERIAL_CFG) );     
lp465drivers/net/pt.cif (!lp->dmachan)  
lp466drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
lp468drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* ABORT int */
lp471drivers/net/pt.cif (lp->base & CHANA)
lp472drivers/net/pt.coutb_p( (pt_sercfg |= PT_DTRA_ON), (lp->cardbase + SERIAL_CFG) );
lp474drivers/net/pt.coutb_p( (pt_sercfg |= PT_DTRB_ON), (lp->cardbase + SERIAL_CFG) );
lp477drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | RxCRC_ENAB | AUTO_ENAB | Rx8 );
lp487drivers/net/pt.cstruct pt_local *lp = (struct pt_local*) dev->priv;
lp493drivers/net/pt.cif ( ((lp->base & CHANA) && !(pt_sercfg & PT_DTRB_ON)) ||
lp494drivers/net/pt.c(!(lp->base & CHANA) && !(pt_sercfg & PT_DTRA_ON)) ) 
lp496drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, FHWRES);
lp498drivers/net/pt.coutb_p((pt_sercfg = 0), lp->cardbase + SERIAL_CFG);
lp499drivers/net/pt.coutb_p((pt_dmacfg = 0), lp->cardbase + DMA_CFG);
lp501drivers/net/pt.cprintk("PTd chipset_init() Resetting SCC, called by ch (%d).\n", lp->base & CHANA);
lp505drivers/net/pt.cif (lp->base & CHANA) {
lp506drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, MIE | DLC | NV | CHRA);
lp507drivers/net/pt.coutb_p( (pt_sercfg &= ~PT_DTRA_ON), lp->cardbase + SERIAL_CFG);
lp509drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, MIE | DLC | NV | CHRB);
lp510drivers/net/pt.coutb_p( (pt_sercfg &= ~PT_DTRB_ON), lp->cardbase + SERIAL_CFG);       
lp638drivers/net/pt.cstatic void pt_rts(struct pt_local *lp, int x)
lp642drivers/net/pt.cint cmd = lp->base + CTL;
lp644drivers/net/pt.cprintk("PTd pt_rts(): Transmitter status will be %d (%d).\n", x, lp->base & CHANA);
lp648drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, 0);
lp649drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, AUTO_ENAB | Rx8);  /* Rx off */
lp650drivers/net/pt.clp->rstate = IDLE;
lp652drivers/net/pt.cif(lp->dmachan)
lp655drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp658drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, 0);
lp661drivers/net/pt.cif (!lp->clockmode)
lp663drivers/net/pt.cif (lp->speed)
lp665drivers/net/pt.cbr = lp->speed;
lp666drivers/net/pt.ctc = (lp->xtal / (br * 2)) - 2;
lp667drivers/net/pt.cwrtscc(lp->cardbase, cmd, R12, tc & 0xff);
lp668drivers/net/pt.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xff);
lp672drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | TxENAB | Tx8 | DTR);
lp675drivers/net/pt.clp->tstate = IDLE;
lp678drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
lp679drivers/net/pt.cif (!lp->clockmode)
lp681drivers/net/pt.cif (lp->speed)    /* internally clocked */
lp685drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
lp686drivers/net/pt.cbr = lp->speed;
lp687drivers/net/pt.ctc = ((lp->xtal / 32) / (br * 2)) - 2;
lp688drivers/net/pt.cwrtscc(lp->cardbase, cmd, R12, tc & 0xff);
lp689drivers/net/pt.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xff);
lp692drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);
lp694drivers/net/pt.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);
lp699drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, AUTO_ENAB | Rx8);
lp702drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);
lp705drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R1);
lp708drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp709drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp710drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp713drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | AUTO_ENAB | Rx8 );
lp715drivers/net/pt.clp->rstate = ACTIVE;
lp717drivers/net/pt.cif (lp->dmachan)
lp719drivers/net/pt.csetup_rx_dma(lp);
lp722drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp723drivers/net/pt.clp->rcvbuf->cnt = 0;
lp725drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, INT_ALL_Rx | EXT_INT_ENAB);
lp728drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, BRKIE );
lp770drivers/net/pt.cstruct pt_local *lp;
lp783drivers/net/pt.clp = (struct pt_local*) dev->priv;
lp789drivers/net/pt.clp->txdmabuf = get_dma_buffer(&mem_ptr);
lp790drivers/net/pt.clp->rxdmabuf1 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp791drivers/net/pt.clp->rxdmabuf2 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp794drivers/net/pt.clp->rcvbuf = lp->rxdmabuf1;
lp795drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp796drivers/net/pt.clp->rcvbuf->cnt = 0;
lp799drivers/net/pt.cskb_queue_head_init(&lp->sndq);
lp801drivers/net/pt.clp->base = dev->base_addr;
lp802drivers/net/pt.clp->cardbase = dev->base_addr & 0x3f0;
lp806drivers/net/pt.clp->xtal = XTAL;
lp809drivers/net/pt.clp->speed = DEF_A_SPEED;
lp810drivers/net/pt.clp->txdelay = DEF_A_TXDELAY;
lp811drivers/net/pt.clp->persist = DEF_A_PERSIST;
lp812drivers/net/pt.clp->slotime = DEF_A_SLOTIME;
lp813drivers/net/pt.clp->squeldelay = DEF_A_SQUELDELAY;
lp814drivers/net/pt.clp->clockmode = DEF_A_CLOCKMODE;
lp815drivers/net/pt.clp->nrzi = DEF_A_NRZI;
lp817drivers/net/pt.clp->speed = DEF_B_SPEED;
lp818drivers/net/pt.clp->txdelay = DEF_B_TXDELAY;
lp819drivers/net/pt.clp->persist = DEF_B_PERSIST;
lp820drivers/net/pt.clp->slotime = DEF_B_SLOTIME;
lp821drivers/net/pt.clp->squeldelay = DEF_B_SQUELDELAY;
lp822drivers/net/pt.clp->clockmode = DEF_B_CLOCKMODE;
lp823drivers/net/pt.clp->nrzi = DEF_B_NRZI;
lp825drivers/net/pt.clp->bufsiz = DMA_BUFF_SIZE;
lp826drivers/net/pt.clp->tstate = IDLE;
lp838drivers/net/pt.clp->dmachan = 0;
lp846drivers/net/pt.coutb_p( pt_sercfg |= PT_EI, lp->cardbase + INT_CFG);
lp850drivers/net/pt.ctdelay(lp, 1);
lp856drivers/net/pt.coutb_p( (pt_sercfg  &= ~ PT_EI), lp->cardbase + INT_CFG);            
lp926drivers/net/pt.cstruct pt_local *lp = dev->priv;
lp944drivers/net/pt.clp->tstate = IDLE;
lp953drivers/net/pt.clp->saved_RR0 = rdscc(lp->cardbase, lp->base + CTL, R0) & ~ZCOUNT;
lp958drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, MIE | NV);
lp959drivers/net/pt.coutb_p( pt_sercfg |= PT_EI, lp->cardbase + INT_CFG);    
lp962drivers/net/pt.clp->open_time = jiffies;
lp974drivers/net/pt.cstruct pt_local *lp = (struct pt_local *) dev->priv;
lp977drivers/net/pt.cprintk("PTd pt_send_packet(): (%d)\n", lp->base & CHANA);
lp986drivers/net/pt.chardware_send_packet(lp, skb);
lp998drivers/net/pt.cstruct pt_local *lp = dev->priv;
lp1002drivers/net/pt.ccmd = lp->base + CTL;
lp1009drivers/net/pt.cdisable_dma(lp->dmachan);
lp1011drivers/net/pt.clp->open_time = 0;
lp1016drivers/net/pt.cwhile ((ptr = skb_dequeue(&lp->sndq)) != NULL)
lp1022drivers/net/pt.cprintk("PTd pt_close(): Closing down channel (%d).\n", lp->base & CHANA);  
lp1033drivers/net/pt.cstruct pt_local *lp = (struct pt_local *) dev->priv;
lp1051drivers/net/pt.clp->txdelay = rq.txdelay;
lp1052drivers/net/pt.clp->persist = rq.persist;
lp1053drivers/net/pt.clp->slotime = rq.slotime;
lp1054drivers/net/pt.clp->squeldelay = rq.squeldelay;
lp1055drivers/net/pt.clp->clockmode = rq.clockmode;
lp1056drivers/net/pt.clp->speed = rq.speed;
lp1073drivers/net/pt.cfree_dma(lp->dmachan);
lp1074drivers/net/pt.cdev->dma = lp->dmachan = rq.dmachan;
lp1075drivers/net/pt.cif (request_dma(lp->dmachan,"pt")) 
lp1090drivers/net/pt.crq.speed = lp->speed;
lp1091drivers/net/pt.crq.txdelay = lp->txdelay;
lp1092drivers/net/pt.crq.persist = lp->persist;
lp1093drivers/net/pt.crq.slotime = lp->slotime;
lp1094drivers/net/pt.crq.squeldelay = lp->squeldelay;
lp1095drivers/net/pt.crq.clockmode = lp->clockmode;
lp1096drivers/net/pt.crq.dmachan = lp->dmachan;
lp1113drivers/net/pt.cstruct pt_local *lp = (struct pt_local *) dev->priv;
lp1115drivers/net/pt.creturn &lp->stats;
lp1129drivers/net/pt.cstatic void tdelay(struct pt_local *lp, int time)
lp1132drivers/net/pt.cif (!lp->dmachan)
lp1133drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R1, INT_ALL_Rx | EXT_INT_ENAB);
lp1135drivers/net/pt.cif (lp->base & CHANA) {
lp1136drivers/net/pt.coutb_p(time & 0xff, lp->cardbase + TMR1);
lp1137drivers/net/pt.coutb_p((time >> 8)&0xff, lp->cardbase + TMR1);
lp1139drivers/net/pt.coutb_p(time & 0xff, lp->cardbase + TMR2);
lp1140drivers/net/pt.coutb_p((time >> 8)&0xff, lp->cardbase + TMR2);
lp1145drivers/net/pt.cstatic void pt_txisr(struct pt_local *lp)
lp1153drivers/net/pt.ccmd = lp->base + CTL;
lp1156drivers/net/pt.cprintk("PTd pt_txisr(): tstate = %d (%d).\n", lp->tstate, lp->base & CHANA);
lp1159drivers/net/pt.cswitch (lp->tstate) 
lp1162drivers/net/pt.clp->tstate = FLAGOUT;
lp1163drivers/net/pt.ctdelay(lp, lp->squeldelay);
lp1169drivers/net/pt.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL)
lp1174drivers/net/pt.cpt_rts(lp, OFF);
lp1179drivers/net/pt.cif (!lp->dmachan)
lp1181drivers/net/pt.clp->txptr = lp->sndbuf->data;
lp1182drivers/net/pt.clp->txptr++;    /* Ignore KISS control byte */
lp1183drivers/net/pt.clp->txcnt = (int) lp->sndbuf->len - 1;
lp1190drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp1191drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp1192drivers/net/pt.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0)
lp1194drivers/net/pt.clp->tstate = DEFER;
lp1195drivers/net/pt.ctdelay(lp, 100);
lp1197drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, DCDIE);
lp1201drivers/net/pt.cif (random() > lp->persist)
lp1203drivers/net/pt.clp->tstate = DEFER;
lp1204drivers/net/pt.ctdelay(lp, lp->slotime);
lp1208drivers/net/pt.cpt_rts(lp, ON);    /* Tx on */
lp1209drivers/net/pt.cif (lp->dmachan)
lp1210drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp1211drivers/net/pt.clp->tstate = ST_TXDELAY;
lp1212drivers/net/pt.ctdelay(lp, lp->txdelay);
lp1218drivers/net/pt.cif (lp->txcnt--)
lp1223drivers/net/pt.cc = *lp->txptr++;
lp1225drivers/net/pt.cwrtscc(lp->cardbase, cmd, R8, c);
lp1229drivers/net/pt.cfree_p(lp->sndbuf);
lp1230drivers/net/pt.clp->sndbuf = NULL;
lp1231drivers/net/pt.cif ((rdscc(lp->cardbase, cmd, R0) & TxEOM))
lp1234drivers/net/pt.clp->stats.tx_errors++;
lp1235drivers/net/pt.clp->stats.tx_fifo_errors++;
lp1236drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp1237drivers/net/pt.clp->tstate = FLAGOUT;
lp1238drivers/net/pt.ctdelay(lp, lp->squeldelay);
lp1242drivers/net/pt.clp->tstate = UNDERRUN;
lp1244drivers/net/pt.cif (lp->nrzi)
lp1246drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
lp1248drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZ);
lp1251drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_P);
lp1256drivers/net/pt.cprintk("PT: pt_txisr(): Invlaid tstate (%d) for chan %s.\n", lp->tstate, (cmd & CHANA? "A": "B") );
lp1257drivers/net/pt.cpt_rts(lp, OFF);
lp1258drivers/net/pt.clp->tstate = IDLE;
lp1266drivers/net/pt.cstruct pt_local *lp = (struct pt_local*) dev->priv;
lp1267drivers/net/pt.cint cmd = lp->base + CTL;
lp1280drivers/net/pt.crse = rdscc(lp->cardbase, cmd, R1);
lp1283drivers/net/pt.cprintk("PTd pt_rxisr(): R1 = %#3x. (%d)\n", rse, lp->base & CHANA);
lp1286drivers/net/pt.cif (lp->dmachan && (rse & Rx_OVR))
lp1287drivers/net/pt.clp->rstate = RXERROR;
lp1289drivers/net/pt.cif (rdscc(lp->cardbase, cmd, R0) & Rx_CH_AV && !lp->dmachan) 
lp1298drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp1299drivers/net/pt.clp->rcvbuf->cnt = 0;
lp1300drivers/net/pt.clp->rstate = RXERROR;
lp1301drivers/net/pt.clp->stats.rx_errors++;
lp1302drivers/net/pt.clp->stats.rx_fifo_errors++;
lp1303drivers/net/pt.c} else if (lp->rcvbuf->cnt >= lp->bufsiz)
lp1308drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp1309drivers/net/pt.clp->rcvbuf->cnt = 0;
lp1310drivers/net/pt.clp->rstate = TOOBIG;
lp1313drivers/net/pt.cif (lp->rstate == ACTIVE)
lp1315drivers/net/pt.c*lp->rcp++ = rdscc(lp->cardbase, cmd, R8);
lp1316drivers/net/pt.clp->rcvbuf->cnt++;
lp1319drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp1320drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp1321drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp1324drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);
lp1325drivers/net/pt.clp->rstate = ACTIVE;
lp1328drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);
lp1336drivers/net/pt.cprintk("PTd pt_rxisr() Got end of a %u byte frame.\n", lp->rcvbuf->cnt);
lp1338drivers/net/pt.cif (lp->dmachan)
lp1340drivers/net/pt.cclear_dma_ff(lp->dmachan);
lp1341drivers/net/pt.cbytecount = lp->bufsiz - get_dma_residue(lp->dmachan);
lp1343drivers/net/pt.cbytecount = lp->rcvbuf->cnt;
lp1347drivers/net/pt.cif (lp->rcvbuf->cnt > 0 || lp->dmachan)
lp1349drivers/net/pt.cif ((rse & CRC_ERR) || (lp->rstate > ACTIVE) || (bytecount < 10))
lp1353drivers/net/pt.clp->stats.rx_crc_errors++;
lp1355drivers/net/pt.cif (lp->dmachan)
lp1357drivers/net/pt.cif (lp->rstate == RXERROR)
lp1359drivers/net/pt.clp->stats.rx_errors++;
lp1360drivers/net/pt.clp->stats.rx_over_errors++;
lp1362drivers/net/pt.clp->rstate = ACTIVE;
lp1363drivers/net/pt.csetup_rx_dma(lp);
lp1366drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp1367drivers/net/pt.clp->rcvbuf->cnt = 0;
lp1370drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);      
lp1378drivers/net/pt.cif (lp->dmachan)
lp1380drivers/net/pt.cpkt_len = lp->rcvbuf->cnt = bytecount - 2 +1;
lp1382drivers/net/pt.ccur_buf = lp->rcvbuf;
lp1383drivers/net/pt.cswitchbuffers(lp);
lp1384drivers/net/pt.csetup_rx_dma(lp);                   
lp1386drivers/net/pt.cpkt_len = lp->rcvbuf->cnt -= 2;  /* Toss 2 CRC bytes */
lp1396drivers/net/pt.clp->stats.rx_dropped++;
lp1406drivers/net/pt.cif (lp->dmachan)
lp1409drivers/net/pt.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
lp1414drivers/net/pt.clp->stats.rx_packets++;
lp1415drivers/net/pt.cif (!lp->dmachan)
lp1418drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp1419drivers/net/pt.clp->rcvbuf->cnt = 0;
lp1424drivers/net/pt.clp->rstate = ACTIVE;
lp1427drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);
lp1432drivers/net/pt.cstatic void empty_scc(struct pt_local *lp)
lp1434drivers/net/pt.cwhile( rdscc(lp->cardbase, lp->base + CTL, R0) & Rx_CH_AV) {
lp1436drivers/net/pt.c(void) inb_p(lp->base + DATA);
lp1445drivers/net/pt.cstatic void pt_tmrisr(struct pt_local *lp)
lp1450drivers/net/pt.cprintk("PTd pt_tmrisr(): tstate = %d (%d).\n", lp->tstate, lp->base & CHANA);
lp1457drivers/net/pt.cswitch (lp->tstate) 
lp1465drivers/net/pt.cpt_exisr(lp);
lp1469drivers/net/pt.cif (lp->base & CHANA)
lp1470drivers/net/pt.cprintk("PT: pt_tmrisr(): Invalid tstate %d for Channel A\n", lp->tstate);
lp1472drivers/net/pt.cprintk("PT: pt_tmrisr(): Invalid tstate %d for Channel B\n", lp->tstate);
lp1487drivers/net/pt.cstruct pt_local *lp = dev->priv;
lp1509drivers/net/pt.clp = (struct pt_local*)pt0a.priv;
lp1513drivers/net/pt.clp = (struct pt_local*)pt0a.priv;
lp1514drivers/net/pt.cpt_txisr(lp);
lp1517drivers/net/pt.clp = (struct pt_local*)pt0a.priv;
lp1518drivers/net/pt.cpt_exisr(lp);
lp1521drivers/net/pt.clp= (struct pt_local*)pt0b.priv;
lp1525drivers/net/pt.clp = (struct pt_local*)pt0b.priv;
lp1526drivers/net/pt.cpt_txisr(lp);
lp1529drivers/net/pt.clp = (struct pt_local*)pt0b.priv;
lp1530drivers/net/pt.cpt_exisr(lp);
lp1535drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_H_IUS);
lp1561drivers/net/pt.cstatic void pt_exisr(struct pt_local *lp)
lp1564drivers/net/pt.cint cmd = lp->base + CTL;
lp1573drivers/net/pt.cst = rdscc(lp->cardbase, cmd, R0);
lp1576drivers/net/pt.cprintk("PTd exisr(): R0 = %#3x tstate = %d (%d).\n", st, lp->tstate, lp->base & CHANA);
lp1579drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp1581drivers/net/pt.cif ((lp->rstate >= ACTIVE) && (st & BRK_ABRT) && lp->dmachan)
lp1583drivers/net/pt.csetup_rx_dma(lp);
lp1584drivers/net/pt.clp->rstate = ACTIVE;
lp1587drivers/net/pt.cswitch (lp->tstate)
lp1593drivers/net/pt.cfree_p(lp->sndbuf);
lp1594drivers/net/pt.clp->sndbuf = NULL;
lp1595drivers/net/pt.cif (!lp->dmachan)
lp1597drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp1598drivers/net/pt.clp->stats.tx_errors++;
lp1599drivers/net/pt.clp->stats.tx_fifo_errors++;
lp1601drivers/net/pt.clp->tstate = FLAGOUT;
lp1602drivers/net/pt.ctdelay(lp, lp->squeldelay);
lp1606drivers/net/pt.clp->tstate = CRCOUT;
lp1612drivers/net/pt.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL)
lp1615drivers/net/pt.cpt_rts(lp, OFF);
lp1616drivers/net/pt.clp->tstate = IDLE;
lp1620drivers/net/pt.cif (!lp->dmachan)
lp1622drivers/net/pt.clp->txptr = lp->sndbuf->data;
lp1623drivers/net/pt.clp->txptr++;    /* Ignore KISS control byte */
lp1624drivers/net/pt.clp->txcnt = (int) lp->sndbuf->len - 1;
lp1629drivers/net/pt.cif (lp->dmachan)
lp1632drivers/net/pt.cdisable_dma(lp->dmachan);
lp1635drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp1637drivers/net/pt.clength = lp->sndbuf->len - 1;
lp1638drivers/net/pt.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
lp1641drivers/net/pt.csetup_tx_dma(lp, length);
lp1643drivers/net/pt.cenable_dma(lp->dmachan);
lp1646drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC | RES_Tx_P);
lp1649drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
lp1652drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, WT_RDY_ENAB | WT_FN_RDYFN | EXT_INT_ENAB);
lp1655drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
lp1657drivers/net/pt.clp->tstate = ACTIVE;
lp1661drivers/net/pt.clp->txcnt--;
lp1662drivers/net/pt.cc = *lp->txptr++;
lp1664drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);
lp1667drivers/net/pt.cif (lp->nrzi)  
lp1669drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
lp1671drivers/net/pt.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZ | ABUNDER);
lp1674drivers/net/pt.cwrtscc(lp->cardbase, cmd, R8, c);
lp1677drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
lp1689drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
lp1692drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp1695drivers/net/pt.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);
lp1697drivers/net/pt.clp->tstate = ACTIVE;
lp1706drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp1707drivers/net/pt.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp1708drivers/net/pt.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0)
lp1710drivers/net/pt.clp->tstate = DEFER;
lp1711drivers/net/pt.ctdelay(lp, 100);
lp1713drivers/net/pt.cwrtscc(lp->cardbase, cmd, R15, DCDIE);
lp1717drivers/net/pt.cif (random() > lp->persist)
lp1719drivers/net/pt.clp->tstate = DEFER;
lp1720drivers/net/pt.ctdelay(lp, lp->slotime);
lp1724drivers/net/pt.cif (lp->dmachan)
lp1725drivers/net/pt.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp1726drivers/net/pt.cpt_rts(lp, ON);      /* Tx on */
lp1727drivers/net/pt.clp->tstate = ST_TXDELAY;
lp1728drivers/net/pt.ctdelay(lp, lp->txdelay);
lp1733drivers/net/pt.cif (lp->dmachan)
lp1746drivers/net/pt.cif ((lp->rstate == ACTIVE) && (st & BRK_ABRT) )
lp1752drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp1753drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);
lp1754drivers/net/pt.c(void) rdscc(lp->cardbase, cmd, R8);      
lp1756drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp1757drivers/net/pt.clp->rcvbuf->cnt = 0;
lp1760drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);      
lp1765drivers/net/pt.cif ( (st & DCD) != (lp->saved_RR0 & DCD))
lp1773drivers/net/pt.cif (lp->rcvbuf->cnt > 0)
lp1776drivers/net/pt.cprintk("PTd pt_exisr() dumping %u bytes from buffer.\n", lp->rcvbuf->cnt);
lp1779drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp1780drivers/net/pt.clp->rcvbuf->cnt = 0;
lp1785drivers/net/pt.c(void)rdscc(lp->cardbase, cmd, R8);
lp1786drivers/net/pt.c(void)rdscc(lp->cardbase, cmd, R8);
lp1787drivers/net/pt.c(void)rdscc(lp->cardbase, cmd, R8);
lp1790drivers/net/pt.clp->rcp = lp->rcvbuf->data;
lp1791drivers/net/pt.clp->rcvbuf->cnt = 0;
lp1794drivers/net/pt.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | ENT_HM | AUTO_ENAB | Rx8);      
lp1799drivers/net/pt.clp->saved_RR0 = st &~ ZCOUNT;
lp350drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp365drivers/net/seeq8005.clp->open_time = jiffies;
lp424drivers/net/seeq8005.cstruct net_local *lp;
lp437drivers/net/seeq8005.clp = (struct net_local *)dev->priv;
lp453drivers/net/seeq8005.clp->stats.tx_packets++;
lp475drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp487drivers/net/seeq8005.coutw( lp->receive_ptr, SEEQ_DMAAR);
lp494drivers/net/seeq8005.cprintk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
lp504drivers/net/seeq8005.cif (next_packet < lp->receive_ptr) {
lp505drivers/net/seeq8005.cpkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
lp507drivers/net/seeq8005.cpkt_len = next_packet - lp->receive_ptr - 4;
lp516drivers/net/seeq8005.clp->receive_ptr = next_packet;
lp523drivers/net/seeq8005.clp->stats.rx_errors++;
lp524drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_SHORT) lp->stats.rx_frame_errors++;
lp525drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_DRIB) lp->stats.rx_frame_errors++;
lp526drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_OVERSIZE) lp->stats.rx_over_errors++;
lp527drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_CRC_ERR) lp->stats.rx_crc_errors++;
lp530drivers/net/seeq8005.coutw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
lp539drivers/net/seeq8005.clp->stats.rx_dropped++;
lp559drivers/net/seeq8005.clp->stats.rx_packets++;
lp573drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp576drivers/net/seeq8005.clp->open_time = 0;
lp599drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp601drivers/net/seeq8005.creturn &lp->stats;
lp635drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp658drivers/net/seeq8005.clp->receive_ptr = (DEFAULT_TEA+1)<<8;  /* so we can find our packet_header */
lp659drivers/net/seeq8005.coutw( lp->receive_ptr, SEEQ_RPR);  /* Receive Pointer Register is set to recv buffer memory */
lp310drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp332drivers/net/skeleton.clp->open_time = jiffies;
lp346drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp390drivers/net/skeleton.clp->stats.tx_aborted_errors++;
lp403drivers/net/skeleton.cstruct net_local *lp;
lp413drivers/net/skeleton.clp = (struct net_local *)dev->priv;
lp422drivers/net/skeleton.clp->stats.tx_packets++;
lp428drivers/net/skeleton.clp->stats.tx_window_errors++;
lp440drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp452drivers/net/skeleton.clp->stats.rx_errors++;
lp453drivers/net/skeleton.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp454drivers/net/skeleton.cif (status & 0x10) lp->stats.rx_over_errors++;
lp455drivers/net/skeleton.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp456drivers/net/skeleton.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp465drivers/net/skeleton.clp->stats.rx_dropped++;
lp477drivers/net/skeleton.clp->stats.rx_packets++;
lp493drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp496drivers/net/skeleton.clp->open_time = 0;
lp528drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp533drivers/net/skeleton.clp->stats.rx_missed_errors = inw(ioaddr+1);
lp536drivers/net/skeleton.creturn &lp->stats;
lp549drivers/net/smc9194.cstruct smc_local *lp   = (struct smc_local *)dev->priv;
lp555drivers/net/smc9194.cif ( lp->saved_skb) {
lp557drivers/net/smc9194.clp->stats.tx_aborted_errors++;
lp561drivers/net/smc9194.clp->saved_skb = skb;
lp576drivers/net/smc9194.clp->saved_skb = NULL;
lp581drivers/net/smc9194.clp->packets_waiting++;
lp643drivers/net/smc9194.cstruct smc_local *lp = (struct smc_local *)dev->priv;
lp645drivers/net/smc9194.cstruct sk_buff *   skb = lp->saved_skb;
lp665drivers/net/smc9194.clp->saved_skb = NULL;
lp726drivers/net/smc9194.clp->saved_skb = NULL;
lp1286drivers/net/smc9194.cstruct smc_local *lp   = (struct smc_local *)dev->priv;
lp1352drivers/net/smc9194.clp->stats.collisions += card_stats & 0xF;
lp1355drivers/net/smc9194.clp->stats.collisions += card_stats & 0xF;
lp1369drivers/net/smc9194.clp->stats.tx_packets += lp->packets_waiting;
lp1370drivers/net/smc9194.clp->packets_waiting = 0;
lp1388drivers/net/smc9194.clp->stats.rx_errors++;
lp1389drivers/net/smc9194.clp->stats.rx_fifo_errors++;      
lp1428drivers/net/smc9194.cstruct smc_local *lp = (struct smc_local *)dev->priv;
lp1472drivers/net/smc9194.clp->stats.multicast++;
lp1483drivers/net/smc9194.clp->stats.rx_dropped++;
lp1532drivers/net/smc9194.clp->stats.rx_packets++;
lp1535drivers/net/smc9194.clp->stats.rx_errors++;
lp1537drivers/net/smc9194.cif ( status & RS_ALGNERR )  lp->stats.rx_frame_errors++;  
lp1539drivers/net/smc9194.clp->stats.rx_length_errors++;
lp1540drivers/net/smc9194.cif ( status & RS_BADCRC)  lp->stats.rx_crc_errors++;
lp1568drivers/net/smc9194.cstruct smc_local *lp = (struct smc_local *)dev->priv;
lp1589drivers/net/smc9194.clp->stats.tx_errors++;
lp1590drivers/net/smc9194.cif ( tx_status & TS_LOSTCAR ) lp->stats.tx_carrier_errors++;
lp1594drivers/net/smc9194.clp->stats.tx_window_errors++;
lp1612drivers/net/smc9194.clp->packets_waiting--;
lp1647drivers/net/smc9194.cstruct smc_local *lp = (struct smc_local *)dev->priv;
lp1649drivers/net/smc9194.creturn &lp->stats;
lp171drivers/net/sunlance.c#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
lp172drivers/net/sunlance.clp->tx_old+TX_RING_MOD_MASK-lp->tx_new:\
lp173drivers/net/sunlance.clp->tx_old - lp->tx_new-1)
lp189drivers/net/sunlance.cstatic void load_csrs (struct lance_private *lp)
lp191drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp192drivers/net/sunlance.cvolatile struct lance_init_block *ib = lp->init_block;
lp214drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *) dev->priv;
lp215drivers/net/sunlance.cvolatile struct lance_init_block *ib = lp->init_block;
lp221drivers/net/sunlance.clp->rx_new = lp->tx_new = 0;
lp222drivers/net/sunlance.clp->rx_old = lp->tx_old = 0;
lp285drivers/net/sunlance.cinit_restart_lance (struct lance_private *lp)
lp287drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp298drivers/net/sunlance.cif (lp->ledma)
lp299drivers/net/sunlance.cprintk ("dcsr=%8.8x\n", (unsigned int) lp->ledma->regs->cond_reg);
lp308drivers/net/sunlance.cif (lp->ledma)
lp309drivers/net/sunlance.clp->ledma->regs->cond_reg |= DMA_INT_ENAB;
lp317drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *) dev->priv;
lp318drivers/net/sunlance.cvolatile struct lance_init_block *ib = lp->init_block;
lp319drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp326drivers/net/sunlance.cif (i == lp->rx_new)
lp335drivers/net/sunlance.cfor (rd = &ib->brx_ring [lp->rx_new];
lp337drivers/net/sunlance.crd = &ib->brx_ring [lp->rx_new]){
lp344drivers/net/sunlance.clp->stats.rx_over_errors++;
lp345drivers/net/sunlance.clp->stats.rx_errors++;
lp349drivers/net/sunlance.cif (bits & LE_R1_BUF) lp->stats.rx_fifo_errors++;
lp350drivers/net/sunlance.cif (bits & LE_R1_CRC) lp->stats.rx_crc_errors++;
lp351drivers/net/sunlance.cif (bits & LE_R1_OFL) lp->stats.rx_over_errors++;
lp352drivers/net/sunlance.cif (bits & LE_R1_FRA) lp->stats.rx_frame_errors++;
lp353drivers/net/sunlance.cif (bits & LE_R1_EOP) lp->stats.rx_errors++;
lp359drivers/net/sunlance.clp->stats.rx_dropped++;
lp361drivers/net/sunlance.clp->rx_new = (lp->rx_new + 1) & RX_RING_MOD_MASK;
lp368drivers/net/sunlance.cmemcpy (buf, (char *) &(ib->rx_buf [lp->rx_new][0]), pkt_len);
lp371drivers/net/sunlance.clp->stats.rx_packets++;
lp376drivers/net/sunlance.clp->rx_new = (lp->rx_new + 1) & RX_RING_MOD_MASK;
lp384drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *) dev->priv;
lp385drivers/net/sunlance.cvolatile struct lance_init_block *ib = lp->init_block;
lp386drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp394drivers/net/sunlance.cj = lp->tx_old;
lp401drivers/net/sunlance.cif (status & LE_T3_RTY)  lp->stats.tx_aborted_errors++;
lp402drivers/net/sunlance.cif (status & LE_T3_CLOS) lp->stats.tx_carrier_errors++;
lp403drivers/net/sunlance.cif (status & LE_T3_LCOL) lp->stats.tx_window_errors++;
lp408drivers/net/sunlance.clp->stats.tx_fifo_errors++;
lp415drivers/net/sunlance.cload_csrs (lp);
lp416drivers/net/sunlance.cinit_restart_lance (lp);
lp420drivers/net/sunlance.clp->stats.tx_packets++;
lp424drivers/net/sunlance.clp->tx_old = (lp->tx_old+1) & TX_RING_MOD_MASK;
lp434drivers/net/sunlance.cstruct lance_private *lp;
lp438drivers/net/sunlance.clp = (struct lance_private *) dev->priv;
lp439drivers/net/sunlance.cll = lp->ll;
lp441drivers/net/sunlance.cif (lp->ledma)
lp442drivers/net/sunlance.cif (lp->ledma->regs->cond_reg & DMA_HNDL_ERROR){
lp444drivers/net/sunlance.c(unsigned int) lp->ledma->regs->cond_reg, ll->rdp); 
lp485drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp486drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp502drivers/net/sunlance.cif (lp->ledma)
lp503drivers/net/sunlance.clp->ledma->regs->dma_test = ((unsigned int) lp->init_block) & 0xff000000;
lp506drivers/net/sunlance.cload_csrs (lp);
lp512drivers/net/sunlance.cstatus = init_restart_lance (lp);
lp513drivers/net/sunlance.cif (lp->ledma)
lp514drivers/net/sunlance.clp->ledma->regs->cond_reg |= DMA_INT_ENAB;
lp528drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *) dev->priv;
lp529drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp547drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp548drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp556drivers/net/sunlance.cif (lp->ledma){
lp558drivers/net/sunlance.clp->ledma->regs->cond_reg |= DMA_RST_ENET;
lp560drivers/net/sunlance.clp->ledma->regs->cond_reg &= ~DMA_RST_ENET;
lp561drivers/net/sunlance.clp->ledma->regs->cond_reg |= DMA_INT_ENAB;
lp564drivers/net/sunlance.cload_csrs (lp);
lp569drivers/net/sunlance.cstatus = init_restart_lance (lp);
lp579drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp580drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp581drivers/net/sunlance.cvolatile struct lance_init_block *ib = lp->init_block;
lp637drivers/net/sunlance.centry = lp->tx_new & TX_RING_MOD_MASK;
lp651drivers/net/sunlance.clp->tx_new = (lp->tx_new+1) & TX_RING_MOD_MASK;
lp668drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *) dev->priv;
lp670drivers/net/sunlance.creturn &lp->stats;
lp677drivers/net/sunlance.cstruct lance_private *lp = (struct lance_private *) dev->priv;
lp678drivers/net/sunlance.cvolatile struct lance_init_block *ib = lp->init_block;
lp679drivers/net/sunlance.cvolatile struct lance_regs *ll = lp->ll;
lp690drivers/net/sunlance.cload_csrs (lp);
lp691drivers/net/sunlance.cinit_restart_lance (lp);
lp717drivers/net/sunlance.cstruct lance_private *lp;
lp770drivers/net/sunlance.clp = (struct lance_private *) dev->priv;
lp773drivers/net/sunlance.clp->init_block = (void *)
lp776drivers/net/sunlance.clp->ll = ll;
lp777drivers/net/sunlance.clp->name = lancestr;
lp778drivers/net/sunlance.clp->ledma = ledma;
lp781drivers/net/sunlance.cif ((int)(lp->init_block->brx_ring) & 0x07) {
lp450drivers/net/tulip.cstruct tulip_private *lp;
lp459drivers/net/tulip.clp = (struct tulip_private *)dev->priv;
lp481drivers/net/tulip.cint dirty_tx = lp->dirty_tx;
lp483drivers/net/tulip.cwhile (dirty_tx < lp->cur_tx) {
lp485drivers/net/tulip.cint status = lp->tx_ring[entry].status;
lp492drivers/net/tulip.clp->stats.tx_errors++;
lp493drivers/net/tulip.cif (status & 0x4104) lp->stats.tx_aborted_errors++;
lp494drivers/net/tulip.cif (status & 0x0C00) lp->stats.tx_carrier_errors++;
lp495drivers/net/tulip.cif (status & 0x0200) lp->stats.tx_window_errors++;
lp496drivers/net/tulip.cif (status & 0x0002) lp->stats.tx_fifo_errors++;
lp497drivers/net/tulip.cif (status & 0x0080) lp->stats.tx_heartbeat_errors++;
lp499drivers/net/tulip.cif (status & 0x0100) lp->stats.collisions16++;
lp503drivers/net/tulip.cif (status & 0x0001) lp->stats.tx_deferred++;
lp505drivers/net/tulip.clp->stats.collisions += (status >> 3) & 15;
lp506drivers/net/tulip.clp->stats.tx_packets++;
lp510drivers/net/tulip.cdev_kfree_skb(lp->tx_skbuff[entry], FREE_WRITE);
lp515drivers/net/tulip.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp517drivers/net/tulip.cdirty_tx, lp->cur_tx, lp->tx_full);
lp522drivers/net/tulip.cif (lp->tx_full && dev->tbusy
lp523drivers/net/tulip.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp525drivers/net/tulip.clp->tx_full = 0;
lp530drivers/net/tulip.clp->dirty_tx = dirty_tx;
lp535drivers/net/tulip.cif (csr5 & 0x0008) lp->stats.tx_errors++; /* Tx babble. */
lp537drivers/net/tulip.clp->stats.rx_errors++;
lp538drivers/net/tulip.clp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;
lp576drivers/net/tulip.cstruct tulip_private *lp = (struct tulip_private *)dev->priv;
lp577drivers/net/tulip.cint entry = lp->cur_rx % RX_RING_SIZE;
lp583drivers/net/tulip.cwhile (lp->rx_ring[entry].status >= 0) {
lp584drivers/net/tulip.cint status = lp->rx_ring[entry].status;
lp593drivers/net/tulip.clp->stats.rx_errors++; /* end of a packet.*/
lp594drivers/net/tulip.cif (status & 0x0890) lp->stats.rx_length_errors++;
lp595drivers/net/tulip.cif (status & 0x0004) lp->stats.rx_frame_errors++;
lp596drivers/net/tulip.cif (status & 0x0002) lp->stats.rx_crc_errors++;
lp597drivers/net/tulip.cif (status & 0x0001) lp->stats.rx_fifo_errors++;
lp600drivers/net/tulip.cshort pkt_len = lp->rx_ring[entry].status >> 16;
lp609drivers/net/tulip.cif (lp->rx_ring[(entry+i) % RX_RING_SIZE].status < 0)
lp613drivers/net/tulip.clp->stats.rx_dropped++;
lp614drivers/net/tulip.clp->rx_ring[entry].status = 0x80000000;
lp615drivers/net/tulip.clp->cur_rx++;
lp621drivers/net/tulip.cmemcpy(skb_put(skb,pkt_len), lp->rx_ring[entry].buffer1, pkt_len);
lp624drivers/net/tulip.clp->stats.rx_packets++;
lp627drivers/net/tulip.clp->rx_ring[entry].status = 0x80000000;
lp628drivers/net/tulip.centry = (++lp->cur_rx) % RX_RING_SIZE;
lp192drivers/net/wavelan.cnet_local  *lp;
lp196drivers/net/wavelan.clp = (net_local *)dev->priv;
lp200drivers/net/wavelan.clp->hacr &= ~HACR_INTRON;
lp201drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp211drivers/net/wavelan.cnet_local  *lp;
lp215drivers/net/wavelan.clp = (net_local *)dev->priv;
lp219drivers/net/wavelan.clp->hacr |= HACR_INTRON;
lp220drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp382drivers/net/wavelan.cnet_local  *lp;
lp387drivers/net/wavelan.clp = (net_local *)dev->priv;
lp431drivers/net/wavelan.cif (lp->promiscuous && lp->full_promiscuous)
lp448drivers/net/wavelan.cm.mmw_netw_id_l = lp->nwid[1];
lp449drivers/net/wavelan.cm.mmw_netw_id_h = lp->nwid[0];
lp459drivers/net/wavelan.cnet_local  *lp;
lp464drivers/net/wavelan.clp = (net_local *)dev->priv;
lp474drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp498drivers/net/wavelan.cnet_local  *lp;
lp504drivers/net/wavelan.clp = (net_local *)dev->priv;
lp509drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp538drivers/net/wavelan.cnet_local  *lp;
lp551drivers/net/wavelan.clp = (net_local *)dev->priv;
lp553drivers/net/wavelan.clp->nresets++;
lp556drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp570drivers/net/wavelan.cpsa_read(ioaddr, lp->hacr, 0, (unsigned char *)&psa, sizeof(psa));
lp594drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp697drivers/net/wavelan.cAC_CFG_PRM(lp->promiscuous);
lp861drivers/net/wavelan.cnet_local  *lp;
lp1016drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1020drivers/net/wavelan.cfirst_wavelan = lp;
lp1021drivers/net/wavelan.clp->prev = lp;
lp1022drivers/net/wavelan.clp->next = lp;
lp1026drivers/net/wavelan.clp->prev = first_wavelan->prev;
lp1027drivers/net/wavelan.clp->next = first_wavelan;
lp1028drivers/net/wavelan.cfirst_wavelan->prev->next = lp;
lp1029drivers/net/wavelan.cfirst_wavelan->prev = lp;
lp1031drivers/net/wavelan.clp->dev = dev;
lp1033drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp1035drivers/net/wavelan.clp->full_promiscuous = enable_full_promiscuous;
lp1036drivers/net/wavelan.clp->nwid[0] = psa.psa_nwid[0];
lp1037drivers/net/wavelan.clp->nwid[1] = psa.psa_nwid[1];
lp1039drivers/net/wavelan.clp->watchdog.function = wavelan_watchdog;
lp1040drivers/net/wavelan.clp->watchdog.data = (unsigned long)dev;
lp1073drivers/net/wavelan.cnet_local  *lp;
lp1082drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1088drivers/net/wavelan.clp->rx_head = OFFSET_RU;
lp1090drivers/net/wavelan.cfor (i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next)
lp1092drivers/net/wavelan.crx_next = (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ;
lp1107drivers/net/wavelan.clp->rx_last = rx;
lp1110drivers/net/wavelan.cobram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset), (unsigned char *)&lp->rx_head, sizeof(lp->rx_head));
lp1115drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1140drivers/net/wavelan.cnet_local  *lp;
lp1147drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1149drivers/net/wavelan.clp->tx_first_free = OFFSET_CU;
lp1150drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1196drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1210drivers/net/wavelan.clp->tx_n_in_use = 0;
lp1219drivers/net/wavelan.cnet_local  *lp;
lp1227drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1282drivers/net/wavelan.cnet_local  *lp;
lp1295drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1299drivers/net/wavelan.ctxblock = lp->tx_first_free;
lp1303drivers/net/wavelan.clp->tx_first_free += TXBLOCKZ;
lp1304drivers/net/wavelan.cif (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1305drivers/net/wavelan.clp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
lp1312drivers/net/wavelan.clp->tx_n_in_use++;
lp1357drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1358drivers/net/wavelan.clp->tx_first_in_use = txblock;
lp1360drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1365drivers/net/wavelan.cif (lp->watchdog.next == (timer_list *)0)
lp1484drivers/net/wavelan.cnet_local  *lp;
lp1488drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1499drivers/net/wavelan.cobram_read(ioaddr, lp->rx_head, (unsigned char *)&fd, sizeof(fd));
lp1526drivers/net/wavelan.clp->stats.rx_errors++;
lp1533drivers/net/wavelan.clp->stats.rx_length_errors++;
lp1539drivers/net/wavelan.clp->stats.rx_over_errors++;
lp1545drivers/net/wavelan.clp->stats.rx_fifo_errors++;
lp1551drivers/net/wavelan.clp->stats.rx_frame_errors++;
lp1557drivers/net/wavelan.clp->stats.rx_crc_errors++;
lp1643drivers/net/wavelan.clp->stats.rx_dropped++;
lp1681drivers/net/wavelan.clp->stats.rx_packets++;
lp1686drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_status), (unsigned char *)&fd.fd_status, sizeof(fd.fd_status));
lp1689drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1692drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_last, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1694drivers/net/wavelan.clp->rx_last = lp->rx_head;
lp1695drivers/net/wavelan.clp->rx_head = fd.fd_link_offset;
lp1710drivers/net/wavelan.cwavelan_complete(device *dev, unsigned short ioaddr, net_local *lp)
lp1720drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1723drivers/net/wavelan.cobram_read(ioaddr, acoff(lp->tx_first_in_use, ac_status), (unsigned char *)&tx_status, sizeof(tx_status));
lp1730drivers/net/wavelan.c--lp->tx_n_in_use;
lp1737drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1738drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1741drivers/net/wavelan.clp->tx_first_in_use += TXBLOCKZ;
lp1742drivers/net/wavelan.cif (lp->tx_first_in_use >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1743drivers/net/wavelan.clp->tx_first_in_use -= NTXBLOCKS * TXBLOCKZ;
lp1750drivers/net/wavelan.clp->stats.tx_packets++;
lp1752drivers/net/wavelan.clp->stats.collisions += ncollisions;
lp1760drivers/net/wavelan.clp->stats.tx_errors++;
lp1763drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1769drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1774drivers/net/wavelan.clp->stats.tx_fifo_errors++;
lp1779drivers/net/wavelan.clp->stats.tx_heartbeat_errors++;
lp1785drivers/net/wavelan.clp->stats.tx_aborted_errors++;
lp1803drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1817drivers/net/wavelan.cnet_local  *lp;
lp1826drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1828drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1834drivers/net/wavelan.clp->watchdog.expires = jiffies+WATCHDOG_JIFFIES;
lp1835drivers/net/wavelan.cadd_timer(&lp->watchdog);
lp1843drivers/net/wavelan.cnreaped = wavelan_complete(dev, ioaddr, lp);
lp1845drivers/net/wavelan.cprintk("%s: warning: wavelan_watchdog(): %d reaped, %d remain.\n", dev->name, nreaped, lp->tx_n_in_use);
lp1863drivers/net/wavelan.cnet_local  *lp;
lp1875drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1909drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1921drivers/net/wavelan.c(void)wavelan_complete(dev, ioaddr, lp);
lp1966drivers/net/wavelan.cnet_local  *lp;
lp1973drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1983drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp2011drivers/net/wavelan.cnet_local  *lp;
lp2013drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2015drivers/net/wavelan.creturn &lp->stats;
lp2022drivers/net/wavelan.cnet_local  *lp;
lp2028drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2035drivers/net/wavelan.clp->promiscuous = 1;
lp2053drivers/net/wavelan.clp->promiscuous = 0;
lp2071drivers/net/wavelan.cnet_local  *lp;
lp2075drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2077drivers/net/wavelan.cif (lp == (net_local *)0)
lp2095drivers/net/wavelan.clp->correct_nwid += (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l;
lp2096drivers/net/wavelan.clp->wrong_nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
lp2104drivers/net/wavelan.clp->correct_nwid,
lp2105drivers/net/wavelan.clp->wrong_nwid,
lp2109drivers/net/wavelan.clp->tx_n_in_use,
lp2110drivers/net/wavelan.clp->nresets
lp2136drivers/net/wavelan.cnet_local  *lp;
lp2138drivers/net/wavelan.clp = first_wavelan;
lp2141drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
lp2155drivers/net/wavelan.cwhile ((lp = lp->next) != first_wavelan);
lp2204drivers/net/wavelan.cwavelan_cu_show_one(device *dev, net_local *lp, int i, unsigned short p)
lp2417drivers/net/wavelan.cnet_local  *lp;
lp2419drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2432drivers/net/wavelan.cnet_local  *lp;
lp2436drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2441drivers/net/wavelan.cfor (i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++)
lp2443drivers/net/wavelan.cwavelan_cu_show_one(dev, lp, i, p);
lp2468drivers/net/wavelan.cnet_local  *lp;
lp2470drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2473drivers/net/wavelan.cprintk(" tx_n_in_use=%d,", lp->tx_n_in_use);
lp2474drivers/net/wavelan.cprintk(" hacr=0x%x,", lp->hacr);
lp2475drivers/net/wavelan.cprintk(" rx_head=0x%x,", lp->rx_head);
lp2476drivers/net/wavelan.cprintk(" rx_last=0x%x,", lp->rx_last);
lp2477drivers/net/wavelan.cprintk(" tx_first_free=0x%x,", lp->tx_first_free);
lp2478drivers/net/wavelan.cprintk(" tx_first_in_use=0x%x,", lp->tx_first_in_use);
lp437drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp443drivers/net/znet.clp->stats.tx_packets++;
lp444drivers/net/znet.clp->stats.collisions += tx_status & 0xf;
lp446drivers/net/znet.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp447drivers/net/znet.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp448drivers/net/znet.cif (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
lp449drivers/net/znet.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp452drivers/net/znet.clp->stats.tx_errors++;
lp472drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp539drivers/net/znet.clp->stats.rx_errors++;
lp540drivers/net/znet.cif (status & 0x0800) lp->stats.rx_crc_errors++;
lp541drivers/net/znet.cif (status & 0x0400) lp->stats.rx_frame_errors++;
lp542drivers/net/znet.cif (status & 0x0200) lp->stats.rx_over_errors++; /* Wrong. */
lp543drivers/net/znet.cif (status & 0x0100) lp->stats.rx_fifo_errors++;
lp544drivers/net/znet.cif (status & 0x0080) lp->stats.rx_length_errors++;
lp546drivers/net/znet.clp->stats.rx_length_errors++;
lp555drivers/net/znet.clp->stats.rx_dropped++;
lp575drivers/net/znet.clp->stats.rx_packets++;
lp621drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp623drivers/net/znet.creturn &lp->stats;
lp5drivers/scsi/eata_dma_proc.cu32 *lp, h_lp;
lp9drivers/scsi/eata_dma_proc.clp = (u32 *)p;
lp10drivers/scsi/eata_dma_proc.csp = ((short *)lp) + 1;      /* Convert Header */
lp12drivers/scsi/eata_dma_proc.clp++;
lp15drivers/scsi/eata_dma_proc.csp = (u16 *)lp;      /* Convert SubHeader */
lp17drivers/scsi/eata_dma_proc.cbp = (u8 *) lp;
lp19drivers/scsi/eata_dma_proc.clp++;
lp20drivers/scsi/eata_dma_proc.cfor (h_lp = (u32)lp; (u32)lp < h_lp + ((u32)*(bp + 3)); lp++)
lp21drivers/scsi/eata_dma_proc.c*lp = ntohl(*lp);
lp22drivers/scsi/eata_dma_proc.c}while ((u32)lp < ((u32)p) + 4 + h_sp);
lp68fs/xiafs/bitmap.cregister long * lp;
lp70fs/xiafs/bitmap.clp=(long *)bh->b_data;
lp72fs/xiafs/bitmap.c*lp++=0;
lp244fs/xiafs/inode.cdt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
lp250fs/xiafs/inode.cif ((tmp=*lp)) {
lp252fs/xiafs/inode.cif (tmp == *lp)
lp263fs/xiafs/inode.cif (*lp) {
lp268fs/xiafs/inode.c*lp = tmp;
lp278fs/xiafs/inode.cu_long *lp;
lp291fs/xiafs/inode.clp = nr + (u_long *) bh->b_data;
lp293fs/xiafs/inode.cif ((tmp=*lp)) {
lp295fs/xiafs/inode.cif (tmp == *lp) {
lp312fs/xiafs/inode.cif (*lp) {
lp317fs/xiafs/inode.c*lp = tmp;
lp40fs/xiafs/truncate.cu_long * lp;
lp49fs/xiafs/truncate.clp=i + inode->u.xiafs_i.i_zone;
lp50fs/xiafs/truncate.cif (!(tmp = *lp))
lp57fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *lp)
lp60fs/xiafs/truncate.c*lp = 0;
lp70fs/xiafs/truncate.cstatic int trunc_indirect(struct inode * inode, int addr_off, u_long * lp)
lp80fs/xiafs/truncate.cif ( !(tmp=*lp) )
lp83fs/xiafs/truncate.cif (tmp != *lp) {
lp88fs/xiafs/truncate.c*lp = 0;
lp119fs/xiafs/truncate.ctmp = *lp;
lp120fs/xiafs/truncate.c*lp = 0;
lp137fs/xiafs/truncate.cu_long * dindp, * lp;
lp140fs/xiafs/truncate.clp = &(inode->u.xiafs_i.i_dind_zone);
lp141fs/xiafs/truncate.cif (!(tmp = *lp))
lp144fs/xiafs/truncate.cif (tmp != *lp) {
lp149fs/xiafs/truncate.c*lp = 0;
lp168fs/xiafs/truncate.ctmp = *lp;
lp169fs/xiafs/truncate.c*lp = 0;
lp480include/linux/isdn.hisdn_net_local *lp;
lp1010kernel/sched.cstruct sched_param lp;
lp1019kernel/sched.cmemcpy_fromfs(&lp, param, sizeof(struct sched_param));
lp1035kernel/sched.cif (lp.sched_priority < 0 || lp.sched_priority > 99)
lp1037kernel/sched.cif ((policy == SCHED_OTHER) != (lp.sched_priority == 0))
lp1047kernel/sched.cp->rt_priority = lp.sched_priority;
lp1084kernel/sched.cstruct sched_param lp;
lp1097kernel/sched.clp.sched_priority = p->rt_priority;
lp1098kernel/sched.cmemcpy_tofs(param, &lp, sizeof(struct sched_param));
lp185net/ipv4/protocol.cstruct inet_protocol *lp = NULL;
lp209net/ipv4/protocol.cif (p->copy == 0 && lp != NULL) 
lp210net/ipv4/protocol.clp->copy = 0;
lp215net/ipv4/protocol.clp = p;