taglinefilesource code
lp40arch/i386/kernel/ldt.cunsigned long *lp;
lp76arch/i386/kernel/ldt.clp = (unsigned long *) &current->ldt[ldt_info.entry_number];
lp79arch/i386/kernel/ldt.c*lp = 0;
lp80arch/i386/kernel/ldt.c*(lp+1) = 0;
lp83arch/i386/kernel/ldt.c*lp = ((ldt_info.base_addr & 0x0000ffff) << 16) |
lp85arch/i386/kernel/ldt.c*(lp+1) = (ldt_info.base_addr & 0xff000000) |
lp158drivers/char/lp.cstruct lp_struct *lp = &lp_table[0];
lp161drivers/char/lp.cwhile (irq != lp->irq) {
lp162drivers/char/lp.cif (++lp >= lp_end)
lp166drivers/char/lp.cwake_up(&lp->lp_wait_q);
lp175drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp181drivers/char/lp.cmemcpy_fromfs(lp->lp_buffer, buf, copy_size);
lp184drivers/char/lp.cif (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
lp213drivers/char/lp.cinterruptible_sleep_on(&lp->lp_wait_q);
lp448drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp457drivers/char/lp.clp->lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
lp458drivers/char/lp.cif (!lp->lp_buffer)
lp473drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp474drivers/char/lp.clp->lp_buffer = NULL;
lp481drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp482drivers/char/lp.clp->lp_buffer = NULL;
lp328drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp341drivers/net/3c501.clp->stats.tx_errors++;
lp370drivers/net/3c501.clp->tx_pkt_start = gp_start;
lp371drivers/net/3c501.clp->collisions = 0;
lp406drivers/net/3c501.cstruct net_local *lp;
lp416drivers/net/3c501.clp = (struct net_local *)dev->priv;
lp455drivers/net/3c501.clp->stats.tx_aborted_errors++;
lp463drivers/net/3c501.coutw(lp->tx_pkt_start, GP_LOW);
lp465drivers/net/3c501.clp->stats.collisions++;
lp472drivers/net/3c501.clp->stats.tx_packets++;
lp497drivers/net/3c501.clp->stats.rx_missed_errors++;
lp499drivers/net/3c501.clp->stats.rx_length_errors++;
lp533drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp546drivers/net/3c501.clp->stats.rx_over_errors++;
lp563drivers/net/3c501.clp->stats.rx_dropped++;
lp578drivers/net/3c501.clp->stats.rx_packets++;
lp632drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp633drivers/net/3c501.creturn &lp->stats;
lp449drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp464drivers/net/3c507.cif (lp->last_restart == lp->stats.tx_packets) {
lp473drivers/net/3c507.clp->last_restart = lp->stats.tx_packets;
lp515drivers/net/3c507.cstruct net_local *lp;
lp527drivers/net/3c507.clp = (struct net_local *)dev->priv;
lp540drivers/net/3c507.cwhile (lp->tx_reap != lp->tx_head) {
lp541drivers/net/3c507.cunsigned short tx_status = shmem[lp->tx_reap>>1];
lp544drivers/net/3c507.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp548drivers/net/3c507.clp->stats.tx_packets++;
lp549drivers/net/3c507.clp->stats.collisions += tx_status & 0xf;
lp553drivers/net/3c507.clp->stats.tx_errors++;
lp554drivers/net/3c507.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp555drivers/net/3c507.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp556drivers/net/3c507.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp557drivers/net/3c507.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp560drivers/net/3c507.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp561drivers/net/3c507.clp->tx_reap += TX_BUF_SIZE;
lp562drivers/net/3c507.cif (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
lp563drivers/net/3c507.clp->tx_reap = TX_BUF_START;
lp570drivers/net/3c507.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp642drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp646drivers/net/3c507.creturn &lp->stats;
lp653drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp657drivers/net/3c507.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp683drivers/net/3c507.clp->rx_tail = cur_rxbuf;
lp690drivers/net/3c507.c(dev->mem_start + lp->rx_tail + 2);
lp692drivers/net/3c507.c*write_ptr++ = lp->rx_head;        /* Link */
lp699drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp722drivers/net/3c507.clp->tx_cmd_link = IDLELOOP + 4;
lp723drivers/net/3c507.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp758drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp760drivers/net/3c507.cushort tx_block = lp->tx_head;
lp784drivers/net/3c507.c*(ushort*)(dev->mem_start + lp->tx_cmd_link) = tx_block;
lp785drivers/net/3c507.clp->tx_cmd_link = tx_block + 20;
lp788drivers/net/3c507.clp->tx_head = tx_block + TX_BUF_SIZE;
lp789drivers/net/3c507.cif (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
lp790drivers/net/3c507.clp->tx_head = TX_BUF_START;
lp794drivers/net/3c507.cdev->name, ioaddr, length, tx_block, lp->tx_head);
lp797drivers/net/3c507.cif (lp->tx_head != lp->tx_reap)
lp804drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp806drivers/net/3c507.cushort rx_head = lp->rx_head;
lp807drivers/net/3c507.cushort rx_tail = lp->rx_tail;
lp827drivers/net/3c507.clp->stats.rx_errors++;
lp828drivers/net/3c507.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp829drivers/net/3c507.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp830drivers/net/3c507.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp831drivers/net/3c507.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp832drivers/net/3c507.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp841drivers/net/3c507.clp->stats.rx_dropped++;
lp851drivers/net/3c507.clp->stats.rx_packets++;
lp866drivers/net/3c507.clp->rx_head = rx_head;
lp867drivers/net/3c507.clp->rx_tail = rx_tail;
lp380drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp452drivers/net/3c509.cif (tx_status & 0x38) lp->stats.tx_aborted_errors++;
lp525drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp532drivers/net/3c509.creturn &lp->stats;
lp542drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp550drivers/net/3c509.clp->stats.tx_carrier_errors   += inb(ioaddr + 0);
lp551drivers/net/3c509.clp->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
lp553drivers/net/3c509.clp->stats.collisions      += inb(ioaddr + 3);
lp554drivers/net/3c509.clp->stats.tx_window_errors    += inb(ioaddr + 4);
lp555drivers/net/3c509.clp->stats.rx_fifo_errors    += inb(ioaddr + 5);
lp556drivers/net/3c509.clp->stats.tx_packets      += inb(ioaddr + 6);
lp571drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp581drivers/net/3c509.clp->stats.rx_errors++;
lp583drivers/net/3c509.ccase 0x0000:    lp->stats.rx_over_errors++; break;
lp584drivers/net/3c509.ccase 0x0800:    lp->stats.rx_length_errors++; break;
lp585drivers/net/3c509.ccase 0x1000:    lp->stats.rx_frame_errors++; break;
lp586drivers/net/3c509.ccase 0x1800:    lp->stats.rx_length_errors++; break;
lp587drivers/net/3c509.ccase 0x2000:    lp->stats.rx_frame_errors++; break;
lp588drivers/net/3c509.ccase 0x2800:    lp->stats.rx_crc_errors++; break;
lp608drivers/net/3c509.clp->stats.rx_packets++;
lp614drivers/net/3c509.clp->stats.rx_dropped++;
lp202drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp206drivers/net/apricot.clp->scb.rfd = (struct i596_rfd *)I596_NULL;
lp222drivers/net/apricot.clp->rx_tail = rfd;
lp227drivers/net/apricot.crfd->next = lp->scb.rfd;
lp228drivers/net/apricot.clp->scb.rfd = rfd;
lp232drivers/net/apricot.clp->rx_tail->next = lp->scb.rfd;
lp240drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp241drivers/net/apricot.cstruct i596_rfd *rfd = lp->scb.rfd;
lp243drivers/net/apricot.clp->rx_tail->next = (struct i596_rfd *)I596_NULL;
lp247drivers/net/apricot.clp->scb.rfd = rfd->next;
lp249drivers/net/apricot.crfd = lp->scb.rfd;
lp251drivers/net/apricot.cwhile (rfd != lp->rx_tail);
lp257drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp265drivers/net/apricot.coutw(((((int)&lp->scp) & 0xffff) | 2), ioaddr);
lp266drivers/net/apricot.coutw((((int)&lp->scp)>>16) & 0xffff, ioaddr);
lp268drivers/net/apricot.clp->last_cmd = jiffies;
lp270drivers/net/apricot.clp->scp.sysbus = 0x00440000;
lp271drivers/net/apricot.clp->scp.iscp = &(lp->iscp);
lp272drivers/net/apricot.clp->iscp.scb = &(lp->scb);
lp273drivers/net/apricot.clp->iscp.stat = 0x0001;
lp274drivers/net/apricot.clp->cmd_backlog = 0;
lp276drivers/net/apricot.clp->cmd_head = lp->scb.cmd = (struct i596_cmd *) I596_NULL;
lp284drivers/net/apricot.cwhile (lp->iscp.stat)
lp288drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp292drivers/net/apricot.clp->scb.command = 0;
lp294drivers/net/apricot.cmemcpy (lp->i596_config, init_setup, 14);
lp295drivers/net/apricot.clp->set_conf.command = CmdConfigure;
lp296drivers/net/apricot.ci596_add_cmd(dev, &lp->set_conf);
lp298drivers/net/apricot.cmemcpy (lp->eth_addr, dev->dev_addr, 6);
lp299drivers/net/apricot.clp->set_add.command = CmdSASetup;
lp300drivers/net/apricot.ci596_add_cmd(dev, &lp->set_add);
lp302drivers/net/apricot.clp->tdr.command = CmdTDR;
lp303drivers/net/apricot.ci596_add_cmd(dev, &lp->tdr);
lp306drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp310drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp314drivers/net/apricot.clp->scb.command = RX_START;
lp318drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp322drivers/net/apricot.clp->scb.status, lp->scb.command);
lp332drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp337drivers/net/apricot.cwhile ((lp->scb.rfd->stat) & STAT_C)
lp339drivers/net/apricot.cif (i596_debug >2) print_eth(lp->scb.rfd->data);
lp341drivers/net/apricot.cif ((lp->scb.rfd->stat) & STAT_OK)
lp344drivers/net/apricot.cint pkt_len = lp->scb.rfd->count & 0x3fff;
lp352drivers/net/apricot.clp->stats.rx_dropped++;
lp358drivers/net/apricot.cmemcpy(skb->data, lp->scb.rfd->data, pkt_len);
lp361drivers/net/apricot.clp->stats.rx_packets++;
lp367drivers/net/apricot.clp->stats.rx_errors++;
lp368drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0001) lp->stats.collisions++;
lp369drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0080) lp->stats.rx_length_errors++;
lp370drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0100) lp->stats.rx_over_errors++;
lp371drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0200) lp->stats.rx_fifo_errors++;
lp372drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0400) lp->stats.rx_frame_errors++;
lp373drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0800) lp->stats.rx_crc_errors++;
lp374drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x1000) lp->stats.rx_length_errors++;
lp377drivers/net/apricot.clp->scb.rfd->stat = 0;
lp378drivers/net/apricot.clp->rx_tail->cmd = 0;
lp379drivers/net/apricot.clp->rx_tail = lp->scb.rfd;
lp380drivers/net/apricot.clp->scb.rfd = lp->scb.rfd->next;
lp381drivers/net/apricot.clp->rx_tail->count = 0;
lp382drivers/net/apricot.clp->rx_tail->cmd = CMD_EOL;
lp392drivers/net/apricot.ci596_cleanup_cmd(struct i596_private *lp)
lp399drivers/net/apricot.cwhile (lp->cmd_head != (struct i596_cmd *) I596_NULL)
lp401drivers/net/apricot.cptr = lp->cmd_head;
lp403drivers/net/apricot.clp->cmd_head = lp->cmd_head->next;
lp404drivers/net/apricot.clp->cmd_backlog--;
lp415drivers/net/apricot.clp->stats.tx_errors++;
lp416drivers/net/apricot.clp->stats.tx_aborted_errors++;
lp435drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp439drivers/net/apricot.clp->scb.status, lp->scb.command);
lp443drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
lp447drivers/net/apricot.ci596_reset(struct device *dev, struct i596_private *lp, int ioaddr)
lp453drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp457drivers/net/apricot.clp->scb.status, lp->scb.command);
lp464drivers/net/apricot.clp->scb.command = CUC_ABORT|RX_ABORT;
lp470drivers/net/apricot.cwhile ((lp->scb.status, lp->scb.command) || lp->scb.command)
lp474drivers/net/apricot.clp->scb.status, lp->scb.command);
lp478drivers/net/apricot.ci596_cleanup_cmd(lp);
lp489drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp502drivers/net/apricot.cif (lp->cmd_head != (struct i596_cmd *) I596_NULL)
lp503drivers/net/apricot.clp->cmd_tail->next = cmd;
lp506drivers/net/apricot.clp->cmd_head = cmd;
lp507drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp511drivers/net/apricot.clp->scb.status, lp->scb.command);
lp515drivers/net/apricot.clp->scb.cmd = cmd;
lp516drivers/net/apricot.clp->scb.command = CUC_START;
lp519drivers/net/apricot.clp->cmd_tail = cmd;
lp520drivers/net/apricot.clp->cmd_backlog++;
lp522drivers/net/apricot.clp->cmd_head = lp->scb.cmd;
lp525drivers/net/apricot.cif (lp->cmd_backlog > 16) 
lp527drivers/net/apricot.cint tickssofar = jiffies - lp->last_cmd;
lp533drivers/net/apricot.ci596_reset(dev, lp, ioaddr);
lp578drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp591drivers/net/apricot.clp->stats.tx_errors++;
lp593drivers/net/apricot.cif (lp->last_restart == lp->stats.tx_packets) {
lp597drivers/net/apricot.ci596_reset(dev,lp, ioaddr);
lp602drivers/net/apricot.clp->scb.command = CUC_START|RX_START;
lp605drivers/net/apricot.clp->last_restart = lp->stats.tx_packets;
lp637drivers/net/apricot.clp->stats.tx_dropped++;
lp659drivers/net/apricot.clp->stats.tx_packets++;
lp688drivers/net/apricot.cstruct i596_private *lp;
lp745drivers/net/apricot.clp = (struct i596_private *)dev->priv;
lp746drivers/net/apricot.cmemset((void *)lp, 0, sizeof(struct i596_private));
lp747drivers/net/apricot.clp->scb.command = 0;
lp748drivers/net/apricot.clp->scb.cmd = (struct i596_cmd *) I596_NULL;
lp749drivers/net/apricot.clp->scb.rfd = (struct i596_rfd *)I596_NULL;
lp758drivers/net/apricot.cstruct i596_private *lp;
lp777drivers/net/apricot.clp = (struct i596_private *)dev->priv;
lp779drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp782drivers/net/apricot.cprintk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command);
lp785drivers/net/apricot.cstatus = lp->scb.status;
lp801drivers/net/apricot.cwhile ((lp->cmd_head != (struct i596_cmd *) I596_NULL) && (lp->cmd_head->status & STAT_C))
lp803drivers/net/apricot.cptr = lp->cmd_head;
lp805drivers/net/apricot.clp->cmd_head = lp->cmd_head->next;
lp806drivers/net/apricot.clp->cmd_backlog--;
lp823drivers/net/apricot.clp->stats.tx_errors++;
lp824drivers/net/apricot.cif ((ptr->status) & 0x0020) lp->stats.collisions++;
lp825drivers/net/apricot.cif (!((ptr->status) & 0x0040)) lp->stats.tx_heartbeat_errors++;
lp826drivers/net/apricot.cif ((ptr->status) & 0x0400) lp->stats.tx_carrier_errors++;
lp827drivers/net/apricot.cif ((ptr->status) & 0x0800) lp->stats.collisions++;
lp828drivers/net/apricot.cif ((ptr->status) & 0x1000) lp->stats.tx_aborted_errors++;
lp868drivers/net/apricot.clp->last_cmd = jiffies;
lp872drivers/net/apricot.cptr = lp->cmd_head;
lp873drivers/net/apricot.cwhile ((ptr != (struct i596_cmd *) I596_NULL) && (ptr != lp->cmd_tail))
lp879drivers/net/apricot.cif ((lp->cmd_head != (struct i596_cmd *) I596_NULL) && (dev->start)) ack_cmd |= CUC_START;
lp880drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
lp901drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp904drivers/net/apricot.cprintk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command);
lp907drivers/net/apricot.clp->scb.command = ack_cmd;
lp924drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp932drivers/net/apricot.cdev->name, lp->scb.status);
lp934drivers/net/apricot.clp->scb.command = CUC_ABORT|RX_ABORT;
lp937drivers/net/apricot.ci596_cleanup_cmd(lp);
lp939drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp943drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp960drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp962drivers/net/apricot.creturn &lp->stats;
lp975drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp997drivers/net/apricot.cif (lp->set_conf.next != (struct i596_cmd * ) I596_NULL) return;
lp999drivers/net/apricot.clp->i596_config[8] &= ~0x01;
lp1001drivers/net/apricot.clp->i596_config[8] |= 0x01;
lp1003drivers/net/apricot.ci596_add_cmd(dev, &lp->set_conf);
lp444drivers/net/arcnet.cstruct arcnet_local *lp;
lp538drivers/net/arcnet.clp=(struct arcnet_local *)(dev->priv);
lp572drivers/net/arcnet.clp->arcnum,lp->arcnum);
lp573drivers/net/arcnet.cif (lp->arcnum==0)
lp575drivers/net/arcnet.cif (lp->arcnum==255)
lp577drivers/net/arcnet.cdev->dev_addr[0]=lp->arcnum;
lp578drivers/net/arcnet.clp->sequence=1;
lp579drivers/net/arcnet.clp->recbuf=0;
lp815drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp851drivers/net/arcnet.clp->intx=0;
lp852drivers/net/arcnet.clp->in_txhandler=0;
lp856drivers/net/arcnet.cinit_timer(&lp->timer);
lp857drivers/net/arcnet.clp->timer.expires = TIMERval;         /* length of time */
lp858drivers/net/arcnet.clp->timer.data = (unsigned long)dev;  /* pointer to "dev" structure */
lp859drivers/net/arcnet.clp->timer.function = &arcnet_timer;    /* timer handler */
lp860drivers/net/arcnet.cadd_timer(&lp->timer);
lp875drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp887drivers/net/arcnet.cdel_timer(&lp->timer);
lp911drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp915drivers/net/arcnet.clp->intx++;
lp919drivers/net/arcnet.cinb(STATUS),lp->intx);
lp921drivers/net/arcnet.cif (dev->tbusy || lp->in_txhandler)
lp926drivers/net/arcnet.cint recbuf=lp->recbuf;
lp931drivers/net/arcnet.cif (lp->txready && (inb(STATUS)&TXFREEflag))
lp936drivers/net/arcnet.clp->intx--;
lp945drivers/net/arcnet.cstatus,tickssofar,lp->outgoing.skb,
lp946drivers/net/arcnet.clp->outgoing.numsegs,
lp947drivers/net/arcnet.clp->outgoing.segnum);
lp948drivers/net/arcnet.clp->intx--;
lp954drivers/net/arcnet.cstatus,lp->intx,tickssofar);
lp963drivers/net/arcnet.cif (lp->outgoing.skb)
lp964drivers/net/arcnet.cdev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
lp965drivers/net/arcnet.clp->outgoing.skb=NULL;
lp969drivers/net/arcnet.clp->intx=0;
lp970drivers/net/arcnet.clp->in_txhandler=0;
lp971drivers/net/arcnet.clp->txready=0;
lp972drivers/net/arcnet.clp->sending=0;
lp983drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp985drivers/net/arcnet.clp->intx--;
lp989drivers/net/arcnet.cif (lp->txready)  /* transmit already in progress! */
lp993drivers/net/arcnet.clp->txready=0;
lp1002drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp1003drivers/net/arcnet.clp->intx--;
lp1007drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1022drivers/net/arcnet.cif (lp->txready && inb(STATUS)&TXFREEflag)
lp1045drivers/net/arcnet.cif (!lp->sending)
lp1070drivers/net/arcnet.cif (lp->txready && inb(STATUS)&TXFREEflag)
lp1073drivers/net/arcnet.cif (!lp->txready)
lp1079drivers/net/arcnet.cif (!lp->sending)
lp1083drivers/net/arcnet.cif (!lp->sending)
lp1124drivers/net/arcnet.clp->intx--;
lp1125drivers/net/arcnet.clp->stats.tx_packets++;
lp1132drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1134drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1136drivers/net/arcnet.cif (lp->txready)
lp1171drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1181drivers/net/arcnet.clp->stats.tx_errors++;
lp1197drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1200drivers/net/arcnet.c(union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
lp1205drivers/net/arcnet.clp->txbuf=lp->txbuf^1;  /* XOR with 1 to alternate between 2 and 3 */
lp1215drivers/net/arcnet.cmemset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
lp1302drivers/net/arcnet.clp->stats.tx_errors++;
lp1307drivers/net/arcnet.clp->txready=lp->txbuf;  /* packet is ready for sending */
lp1319drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp1326drivers/net/arcnet.cif (!(inb(STATUS)&TXFREEflag) || !lp->txready) return;
lp1329drivers/net/arcnet.coutb(TXcmd|(lp->txready<<3),COMMAND);
lp1336drivers/net/arcnet.clp->txready=0;
lp1337drivers/net/arcnet.clp->sending++;
lp1360drivers/net/arcnet.cstruct arcnet_local *lp;
lp1367drivers/net/arcnet.clp = (struct arcnet_local *)dev->priv;
lp1410drivers/net/arcnet.cint recbuf=lp->recbuf=!lp->recbuf;
lp1427drivers/net/arcnet.cif (status&TXFREEflag && !lp->in_txhandler && lp->sending)
lp1429drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1431drivers/net/arcnet.clp->in_txhandler++;
lp1432drivers/net/arcnet.clp->sending--;
lp1439drivers/net/arcnet.cif (lp->txready)
lp1445drivers/net/arcnet.cif (lp->intx)
lp1447drivers/net/arcnet.clp->in_txhandler--;
lp1451drivers/net/arcnet.cif (!lp->outgoing.skb)
lp1457drivers/net/arcnet.cif (!lp->txready && dev->tbusy)
lp1463drivers/net/arcnet.clp->in_txhandler--;
lp1474drivers/net/arcnet.cif (lp->txready && !lp->sending)
lp1489drivers/net/arcnet.cif (!lp->txready && dev->tbusy)
lp1497drivers/net/arcnet.clp->in_txhandler--;
lp1507drivers/net/arcnet.cif (dev->start && lp->sending )
lp1521drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1542drivers/net/arcnet.clp->stats.rx_errors++;
lp1578drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp1598drivers/net/arcnet.clp->stats.rx_dropped++;
lp1676drivers/net/arcnet.clp->stats.rx_packets++;
lp1697drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp1732drivers/net/arcnet.clp->stats.rx_dropped++;
lp1742drivers/net/arcnet.clp->stats.rx_dropped++;
lp1848drivers/net/arcnet.clp->stats.rx_packets++;
lp1871drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1889drivers/net/arcnet.cinit_timer(&lp->timer);
lp1890drivers/net/arcnet.clp->timer.expires=TIMERval;
lp1891drivers/net/arcnet.cadd_timer(&lp->timer);
lp1900drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1903drivers/net/arcnet.creturn &lp->stats;
lp1916drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp1928drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp1930drivers/net/arcnet.cint delayval,recbuf=lp->recbuf;
lp1955drivers/net/arcnet.clp->arcnum=cardmem[1];  /* save address for later use */
lp1959drivers/net/arcnet.crecbuf=lp->recbuf=0;
lp1960drivers/net/arcnet.clp->txbuf=2;
lp1992drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp2046drivers/net/arcnet.chead->sequence=(lp->sequence++);
lp322drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp347drivers/net/at1700.clp->tx_started = 0;
lp348drivers/net/at1700.clp->tx_queue = 0;
lp349drivers/net/at1700.clp->tx_queue_len = 0;
lp365drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp381drivers/net/at1700.clp->stats.tx_errors++;
lp389drivers/net/at1700.clp->tx_started = 0;
lp390drivers/net/at1700.clp->tx_queue = 0;
lp391drivers/net/at1700.clp->tx_queue_len = 0;
lp416drivers/net/at1700.clp->tx_queue++;
lp417drivers/net/at1700.clp->tx_queue_len += length + 2;
lp419drivers/net/at1700.cif (lp->tx_started == 0) {
lp421drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp422drivers/net/at1700.clp->tx_queue = 0;
lp423drivers/net/at1700.clp->tx_queue_len = 0;
lp425drivers/net/at1700.clp->tx_started = 1;
lp427drivers/net/at1700.c} else if (lp->tx_queue_len < 4096 - 1502)
lp445drivers/net/at1700.cstruct net_local *lp;
lp455drivers/net/at1700.clp = (struct net_local *)dev->priv;
lp467drivers/net/at1700.clp->stats.tx_packets++;
lp468drivers/net/at1700.cif (lp->tx_queue) {
lp469drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp470drivers/net/at1700.clp->tx_queue = 0;
lp471drivers/net/at1700.clp->tx_queue_len = 0;
lp476drivers/net/at1700.clp->tx_started = 0;
lp493drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp512drivers/net/at1700.clp->stats.rx_errors++;
lp513drivers/net/at1700.cif (status & 0x08) lp->stats.rx_length_errors++;
lp514drivers/net/at1700.cif (status & 0x04) lp->stats.rx_frame_errors++;
lp515drivers/net/at1700.cif (status & 0x02) lp->stats.rx_crc_errors++;
lp516drivers/net/at1700.cif (status & 0x01) lp->stats.rx_over_errors++;
lp527drivers/net/at1700.clp->stats.rx_errors++;
lp537drivers/net/at1700.clp->stats.rx_dropped++;
lp545drivers/net/at1700.clp->stats.rx_packets++;
lp573drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp595drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp601drivers/net/at1700.creturn &lp->stats;
lp234drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp235drivers/net/atp.clp->addr_mode = CMR2h_Normal;
lp342drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp351drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp368drivers/net/atp.clp->tx_unit_busy = 0;
lp369drivers/net/atp.clp->pac_cnt_in_tx_buf = 0;
lp370drivers/net/atp.clp->saved_tx_size = 0;
lp416drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp428drivers/net/atp.clp->stats.tx_errors++;
lp462drivers/net/atp.clp->pac_cnt_in_tx_buf++;
lp463drivers/net/atp.cif (lp->tx_unit_busy == 0) {
lp465drivers/net/atp.clp->saved_tx_size = 0;         /* Redundant */
lp466drivers/net/atp.clp->re_tx = 0;
lp467drivers/net/atp.clp->tx_unit_busy = 1;
lp469drivers/net/atp.clp->saved_tx_size = length;
lp488drivers/net/atp.cstruct net_local *lp;
lp499drivers/net/atp.clp = (struct net_local *)dev->priv;
lp522drivers/net/atp.clp->stats.rx_over_errors++;
lp528drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp542drivers/net/atp.clp->stats.collisions++;
lp543drivers/net/atp.cif (++lp->re_tx > 15) {
lp544drivers/net/atp.clp->stats.tx_aborted_errors++;
lp553drivers/net/atp.clp->stats.tx_packets++;
lp554drivers/net/atp.clp->pac_cnt_in_tx_buf--;
lp555drivers/net/atp.cif ( lp->saved_tx_size) {
lp556drivers/net/atp.ctrigger_send(ioaddr, lp->saved_tx_size);
lp557drivers/net/atp.clp->saved_tx_size = 0;
lp558drivers/net/atp.clp->re_tx = 0;
lp560drivers/net/atp.clp->tx_unit_busy = 0;
lp572drivers/net/atp.clp->stats.rx_missed_errors++;
lp622drivers/net/atp.cstruct net_local *lp = (struct net_local *)atp_timed_dev->priv;
lp625drivers/net/atp.clp->stats.tx_errors++;
lp627drivers/net/atp.clp->stats.tx_dropped++;
lp629drivers/net/atp.clp->stats.collisions++;
lp631drivers/net/atp.clp->stats.rx_errors++;
lp646drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp661drivers/net/atp.clp->stats.rx_errors++;
lp676drivers/net/atp.clp->stats.rx_dropped++;
lp694drivers/net/atp.clp->stats.rx_packets++;
lp725drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp732drivers/net/atp.clp->addr_mode = CMR2h_OFF;
lp751drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp752drivers/net/atp.creturn &lp->stats;
lp764drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp766drivers/net/atp.clp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
lp767drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp314drivers/net/de4x5.c#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
lp315drivers/net/de4x5.clp->tx_old+lp->txRingSize-lp->tx_new-1:\
lp316drivers/net/de4x5.clp->tx_old               -lp->tx_new-1)
lp424drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp435drivers/net/de4x5.cif (lp->bus == PCI) {
lp447drivers/net/de4x5.crequest_region(iobase, (lp->bus == PCI ? DE4X5_PCI_TOTAL_SIZE :
lp450drivers/net/de4x5.cif (lp->bus == EISA) {
lp454drivers/net/de4x5.cprintk("%s: %s at %#3x (PCI device %d)", dev->name, name, (u_short)iobase,lp->device);
lp464drivers/net/de4x5.ctmpbus = lp->bus;
lp467drivers/net/de4x5.cstruct de4x5_private *lp;
lp479drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp481drivers/net/de4x5.clp->bus = tmpbus;
lp482drivers/net/de4x5.cstrcpy(lp->adapter_name, name);
lp494drivers/net/de4x5.clp->rx_ring[i].status = 0;
lp495drivers/net/de4x5.clp->rx_ring[i].des1 = RX_BUFF_SZ;
lp496drivers/net/de4x5.clp->rx_ring[i].buf = tmp + i * RX_BUFF_SZ;
lp497drivers/net/de4x5.clp->rx_ring[i].next = NULL;
lp503drivers/net/de4x5.clp->rxRingSize = NUM_RX_DESC;
lp504drivers/net/de4x5.clp->txRingSize = NUM_TX_DESC;
lp507drivers/net/de4x5.clp->rx_ring[lp->rxRingSize - 1].des1 |= RD_RER;
lp508drivers/net/de4x5.clp->tx_ring[lp->txRingSize - 1].des1 |= TD_TER;
lp511drivers/net/de4x5.coutl((u_long)lp->rx_ring, DE4X5_RRBA);
lp512drivers/net/de4x5.coutl((u_long)lp->tx_ring, DE4X5_TRBA);
lp557drivers/net/de4x5.cif (status) release_region(iobase, (lp->bus == PCI ? 
lp587drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp588drivers/net/de4x5.cif (lp) {
lp589drivers/net/de4x5.ckfree_s(lp->rx_ring[0].buf, RX_BUFF_SZ * NUM_RX_DESC + LWPAD);
lp604drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp614drivers/net/de4x5.cif (request_irq(dev->irq, (void *)de4x5_interrupt, 0, lp->adapter_name)) {
lp633drivers/net/de4x5.cprintk("\t0x%8.8lx  0x%8.8lx\n",(long)lp->rx_ring,(long)lp->tx_ring);
lp635drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp637drivers/net/de4x5.cprintk("0x%8.8lx  ",(long)&lp->rx_ring[i].status);
lp640drivers/net/de4x5.cprintk("...0x%8.8lx\n",(long)&lp->rx_ring[i].status);
lp642drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp644drivers/net/de4x5.cprintk("0x%8.8lx  ", (long)&lp->tx_ring[i].status);
lp647drivers/net/de4x5.cprintk("...0x%8.8lx\n", (long)&lp->tx_ring[i].status);
lp649drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp651drivers/net/de4x5.cprintk("0x%8.8lx  ",(long)lp->rx_ring[i].buf);
lp654drivers/net/de4x5.cprintk("...0x%8.8lx\n",(long)lp->rx_ring[i].buf);
lp656drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp658drivers/net/de4x5.cprintk("0x%8.8lx  ", (long)lp->tx_ring[i].buf);
lp661drivers/net/de4x5.cprintk("...0x%8.8lx\n", (long)lp->tx_ring[i].buf);
lp663drivers/net/de4x5.c(short)lp->rxRingSize, 
lp664drivers/net/de4x5.c(short)lp->txRingSize); 
lp711drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp733drivers/net/de4x5.coutl((u_long)lp->rx_ring, DE4X5_RRBA);  /* Start of RX Descriptor List */
lp734drivers/net/de4x5.coutl((u_long)lp->tx_ring, DE4X5_TRBA);  /* Start of TX Descriptor List */
lp737drivers/net/de4x5.clp->rx_new = lp->rx_old = 0;
lp738drivers/net/de4x5.clp->tx_new = lp->tx_old = 0;
lp741drivers/net/de4x5.cfor (i = 0; i < lp->rxRingSize; i++) {
lp742drivers/net/de4x5.clp->rx_ring[i].status = R_OWN;
lp746drivers/net/de4x5.cfor (i = 0; i < lp->txRingSize; i++) {
lp747drivers/net/de4x5.clp->tx_ring[i].status = 0;
lp751drivers/net/de4x5.cmemset(lp->setup_frame, 0, SETUP_FRAME_LEN);
lp754drivers/net/de4x5.cfor (pa=lp->setup_frame+offset, j=0; j<ETH_ALEN; j++) {
lp763drivers/net/de4x5.cload_packet(dev, lp->setup_frame, HASH_F | TD_SET | SETUP_FRAME_LEN, NULL);
lp770drivers/net/de4x5.cif (lp->tx_ring[lp->tx_new].status >= 0) j=1;
lp781drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp782drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp798drivers/net/de4x5.cvolatile struct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp810drivers/net/de4x5.cif (dev->tbusy || (lp->lostMedia > 3)) {
lp812drivers/net/de4x5.cif (tickssofar < 10 && !lp->lostMedia) {
lp819drivers/net/de4x5.cprintk("%s: transmit timed out, status %08x, tbusy:%d, lostMedia:%d tickssofar:%d, resetting.\n",dev->name, inl(DE4X5_STS), dev->tbusy, lp->lostMedia, tickssofar);
lp868drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize; /* Ensure a wrap */
lp888drivers/net/de4x5.cstruct de4x5_private *lp;
lp895drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp939drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp945drivers/net/de4x5.cfor (entry = lp->rx_new; lp->rx_ring[entry].status >= 0;entry = lp->rx_new) {
lp946drivers/net/de4x5.cstatus = lp->rx_ring[entry].status;
lp949drivers/net/de4x5.clp->rx_old = entry;
lp954drivers/net/de4x5.clp->stats.rx_errors++;              /* Update the error stats. */
lp955drivers/net/de4x5.cif (status & (RD_RF | RD_TL)) lp->stats.rx_frame_errors++;
lp956drivers/net/de4x5.cif (status & RD_CE)           lp->stats.rx_crc_errors++;
lp957drivers/net/de4x5.cif (status & RD_OF)           lp->stats.rx_fifo_errors++;
lp960drivers/net/de4x5.cshort pkt_len = (short)(lp->rx_ring[entry].status >> 16);
lp966drivers/net/de4x5.cif (entry < lp->rx_old) {         /* Wrapped buffer */
lp967drivers/net/de4x5.cshort len = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
lp968drivers/net/de4x5.cmemcpy(skb->data, lp->rx_ring[lp->rx_old].buf, len);
lp969drivers/net/de4x5.cmemcpy(skb->data + len, lp->rx_ring[0].buf, pkt_len - len);
lp971drivers/net/de4x5.cmemcpy(skb->data, lp->rx_ring[lp->rx_old].buf, pkt_len);
lp983drivers/net/de4x5.clp->stats.rx_packets++;
lp986drivers/net/de4x5.clp->pktStats.bins[i]++;
lp993drivers/net/de4x5.clp->pktStats.broadcast++;
lp995drivers/net/de4x5.clp->pktStats.multicast++;
lp999drivers/net/de4x5.clp->pktStats.unicast++;
lp1002drivers/net/de4x5.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1003drivers/net/de4x5.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1004drivers/net/de4x5.cmemset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
lp1008drivers/net/de4x5.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1014drivers/net/de4x5.cfor (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)%lp->rxRingSize) {
lp1015drivers/net/de4x5.clp->rx_ring[lp->rx_old].status = R_OWN;
lp1017drivers/net/de4x5.clp->rx_ring[entry].status = R_OWN;
lp1023drivers/net/de4x5.clp->rx_new = (++lp->rx_new) % lp->rxRingSize;
lp1035drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1039drivers/net/de4x5.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
lp1040drivers/net/de4x5.cstatus = lp->tx_ring[entry].status;
lp1044drivers/net/de4x5.clp->stats.tx_errors++; 
lp1045drivers/net/de4x5.cif (status & TD_NC)  lp->stats.tx_carrier_errors++;
lp1046drivers/net/de4x5.cif (status & TD_LC)  lp->stats.tx_window_errors++;
lp1047drivers/net/de4x5.cif (status & TD_UF)  lp->stats.tx_fifo_errors++;
lp1048drivers/net/de4x5.cif (status & TD_LC)  lp->stats.collisions++;
lp1049drivers/net/de4x5.cif (status & TD_EC)  lp->pktStats.excessive_collisions++;
lp1050drivers/net/de4x5.cif (status & TD_DE)  lp->stats.tx_aborted_errors++;
lp1053drivers/net/de4x5.clp->lostMedia++;
lp1058drivers/net/de4x5.clp->stats.tx_packets++;
lp1059drivers/net/de4x5.clp->lostMedia = 0;                         /* Remove transient problem */
lp1062drivers/net/de4x5.cif (lp->skb[entry] != NULL) {
lp1063drivers/net/de4x5.cdev_kfree_skb(lp->skb[entry], FREE_WRITE);
lp1067drivers/net/de4x5.clp->tx_old = (++lp->tx_old) % lp->txRingSize;
lp1076drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1109drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1112drivers/net/de4x5.clp->stats.rx_missed_errors = (int) inl(DE4X5_MFC);
lp1114drivers/net/de4x5.creturn &lp->stats;
lp1119drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1121drivers/net/de4x5.clp->tx_ring[lp->tx_new].buf = buf;
lp1122drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 &= TD_TER;
lp1123drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 |= flags;
lp1124drivers/net/de4x5.clp->skb[lp->tx_new] = skb;
lp1125drivers/net/de4x5.clp->tx_ring[lp->tx_new].status = T_OWN;
lp1141drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1150drivers/net/de4x5.cSetMulticastFilter(dev, num_addrs, (char *)addrs, lp->setup_frame);
lp1153drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp1155drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1230drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1235drivers/net/de4x5.clp->bus = EISA;
lp1278drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1283drivers/net/de4x5.clp->bus = PCI;
lp1305drivers/net/de4x5.clp->device = dev_num;
lp1459drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1496drivers/net/de4x5.centry = lp->tx_new;                        /* Remember the ring position */
lp1504drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1505drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp1513drivers/net/de4x5.cif (lp->tx_ring[entry].status >= 0) linkBad=0;
lp1518drivers/net/de4x5.cif (linkBad || (lp->tx_ring[entry].status & TD_ES)) {
lp1530drivers/net/de4x5.centry = lp->tx_new;                      /* Remember the ring position */
lp1538drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1539drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp1547drivers/net/de4x5.cif (lp->tx_ring[entry].status >= 0) linkBad=0;
lp1552drivers/net/de4x5.cif (linkBad || (lp->tx_ring[entry].status & TD_ES)) {
lp1571drivers/net/de4x5.cif (media) lp->lostMedia = 0;
lp1712drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1719drivers/net/de4x5.cif (lp->bus == PCI) {
lp1749drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1755drivers/net/de4x5.cif (lp->bus == PCI) {
lp1773drivers/net/de4x5.cif (lp->bus == PCI) {
lp1794drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1830drivers/net/de4x5.cfor (pa=lp->setup_frame+offset, i=0; i<ETH_ALEN; i++) {
lp1836drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp1838drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1874drivers/net/de4x5.cmemcpy_tofs(ioc->data, lp->setup_frame, 192); 
lp1909drivers/net/de4x5.cmemcpy_tofs(ioc->data, &lp->pktStats, sizeof(lp->pktStats)); 
lp1917drivers/net/de4x5.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1959drivers/net/de4x5.ctmp.addr[j++] = lp->rxRingSize;
lp1960drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->rx_ring; j+=4;
lp1961drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->tx_ring; j+=4;
lp1963drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp1965drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp1968drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp1969drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp1971drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp1974drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp1976drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp1978drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->rx_ring[i].buf; j+=4;
lp1981drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->rx_ring[i].buf; j+=4;
lp1982drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp1984drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->tx_ring[i].buf; j+=4;
lp1987drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->tx_ring[i].buf; j+=4;
lp1989drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize;i++){
lp1990drivers/net/de4x5.ctmp.lval[j>>2] = lp->rx_ring[i].status; j+=4;
lp1992drivers/net/de4x5.cfor (i=0;i<lp->txRingSize;i++){
lp1993drivers/net/de4x5.ctmp.lval[j>>2] = lp->tx_ring[i].status; j+=4;
lp2005drivers/net/de4x5.ctmp.addr[j++] = lp->txRingSize;
lp2043drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *) thisDE4X5.priv;
lp2048drivers/net/de4x5.crelease_region(thisDE4X5.base_addr, (lp->bus == PCI ? 
lp2051drivers/net/de4x5.cif (lp) {
lp2052drivers/net/de4x5.ckfree_s(lp->rx_ring[0].buf, RX_BUFF_SZ * NUM_RX_DESC + LWPAD);
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_DDR    iobase+(0x050 << lp->bus)  /* Data Diagnostic Register */
lp27drivers/net/de4x5.h#define DE4X5_FDR    iobase+(0x058 << lp->bus)  /* Full Duplex Register */
lp28drivers/net/de4x5.h#define DE4X5_SISR   iobase+(0x060 << lp->bus)  /* SIA Status Register */
lp29drivers/net/de4x5.h#define DE4X5_SICR   iobase+(0x068 << lp->bus)  /* SIA Connectivity Register */
lp30drivers/net/de4x5.h#define DE4X5_STRR   iobase+(0x070 << lp->bus)  /* SIA TX/RX Register */
lp31drivers/net/de4x5.h#define DE4X5_SIGR   iobase+(0x078 << lp->bus)  /* SIA General Register */
lp415drivers/net/depca.cstruct depca_private *lp;
lp561drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp563drivers/net/depca.cstrcpy(lp->devname,name);
lp569drivers/net/depca.clp->rx_ring = (struct depca_rx_head *)mem_start;
lp572drivers/net/depca.clp->tx_ring = (struct depca_tx_head *)mem_start;
lp575drivers/net/depca.clp->bus_offset = mem_start & 0x00ff0000;
lp578drivers/net/depca.clp->dma_buffs = mem_start;
lp584drivers/net/depca.cmemset(lp->rx_ring, 0, sizeof(struct depca_rx_head)*j);
lp585drivers/net/depca.cmemset(lp->tx_ring, 0, sizeof(struct depca_tx_head)*j);
lp588drivers/net/depca.cif ((long)(lp->rx_ring) & 0x07) {
lp596drivers/net/depca.clp->ringSize = j;
lp597drivers/net/depca.cif (lp->ringSize > RING_SIZE) lp->ringSize = RING_SIZE;
lp598drivers/net/depca.clp->rmask = lp->ringSize - 1;
lp604drivers/net/depca.cfor (i=0, j = lp->ringSize; j>1; i++) {
lp607drivers/net/depca.clp->rlen = (unsigned long)(i << 29);
lp681drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp700drivers/net/depca.cif (strstr(lp->devname,"DEPCA") == NULL) {
lp714drivers/net/depca.cprintk("\t0x%8.8lx  0x%8.8lx\n",(long)lp->rx_ring,(long)lp->tx_ring);
lp716drivers/net/depca.cfor (i=0;i<lp->ringSize;i++){
lp717drivers/net/depca.cprintk("\t0x%8.8lx  0x%8.8lx\n",(long)&lp->rx_ring[i].base,
lp718drivers/net/depca.c(long)&lp->tx_ring[i].base);
lp721drivers/net/depca.cfor (i=0;i<lp->ringSize;i++){
lp722drivers/net/depca.cprintk("\t0x%8.8lx  0x%8.8lx\n",(long)lp->rx_ring[i].base,
lp723drivers/net/depca.c(long)lp->tx_ring[i].base);
lp725drivers/net/depca.cprintk("Initialisation block at 0x%8.8lx\n",(long)&lp->init_block);
lp726drivers/net/depca.cprintk("\tmode: 0x%4.4x\n",lp->init_block.mode);
lp729drivers/net/depca.cprintk("%2.2x:",(short)lp->init_block.phys_addr[i]);
lp733drivers/net/depca.cprintk("%2.2x",(short)lp->init_block.filter[i]);
lp735drivers/net/depca.cprintk("\n\trx_ring at: 0x%8.8lx\n",(long)lp->init_block.rx_ring);
lp736drivers/net/depca.cprintk("\ttx_ring at: 0x%8.8lx\n",(long)lp->init_block.tx_ring);
lp737drivers/net/depca.cprintk("dma_buffs: 0x%8.8lx\n",(long)lp->dma_buffs);
lp739drivers/net/depca.c(short)lp->ringSize, 
lp740drivers/net/depca.c(char)lp->rmask,
lp741drivers/net/depca.c(long)lp->rlen);
lp777drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp780drivers/net/depca.clp->init_block.mode = DTX | DRX;       /* Disable Rx and Tx. */
lp781drivers/net/depca.clp->cur_rx = lp->cur_tx = 0;
lp782drivers/net/depca.clp->dirty_rx = lp->dirty_tx = 0;
lp785drivers/net/depca.cfor (i = 0; i < lp->ringSize; i++) {
lp786drivers/net/depca.clp->rx_ring[i].base = (lp->dma_buffs + i*PKT_BUF_SZ) | R_OWN;
lp787drivers/net/depca.clp->rx_ring[i].buf_length = -PKT_BUF_SZ;
lp788drivers/net/depca.clp->tx_ring[i].base = (lp->dma_buffs + (i+lp->ringSize) * PKT_BUF_SZ) &
lp794drivers/net/depca.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp797drivers/net/depca.clp->init_block.filter[i] = 0x0000;
lp799drivers/net/depca.clp->init_block.rx_ring = ((unsigned long)lp->rx_ring & LA_MASK) | lp->rlen;
lp800drivers/net/depca.clp->init_block.tx_ring = ((unsigned long)lp->tx_ring & LA_MASK) | lp->rlen;
lp802drivers/net/depca.clp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */ 
lp811drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp861drivers/net/depca.cint entry = lp->cur_tx++;
lp866drivers/net/depca.centry &= lp->rmask;          /* Ring around buffer number. */
lp867drivers/net/depca.cbuf = (unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) & 
lp871drivers/net/depca.cwhile (lp->tx_ring[entry].base < 0);
lp880drivers/net/depca.clp->tx_ring[entry].length = -len;
lp883drivers/net/depca.clp->tx_ring[entry].misc = 0x0000;
lp889drivers/net/depca.cif (skbL <= 0) lp->tx_ring[entry].base |= (T_ENP);
lp890drivers/net/depca.clp->tx_ring[entry].base |= (T_OWN|T_STP);
lp901drivers/net/depca.centry = lp->cur_tx++;
lp902drivers/net/depca.centry &= lp->rmask;          /* Ring around buffer number. */
lp903drivers/net/depca.cbuf = (unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) &
lp907drivers/net/depca.cwhile (lp->tx_ring[entry].base < 0);
lp917drivers/net/depca.clp->tx_ring[entry].length = -len;
lp920drivers/net/depca.clp->tx_ring[entry].misc = 0x0000;
lp926drivers/net/depca.cif (skbL <= 0) lp->tx_ring[entry].base |= T_ENP;
lp927drivers/net/depca.clp->tx_ring[entry].base |= T_OWN;
lp932drivers/net/depca.c(unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) &
lp936drivers/net/depca.cdev->name, entry, (unsigned long) &lp->tx_ring[entry],
lp937drivers/net/depca.clp->tx_ring[entry].base, -lp->tx_ring[entry].length);
lp945drivers/net/depca.cif (lp->tx_ring[(entry+1) & lp->rmask].base >= 0) {
lp962drivers/net/depca.cstruct depca_private *lp;
lp968drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp1019drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1020drivers/net/depca.cint entry = lp->cur_rx & lp->rmask;
lp1023drivers/net/depca.cfor (; lp->rx_ring[entry].base >= 0; entry = (++lp->cur_rx) & lp->rmask) {
lp1024drivers/net/depca.cint status = lp->rx_ring[entry].base >> 16 ;
lp1044drivers/net/depca.cwhile ((status=(lp->rx_ring[(entry+1)&lp->rmask].base >> 16)) < 0);
lp1050drivers/net/depca.clp->stats.rx_errors++;             /* Update the error stats. */
lp1051drivers/net/depca.cif (status & R_FRAM) lp->stats.rx_frame_errors++;
lp1052drivers/net/depca.cif (status & R_OFLO) lp->stats.rx_over_errors++;
lp1053drivers/net/depca.cif (status & R_CRC)  lp->stats.rx_crc_errors++;
lp1054drivers/net/depca.cif (status & R_BUFF) lp->stats.rx_fifo_errors++;
lp1056drivers/net/depca.cshort pkt_len = lp->rx_ring[entry].msg_length;
lp1062drivers/net/depca.clp->stats.rx_dropped++;  /* Really, deferred. */
lp1068drivers/net/depca.c(unsigned char *)((lp->rx_ring[entry].base+lp->bus_offset) &
lp1076drivers/net/depca.clp->stats.rx_packets++;
lp1080drivers/net/depca.clp->rx_ring[entry].base |= R_OWN;
lp1082drivers/net/depca.centry = (++lp->cur_rx) & lp->rmask;
lp1083drivers/net/depca.clp->rx_ring[entry].base |= R_OWN;
lp1101drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1102drivers/net/depca.cint dirty_tx = lp->dirty_tx & lp->rmask;
lp1106drivers/net/depca.cdev->name, dirty_tx, (lp->cur_tx & lp->rmask));
lp1112drivers/net/depca.cfor (; dirty_tx!=(lp->cur_tx & lp->rmask) && lp->tx_ring[dirty_tx].base>0;
lp1113drivers/net/depca.cdirty_tx = ++lp->dirty_tx & lp->rmask) {
lp1114drivers/net/depca.cunsigned long *tmdp = (unsigned long *)(&lp->tx_ring[dirty_tx]);
lp1115drivers/net/depca.cint status = lp->tx_ring[dirty_tx].base >> 16;
lp1122drivers/net/depca.cint err_status = lp->tx_ring[dirty_tx].misc;
lp1124drivers/net/depca.clp->stats.tx_errors++;
lp1125drivers/net/depca.cif (err_status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
lp1126drivers/net/depca.cif (err_status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
lp1127drivers/net/depca.cif (err_status & TMD3_LCOL) lp->stats.tx_window_errors++;
lp1128drivers/net/depca.cif (err_status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
lp1131drivers/net/depca.clp->stats.collisions++;
lp1133drivers/net/depca.clp->stats.tx_packets++;
lp1148drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1170drivers/net/depca.cif (strstr(lp->devname,"DEPCA") == NULL) {
lp1187drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1191drivers/net/depca.coutw((unsigned short)((unsigned long)(&lp->init_block) & LA_MASK), 
lp1194drivers/net/depca.coutw((unsigned short)(((unsigned long)(&lp->init_block) & LA_MASK) >> 16), 
lp1203drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1218drivers/net/depca.cdev->name, i, (long) &lp->init_block, inw(DEPCA_DATA));
lp1223drivers/net/depca.cdev->name, i, (long) &lp->init_block, inw(DEPCA_DATA));
lp1232drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1236drivers/net/depca.creturn &lp->stats;
lp1247drivers/net/depca.c#define hash_filter lp->init_block.filter
lp1253drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1261drivers/net/depca.clp->init_block.mode &= ~PROM;   /* Unset promiscuous mode */
lp1263drivers/net/depca.clp->init_block.mode |= PROM;    /* Set promiscuous mode */
lp454drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp467drivers/net/eexpress.clp->stats.tx_errors++;
lp469drivers/net/eexpress.cif (lp->last_restart == lp->stats.tx_packets) {
lp478drivers/net/eexpress.clp->last_restart = lp->stats.tx_packets;
lp510drivers/net/eexpress.clp->stats.tx_aborted_errors++;
lp521drivers/net/eexpress.cstruct net_local *lp;
lp532drivers/net/eexpress.clp = (struct net_local *)dev->priv;
lp544drivers/net/eexpress.cwhile (lp->tx_reap != lp->tx_head) {   /* if (status & 0x8000) */
lp546drivers/net/eexpress.coutw(lp->tx_reap, ioaddr + READ_PTR);
lp549drivers/net/eexpress.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp553drivers/net/eexpress.clp->stats.tx_packets++;
lp554drivers/net/eexpress.clp->stats.collisions += tx_status & 0xf;
lp558drivers/net/eexpress.clp->stats.tx_errors++;
lp559drivers/net/eexpress.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp560drivers/net/eexpress.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp561drivers/net/eexpress.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp562drivers/net/eexpress.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp565drivers/net/eexpress.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp566drivers/net/eexpress.clp->tx_reap += TX_BUF_SIZE;
lp567drivers/net/eexpress.cif (lp->tx_reap > TX_BUF_END - TX_BUF_SIZE)
lp568drivers/net/eexpress.clp->tx_reap = TX_BUF_START;
lp575drivers/net/eexpress.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp594drivers/net/eexpress.clp->tx_cmd_link = IDLELOOP + 4;
lp595drivers/net/eexpress.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp605drivers/net/eexpress.clp->stats.rx_errors++;
lp609drivers/net/eexpress.cdev->name, status, lp->rx_head, lp->rx_tail);
lp673drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp677drivers/net/eexpress.creturn &lp->stats;
lp757drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp777drivers/net/eexpress.clp->tx_cmd_link = DUMP_DATA + 4;
lp779drivers/net/eexpress.clp->tx_cmd_link = IDLELOOP + 4;
lp781drivers/net/eexpress.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp815drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp818drivers/net/eexpress.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp842drivers/net/eexpress.clp->rx_tail = cur_rxbuf;
lp848drivers/net/eexpress.coutw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
lp850drivers/net/eexpress.coutw(lp->rx_head, ioaddr);        /* Link */
lp856drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp858drivers/net/eexpress.cshort tx_block = lp->tx_head;
lp883drivers/net/eexpress.coutw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
lp885drivers/net/eexpress.clp->tx_cmd_link = tx_block + 20;
lp888drivers/net/eexpress.clp->tx_head = tx_block + TX_BUF_SIZE;
lp889drivers/net/eexpress.cif (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
lp890drivers/net/eexpress.clp->tx_head = TX_BUF_START;
lp895drivers/net/eexpress.ctx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
lp898drivers/net/eexpress.cif (lp->tx_head != lp->tx_reap)
lp905drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp908drivers/net/eexpress.cshort rx_head = lp->rx_head;
lp909drivers/net/eexpress.cshort rx_tail = lp->rx_tail;
lp933drivers/net/eexpress.clp->stats.rx_errors++;
lp934drivers/net/eexpress.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp935drivers/net/eexpress.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp936drivers/net/eexpress.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp937drivers/net/eexpress.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp938drivers/net/eexpress.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp947drivers/net/eexpress.clp->stats.rx_dropped++;
lp958drivers/net/eexpress.clp->stats.rx_packets++;
lp995drivers/net/eexpress.clp->rx_head = rx_head;
lp996drivers/net/eexpress.clp->rx_tail = rx_tail;
lp399drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp551drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp553drivers/net/ewrk3.clp->shmem_base = mem_start;
lp554drivers/net/ewrk3.clp->shmem_length = shmem_length;
lp555drivers/net/ewrk3.clp->lemac = lemac;
lp556drivers/net/ewrk3.clp->hard_strapped = hard_strapped;
lp558drivers/net/ewrk3.clp->mPage = 64;
lp559drivers/net/ewrk3.cif (cmr & DRAM) lp->mPage <<= 1 ;     /* 2 DRAMS on module */ 
lp650drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp660drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp681drivers/net/ewrk3.cif (lp->shmem_length == 0) {
lp684drivers/net/ewrk3.cprintk("\tstart of shared memory: 0x%08lx\n",lp->shmem_base);
lp685drivers/net/ewrk3.cprintk("\twindow length: 0x%04lx\n",lp->shmem_length);
lp727drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp747drivers/net/ewrk3.cfor (page=1;page<lp->mPage;page++) {      /* Write the free page numbers */
lp751drivers/net/ewrk3.clp->lock = 0;                             /* Ensure there are no locks */
lp762drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp768drivers/net/ewrk3.cif (dev->tbusy || lp->lock) {
lp772drivers/net/ewrk3.c} else if (!lp->hard_strapped) {
lp816drivers/net/ewrk3.cif ((page = inb(EWRK3_FMQ)) < lp->mPage) {
lp822drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp823drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp825drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp826drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp828drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp829drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp831drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp832drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp846drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp861drivers/net/ewrk3.cif (lp->txc) {
lp884drivers/net/ewrk3.clp->lock = 0;         /* unlock the page register */
lp912drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp919drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp976drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp982drivers/net/ewrk3.cif ((page = inb(EWRK3_RQ)) < lp->mPage) {/* Get next entry's buffer page */
lp989drivers/net/ewrk3.cif ((tmpLock = set_bit(0, (void *)&lp->lock)) == 1) {   /* Assert lock */
lp990drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {              /* Get existing page */
lp1000drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1002drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp1003drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp1005drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp1006drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp1008drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp1009drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp1020drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1031drivers/net/ewrk3.clp->stats.rx_errors++;            /* Update the error stats. */
lp1032drivers/net/ewrk3.cif (rx_status & DBE) lp->stats.rx_frame_errors++;
lp1033drivers/net/ewrk3.cif (rx_status & CRC) lp->stats.rx_crc_errors++;
lp1034drivers/net/ewrk3.cif (rx_status & PLL) lp->stats.rx_fifo_errors++;
lp1042drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1062drivers/net/ewrk3.clp->stats.rx_packets++;
lp1065drivers/net/ewrk3.clp->pktStats.bins[i]++;
lp1072drivers/net/ewrk3.clp->pktStats.broadcast++;
lp1074drivers/net/ewrk3.clp->pktStats.multicast++;
lp1078drivers/net/ewrk3.clp->pktStats.unicast++;
lp1081drivers/net/ewrk3.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1082drivers/net/ewrk3.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1083drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1087drivers/net/ewrk3.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1098drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {    /* Replace old page */
lp1104drivers/net/ewrk3.clp->lock = 0;                           /* Unlock the page register */
lp1119drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1126drivers/net/ewrk3.clp->stats.tx_errors++;
lp1127drivers/net/ewrk3.cif (tx_status & MAC_NCL)    lp->stats.tx_carrier_errors++;
lp1128drivers/net/ewrk3.cif (tx_status & MAC_LCL)    lp->stats.tx_window_errors++;
lp1131drivers/net/ewrk3.clp->pktStats.tx_underruns++;
lp1133drivers/net/ewrk3.clp->pktStats.excessive_underruns++;
lp1137drivers/net/ewrk3.clp->stats.collisions++;
lp1139drivers/net/ewrk3.clp->pktStats.excessive_collisions++;
lp1143drivers/net/ewrk3.clp->stats.tx_packets++;
lp1154drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1183drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp1199drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1203drivers/net/ewrk3.creturn &lp->stats;
lp1216drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1223drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1226drivers/net/ewrk3.cmulticast_table = (char *)(lp->shmem_base + PAGE0_HTE);
lp1251drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1258drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1260drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1269drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1278drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1306drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1323drivers/net/ewrk3.clp->lock = 0;                              /* Unlock the page register */
lp1611drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1674drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1675drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1683drivers/net/ewrk3.cmemcpy(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
lp1687drivers/net/ewrk3.clp->lock = 0;                               /* Unlock the page register */
lp1722drivers/net/ewrk3.cmemcpy_tofs(ioc->data, &lp->pktStats, sizeof(lp->pktStats)); 
lp1730drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1786drivers/net/ewrk3.clp->txc = 1;
lp1794drivers/net/ewrk3.clp->txc = 0;
lp314drivers/net/lance.cstruct lance_private *lp;
lp388drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp389drivers/net/lance.clp->name = chipname;
lp390drivers/net/lance.clp->rx_buffs = (long)dev->priv + sizeof(struct lance_private);
lp391drivers/net/lance.clp->tx_bounce_buffs = (char (*)[PKT_BUF_SZ])
lp392drivers/net/lance.c(lp->rx_buffs + PKT_BUF_SZ*RX_RING_SIZE);
lp396drivers/net/lance.cif ((int)(lp->rx_ring) & 0x07) {
lp402drivers/net/lance.clp->chip_version = lance_version;
lp404drivers/net/lance.clp->init_block.mode = 0x0003;    /* Disable Rx and Tx. */
lp406drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp407drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp408drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp409drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp410drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp414drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp417drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp525drivers/net/lance.cif (lp->chip_version !=  OLD_LANCE) {
lp549drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp554drivers/net/lance.crequest_irq(dev->irq, &lance_interrupt, 0, lp->name)) {
lp573drivers/net/lance.cif (lp->chip_version == OLD_LANCE)
lp576drivers/net/lance.cif (lp->chip_version != OLD_LANCE) {
lp584drivers/net/lance.cdev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
lp585drivers/net/lance.c(int) &lp->init_block);
lp590drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp592drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp615drivers/net/lance.cdev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
lp624drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp627drivers/net/lance.clp->lock = 0, lp->tx_full = 0;
lp628drivers/net/lance.clp->cur_rx = lp->cur_tx = 0;
lp629drivers/net/lance.clp->dirty_rx = lp->dirty_tx = 0;
lp632drivers/net/lance.clp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
lp633drivers/net/lance.clp->rx_ring[i].buf_length = -PKT_BUF_SZ;
lp638drivers/net/lance.clp->tx_ring[i].base = 0;
lp641drivers/net/lance.clp->init_block.mode = 0x0000;
lp643drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp644drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp645drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp646drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp647drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp653drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp666drivers/net/lance.clp->stats.tx_errors++;
lp671drivers/net/lance.clp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
lp672drivers/net/lance.clp->cur_rx);
lp675drivers/net/lance.clp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
lp676drivers/net/lance.clp->rx_ring[i].msg_length);
lp679drivers/net/lance.clp->tx_ring[i].base, -lp->tx_ring[i].length,
lp680drivers/net/lance.clp->tx_ring[i].misc);
lp715drivers/net/lance.cif (set_bit(0, (void*)&lp->lock) != 0) {
lp725drivers/net/lance.centry = lp->cur_tx & TX_RING_MOD_MASK;
lp731drivers/net/lance.cif (lp->chip_version == OLD_LANCE) {
lp732drivers/net/lance.clp->tx_ring[entry].length =
lp735drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
lp737drivers/net/lance.clp->tx_ring[entry].misc = 0x0000;
lp745drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
lp746drivers/net/lance.clp->tx_ring[entry].base =
lp747drivers/net/lance.c(int)(lp->tx_bounce_buffs + entry) | 0x83000000;
lp750drivers/net/lance.clp->tx_skbuff[entry] = skb;
lp751drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
lp753drivers/net/lance.clp->cur_tx++;
lp762drivers/net/lance.clp->lock = 0;
lp763drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
lp766drivers/net/lance.clp->tx_full = 1;
lp777drivers/net/lance.cstruct lance_private *lp;
lp786drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp806drivers/net/lance.cint dirty_tx = lp->dirty_tx;
lp808drivers/net/lance.cwhile (dirty_tx < lp->cur_tx) {
lp810drivers/net/lance.cint status = lp->tx_ring[entry].base;
lp815drivers/net/lance.clp->tx_ring[entry].base = 0;
lp819drivers/net/lance.cint err_status = lp->tx_ring[entry].misc;
lp820drivers/net/lance.clp->stats.tx_errors++;
lp821drivers/net/lance.cif (err_status & 0x0400) lp->stats.tx_aborted_errors++;
lp822drivers/net/lance.cif (err_status & 0x0800) lp->stats.tx_carrier_errors++;
lp823drivers/net/lance.cif (err_status & 0x1000) lp->stats.tx_window_errors++;
lp826drivers/net/lance.clp->stats.tx_fifo_errors++;
lp835drivers/net/lance.clp->stats.collisions++;
lp836drivers/net/lance.clp->stats.tx_packets++;
lp841drivers/net/lance.cif (lp->tx_skbuff[entry]) {
lp842drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
lp843drivers/net/lance.clp->tx_skbuff[entry] = 0;
lp849drivers/net/lance.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp851drivers/net/lance.cdirty_tx, lp->cur_tx, lp->tx_full);
lp856drivers/net/lance.cif (lp->tx_full && dev->tbusy
lp857drivers/net/lance.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp859drivers/net/lance.clp->tx_full = 0;
lp864drivers/net/lance.clp->dirty_tx = dirty_tx;
lp868drivers/net/lance.cif (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
lp869drivers/net/lance.cif (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
lp894drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp895drivers/net/lance.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
lp899drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
lp900drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
lp908drivers/net/lance.clp->stats.rx_errors++; /* end of a packet.*/
lp909drivers/net/lance.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp910drivers/net/lance.cif (status & 0x10) lp->stats.rx_over_errors++;
lp911drivers/net/lance.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp912drivers/net/lance.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp913drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
lp916drivers/net/lance.cshort pkt_len = lp->rx_ring[entry].msg_length;
lp923drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
lp927drivers/net/lance.clp->stats.rx_dropped++;
lp928drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp929drivers/net/lance.clp->cur_rx++;
lp936drivers/net/lance.c(unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
lp939drivers/net/lance.clp->stats.rx_packets++;
lp944drivers/net/lance.clp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
lp945drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp946drivers/net/lance.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
lp959drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp964drivers/net/lance.cif (lp->chip_version != OLD_LANCE) {
lp966drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp991drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp995drivers/net/lance.cif (lp->chip_version != OLD_LANCE) {
lp999drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp1004drivers/net/lance.creturn &lp->stats;
lp280drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp299drivers/net/skeleton.clp->open_time = jiffies;
lp310drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp350drivers/net/skeleton.clp->stats.tx_aborted_errors++;
lp361drivers/net/skeleton.cstruct net_local *lp;
lp371drivers/net/skeleton.clp = (struct net_local *)dev->priv;
lp380drivers/net/skeleton.clp->stats.tx_packets++;
lp386drivers/net/skeleton.clp->stats.tx_window_errors++;
lp398drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp410drivers/net/skeleton.clp->stats.rx_errors++;
lp411drivers/net/skeleton.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp412drivers/net/skeleton.cif (status & 0x10) lp->stats.rx_over_errors++;
lp413drivers/net/skeleton.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp414drivers/net/skeleton.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp422drivers/net/skeleton.clp->stats.rx_dropped++;
lp435drivers/net/skeleton.clp->stats.rx_packets++;
lp449drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp452drivers/net/skeleton.clp->open_time = 0;
lp480drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp485drivers/net/skeleton.clp->stats.rx_missed_errors = inw(ioaddr+1);
lp488drivers/net/skeleton.creturn &lp->stats;
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->data, lp->rx_ring[entry].buffer1, pkt_len);
lp623drivers/net/tulip.clp->stats.rx_packets++;
lp626drivers/net/tulip.clp->rx_ring[entry].status = 0x80000000;
lp627drivers/net/tulip.centry = (++lp->cur_rx) % RX_RING_SIZE;
lp193drivers/net/wavelan.cnet_local  *lp;
lp197drivers/net/wavelan.clp = (net_local *)dev->priv;
lp201drivers/net/wavelan.clp->hacr &= ~HACR_INTRON;
lp202drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp212drivers/net/wavelan.cnet_local  *lp;
lp216drivers/net/wavelan.clp = (net_local *)dev->priv;
lp220drivers/net/wavelan.clp->hacr |= HACR_INTRON;
lp221drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp346drivers/net/wavelan.cnet_local  *lp;
lp351drivers/net/wavelan.clp = (net_local *)dev->priv;
lp395drivers/net/wavelan.cif (lp->promiscuous)
lp412drivers/net/wavelan.cm.mmw_netw_id_l = lp->nwid[1];
lp413drivers/net/wavelan.cm.mmw_netw_id_h = lp->nwid[0];
lp423drivers/net/wavelan.cnet_local  *lp;
lp428drivers/net/wavelan.clp = (net_local *)dev->priv;
lp438drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp462drivers/net/wavelan.cnet_local  *lp;
lp468drivers/net/wavelan.clp = (net_local *)dev->priv;
lp473drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp502drivers/net/wavelan.cnet_local  *lp;
lp512drivers/net/wavelan.clp = (net_local *)dev->priv;
lp514drivers/net/wavelan.clp->nresets++;
lp517drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp531drivers/net/wavelan.cpsa_read(ioaddr, lp->hacr, 0, (unsigned char *)&psa, sizeof(psa));
lp555drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp642drivers/net/wavelan.cAC_CFG_PRM(lp->promiscuous);
lp765drivers/net/wavelan.cnet_local  *lp;
lp879drivers/net/wavelan.clp = (net_local *)dev->priv;
lp883drivers/net/wavelan.cfirst_wavelan = lp;
lp884drivers/net/wavelan.clp->prev = lp;
lp885drivers/net/wavelan.clp->next = lp;
lp889drivers/net/wavelan.clp->prev = first_wavelan->prev;
lp890drivers/net/wavelan.clp->next = first_wavelan;
lp891drivers/net/wavelan.cfirst_wavelan->prev->next = lp;
lp892drivers/net/wavelan.cfirst_wavelan->prev = lp;
lp894drivers/net/wavelan.clp->dev = dev;
lp896drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp898drivers/net/wavelan.clp->nwid[0] = psa.psa_nwid[0];
lp899drivers/net/wavelan.clp->nwid[1] = psa.psa_nwid[1];
lp901drivers/net/wavelan.clp->watchdog.function = wavelan_watchdog;
lp902drivers/net/wavelan.clp->watchdog.data = (unsigned long)dev;
lp930drivers/net/wavelan.cnet_local  *lp;
lp939drivers/net/wavelan.clp = (net_local *)dev->priv;
lp945drivers/net/wavelan.clp->rx_head = OFFSET_RU;
lp947drivers/net/wavelan.cfor (i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next)
lp949drivers/net/wavelan.crx_next = (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ;
lp964drivers/net/wavelan.clp->rx_last = rx;
lp967drivers/net/wavelan.cobram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset), (unsigned char *)&lp->rx_head, sizeof(lp->rx_head));
lp972drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp997drivers/net/wavelan.cnet_local  *lp;
lp1004drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1006drivers/net/wavelan.clp->tx_first_free = OFFSET_CU;
lp1007drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1053drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1067drivers/net/wavelan.clp->tx_n_in_use = 0;
lp1076drivers/net/wavelan.cnet_local  *lp;
lp1079drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1120drivers/net/wavelan.cnet_local  *lp;
lp1133drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1137drivers/net/wavelan.ctxblock = lp->tx_first_free;
lp1141drivers/net/wavelan.clp->tx_first_free += TXBLOCKZ;
lp1142drivers/net/wavelan.cif (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1143drivers/net/wavelan.clp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
lp1150drivers/net/wavelan.clp->tx_n_in_use++;
lp1195drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1196drivers/net/wavelan.clp->tx_first_in_use = txblock;
lp1198drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1203drivers/net/wavelan.cif (lp->watchdog.next == (timer_list *)0)
lp1322drivers/net/wavelan.cnet_local  *lp;
lp1326drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1337drivers/net/wavelan.cobram_read(ioaddr, lp->rx_head, (unsigned char *)&fd, sizeof(fd));
lp1364drivers/net/wavelan.clp->stats.rx_errors++;
lp1371drivers/net/wavelan.clp->stats.rx_length_errors++;
lp1377drivers/net/wavelan.clp->stats.rx_over_errors++;
lp1383drivers/net/wavelan.clp->stats.rx_fifo_errors++;
lp1389drivers/net/wavelan.clp->stats.rx_frame_errors++;
lp1395drivers/net/wavelan.clp->stats.rx_crc_errors++;
lp1481drivers/net/wavelan.clp->stats.rx_dropped++;
lp1519drivers/net/wavelan.clp->stats.rx_packets++;
lp1524drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_status), (unsigned char *)&fd.fd_status, sizeof(fd.fd_status));
lp1527drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1530drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_last, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1532drivers/net/wavelan.clp->rx_last = lp->rx_head;
lp1533drivers/net/wavelan.clp->rx_head = fd.fd_link_offset;
lp1548drivers/net/wavelan.cwavelan_complete(device *dev, unsigned short ioaddr, net_local *lp)
lp1558drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1561drivers/net/wavelan.cobram_read(ioaddr, acoff(lp->tx_first_in_use, ac_status), (unsigned char *)&tx_status, sizeof(tx_status));
lp1568drivers/net/wavelan.c--lp->tx_n_in_use;
lp1575drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1576drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1579drivers/net/wavelan.clp->tx_first_in_use += TXBLOCKZ;
lp1580drivers/net/wavelan.cif (lp->tx_first_in_use >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1581drivers/net/wavelan.clp->tx_first_in_use -= NTXBLOCKS * TXBLOCKZ;
lp1588drivers/net/wavelan.clp->stats.tx_packets++;
lp1590drivers/net/wavelan.clp->stats.collisions += ncollisions;
lp1598drivers/net/wavelan.clp->stats.tx_errors++;
lp1601drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1607drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1612drivers/net/wavelan.clp->stats.tx_fifo_errors++;
lp1617drivers/net/wavelan.clp->stats.tx_heartbeat_errors++;
lp1623drivers/net/wavelan.clp->stats.tx_aborted_errors++;
lp1641drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1655drivers/net/wavelan.cnet_local  *lp;
lp1664drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1666drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1672drivers/net/wavelan.clp->watchdog.expires = WATCHDOG_JIFFIES;
lp1673drivers/net/wavelan.cadd_timer(&lp->watchdog);
lp1681drivers/net/wavelan.cnreaped = wavelan_complete(dev, ioaddr, lp);
lp1683drivers/net/wavelan.cprintk("%s: warning: wavelan_watchdog(): %d reaped, %d remain.\n", dev->name, nreaped, lp->tx_n_in_use);
lp1701drivers/net/wavelan.cnet_local  *lp;
lp1713drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1747drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1759drivers/net/wavelan.c(void)wavelan_complete(dev, ioaddr, lp);
lp1804drivers/net/wavelan.cnet_local  *lp;
lp1808drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1818drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1845drivers/net/wavelan.cnet_local  *lp;
lp1847drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1849drivers/net/wavelan.creturn &lp->stats;
lp1856drivers/net/wavelan.cnet_local  *lp;
lp1859drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1867drivers/net/wavelan.clp->promiscuous = 1;
lp1878drivers/net/wavelan.clp->promiscuous = 0;
lp1901drivers/net/wavelan.cnet_local  *lp;
lp1905drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1907drivers/net/wavelan.cif (lp == (net_local *)0)
lp1925drivers/net/wavelan.clp->correct_nwid += (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l;
lp1926drivers/net/wavelan.clp->wrong_nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
lp1934drivers/net/wavelan.clp->correct_nwid,
lp1935drivers/net/wavelan.clp->wrong_nwid,
lp1939drivers/net/wavelan.clp->tx_n_in_use,
lp1940drivers/net/wavelan.clp->nresets
lp1966drivers/net/wavelan.cnet_local  *lp;
lp1968drivers/net/wavelan.clp = first_wavelan;
lp1971drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
lp1985drivers/net/wavelan.cwhile ((lp = lp->next) != first_wavelan);
lp2030drivers/net/wavelan.cwavelan_cu_show_one(device *dev, net_local *lp, int i, unsigned short p)
lp2243drivers/net/wavelan.cnet_local  *lp;
lp2245drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2258drivers/net/wavelan.cnet_local  *lp;
lp2262drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2267drivers/net/wavelan.cfor (i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++)
lp2269drivers/net/wavelan.cwavelan_cu_show_one(dev, lp, i, p);
lp2294drivers/net/wavelan.cnet_local  *lp;
lp2296drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2299drivers/net/wavelan.cprintk(" tx_n_in_use=%d,", lp->tx_n_in_use);
lp2300drivers/net/wavelan.cprintk(" hacr=0x%x,", lp->hacr);
lp2301drivers/net/wavelan.cprintk(" rx_head=0x%x,", lp->rx_head);
lp2302drivers/net/wavelan.cprintk(" rx_last=0x%x,", lp->rx_last);
lp2303drivers/net/wavelan.cprintk(" tx_first_free=0x%x,", lp->tx_first_free);
lp2304drivers/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++;
lp581drivers/net/znet.clp->stats.rx_dropped++;
lp585drivers/net/znet.clp->stats.rx_packets++;
lp631drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp633drivers/net/znet.creturn &lp->stats;
lp72fs/xiafs/bitmap.cregister long * lp;
lp74fs/xiafs/bitmap.clp=(long *)bh->b_data;
lp76fs/xiafs/bitmap.c*lp++=0;
lp250fs/xiafs/inode.cdt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
lp256fs/xiafs/inode.cif ((tmp=*lp)) {
lp258fs/xiafs/inode.cif (tmp == *lp)
lp269fs/xiafs/inode.cif (*lp) {
lp274fs/xiafs/inode.c*lp = tmp;
lp284fs/xiafs/inode.cu_long *lp;
lp297fs/xiafs/inode.clp = nr + (u_long *) bh->b_data;
lp299fs/xiafs/inode.cif ((tmp=*lp)) {
lp301fs/xiafs/inode.cif (tmp == *lp) {
lp318fs/xiafs/inode.cif (*lp) {
lp323fs/xiafs/inode.c*lp = tmp;
lp44fs/xiafs/truncate.cu_long * lp;
lp53fs/xiafs/truncate.clp=i + inode->u.xiafs_i.i_zone;
lp54fs/xiafs/truncate.cif (!(tmp = *lp))
lp61fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *lp)
lp64fs/xiafs/truncate.c*lp = 0;
lp74fs/xiafs/truncate.cstatic int trunc_indirect(struct inode * inode, int addr_off, u_long * lp)
lp84fs/xiafs/truncate.cif ( !(tmp=*lp) )
lp87fs/xiafs/truncate.cif (tmp != *lp) {
lp92fs/xiafs/truncate.c*lp = 0;
lp123fs/xiafs/truncate.ctmp = *lp;
lp124fs/xiafs/truncate.c*lp = 0;
lp141fs/xiafs/truncate.cu_long * dindp, * lp;
lp144fs/xiafs/truncate.clp = &(inode->u.xiafs_i.i_dind_zone);
lp145fs/xiafs/truncate.cif (!(tmp = *lp))
lp148fs/xiafs/truncate.cif (tmp != *lp) {
lp153fs/xiafs/truncate.c*lp = 0;
lp172fs/xiafs/truncate.ctmp = *lp;
lp173fs/xiafs/truncate.c*lp = 0;
lp144net/inet/protocol.cstruct inet_protocol *lp = NULL;
lp165net/inet/protocol.cif (p->copy == 0 && lp != NULL) lp->copy = 0;
lp171net/inet/protocol.clp = p;