taglinefilesource code
lp133drivers/char/lp.cstruct lp_struct *lp = &lp_table[0];
lp136drivers/char/lp.cwhile (irq != lp->irq) {
lp137drivers/char/lp.cif (++lp >= lp_end)
lp141drivers/char/lp.cwake_up(&lp->lp_wait_q);
lp150drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp156drivers/char/lp.cmemcpy_fromfs(lp->lp_buffer, buf, copy_size);
lp159drivers/char/lp.cif (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
lp191drivers/char/lp.cinterruptible_sleep_on(&lp->lp_wait_q);
lp384drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp393drivers/char/lp.clp->lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
lp394drivers/char/lp.cif (!lp->lp_buffer)
lp409drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp410drivers/char/lp.clp->lp_buffer = NULL;
lp417drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp418drivers/char/lp.clp->lp_buffer = NULL;
lp273drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp285drivers/net/3c501.clp->stats.tx_errors++;
lp306drivers/net/3c501.clp->tx_pkt_start = gp_start;
lp307drivers/net/3c501.clp->collisions = 0;
lp334drivers/net/3c501.cstruct net_local *lp;
lp344drivers/net/3c501.clp = (struct net_local *)dev->priv;
lp371drivers/net/3c501.clp->stats.tx_aborted_errors++;
lp376drivers/net/3c501.coutw(lp->tx_pkt_start, GP_LOW);
lp378drivers/net/3c501.clp->stats.collisions++;
lp382drivers/net/3c501.clp->stats.tx_packets++;
lp397drivers/net/3c501.clp->stats.rx_missed_errors++;
lp399drivers/net/3c501.clp->stats.rx_length_errors++;
lp427drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp440drivers/net/3c501.clp->stats.rx_over_errors++;
lp449drivers/net/3c501.clp->stats.rx_dropped++;
lp458drivers/net/3c501.clp->stats.rx_packets++;
lp514drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp515drivers/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;
lp516drivers/net/3c507.cstruct net_local *lp;
lp528drivers/net/3c507.clp = (struct net_local *)dev->priv;
lp541drivers/net/3c507.cwhile (lp->tx_reap != lp->tx_head) {
lp542drivers/net/3c507.cunsigned short tx_status = shmem[lp->tx_reap>>1];
lp545drivers/net/3c507.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp549drivers/net/3c507.clp->stats.tx_packets++;
lp550drivers/net/3c507.clp->stats.collisions += tx_status & 0xf;
lp554drivers/net/3c507.clp->stats.tx_errors++;
lp555drivers/net/3c507.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp556drivers/net/3c507.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp557drivers/net/3c507.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp558drivers/net/3c507.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp561drivers/net/3c507.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp562drivers/net/3c507.clp->tx_reap += TX_BUF_SIZE;
lp563drivers/net/3c507.cif (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
lp564drivers/net/3c507.clp->tx_reap = TX_BUF_START;
lp571drivers/net/3c507.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp643drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp647drivers/net/3c507.creturn &lp->stats;
lp654drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp658drivers/net/3c507.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp684drivers/net/3c507.clp->rx_tail = cur_rxbuf;
lp691drivers/net/3c507.c(dev->mem_start + lp->rx_tail + 2);
lp693drivers/net/3c507.c*write_ptr++ = lp->rx_head;        /* Link */
lp700drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp723drivers/net/3c507.clp->tx_cmd_link = IDLELOOP + 4;
lp724drivers/net/3c507.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp759drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp761drivers/net/3c507.cushort tx_block = lp->tx_head;
lp785drivers/net/3c507.c*(ushort*)(dev->mem_start + lp->tx_cmd_link) = tx_block;
lp786drivers/net/3c507.clp->tx_cmd_link = tx_block + 20;
lp789drivers/net/3c507.clp->tx_head = tx_block + TX_BUF_SIZE;
lp790drivers/net/3c507.cif (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
lp791drivers/net/3c507.clp->tx_head = TX_BUF_START;
lp795drivers/net/3c507.cdev->name, ioaddr, length, tx_block, lp->tx_head);
lp798drivers/net/3c507.cif (lp->tx_head != lp->tx_reap)
lp805drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp807drivers/net/3c507.cushort rx_head = lp->rx_head;
lp808drivers/net/3c507.cushort rx_tail = lp->rx_tail;
lp828drivers/net/3c507.clp->stats.rx_errors++;
lp829drivers/net/3c507.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp830drivers/net/3c507.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp831drivers/net/3c507.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp832drivers/net/3c507.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp833drivers/net/3c507.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp842drivers/net/3c507.clp->stats.rx_dropped++;
lp852drivers/net/3c507.clp->stats.rx_packets++;
lp867drivers/net/3c507.clp->rx_head = rx_head;
lp868drivers/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++;
lp526drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp533drivers/net/3c509.creturn &lp->stats;
lp543drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp551drivers/net/3c509.clp->stats.tx_carrier_errors   += inb(ioaddr + 0);
lp552drivers/net/3c509.clp->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
lp554drivers/net/3c509.clp->stats.collisions      += inb(ioaddr + 3);
lp555drivers/net/3c509.clp->stats.tx_window_errors    += inb(ioaddr + 4);
lp556drivers/net/3c509.clp->stats.rx_fifo_errors    += inb(ioaddr + 5);
lp557drivers/net/3c509.clp->stats.tx_packets      += inb(ioaddr + 6);
lp572drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp582drivers/net/3c509.clp->stats.rx_errors++;
lp584drivers/net/3c509.ccase 0x0000:    lp->stats.rx_over_errors++; break;
lp585drivers/net/3c509.ccase 0x0800:    lp->stats.rx_length_errors++; break;
lp586drivers/net/3c509.ccase 0x1000:    lp->stats.rx_frame_errors++; break;
lp587drivers/net/3c509.ccase 0x1800:    lp->stats.rx_length_errors++; break;
lp588drivers/net/3c509.ccase 0x2000:    lp->stats.rx_frame_errors++; break;
lp589drivers/net/3c509.ccase 0x2800:    lp->stats.rx_crc_errors++; break;
lp609drivers/net/3c509.clp->stats.rx_packets++;
lp615drivers/net/3c509.clp->stats.rx_dropped++;
lp200drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp211drivers/net/apricot.clp->scb.rfd = &lp->rx[0];
lp215drivers/net/apricot.clp->rx_tail = &(lp->rx[i]);
lp216drivers/net/apricot.clp->rx[i].next = &lp->rx[0];
lp217drivers/net/apricot.clp->rx[i].cmd = CMD_EOL;
lp221drivers/net/apricot.clp->rx[i].next = &lp->rx[i+1];
lp222drivers/net/apricot.clp->rx[i].cmd = 0x0000;
lp224drivers/net/apricot.clp->rx[i].stat = 0x0000;
lp225drivers/net/apricot.clp->rx[i].rbd = 0xffffffff;
lp226drivers/net/apricot.clp->rx[i].count = 0;
lp227drivers/net/apricot.clp->rx[i].size = 1532;
lp230drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp234drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp238drivers/net/apricot.clp->scb.command = RX_START;
lp248drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp256drivers/net/apricot.coutw(((((int)&lp->scp) & 0xffff) | 2), ioaddr);
lp257drivers/net/apricot.coutw((((int)&lp->scp)>>16) & 0xffff, ioaddr);
lp259drivers/net/apricot.clp->last_cmd=jiffies;
lp261drivers/net/apricot.clp->scp.sysbus = 0x00440000;
lp262drivers/net/apricot.clp->scp.iscp = &(lp->iscp);
lp263drivers/net/apricot.clp->iscp.scb = &(lp->scb);
lp264drivers/net/apricot.clp->iscp.stat = 0x0001;
lp265drivers/net/apricot.clp->cmd_backlog = 0;
lp267drivers/net/apricot.clp->cmd_head = lp->scb.cmd = (struct i596_cmd *) -1;
lp275drivers/net/apricot.cwhile (lp->iscp.stat)
lp279drivers/net/apricot.cdev->name, lp->scb.status, lp->scb.command);
lp283drivers/net/apricot.cmemcpy (lp->i596_config, init_setup, 14);
lp284drivers/net/apricot.clp->set_conf.command = CmdConfigure;
lp285drivers/net/apricot.ci596_add_cmd(dev, &lp->set_conf);
lp287drivers/net/apricot.cmemcpy (lp->eth_addr, dev->dev_addr, 6);
lp288drivers/net/apricot.clp->set_add.command = CmdSASetup;
lp289drivers/net/apricot.ci596_add_cmd(dev, &lp->set_add);
lp291drivers/net/apricot.clp->tdr.command = CmdTDR;
lp292drivers/net/apricot.ci596_add_cmd(dev, &lp->tdr);
lp297drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp301drivers/net/apricot.clp->scb.status, lp->scb.command);
lp311drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp316drivers/net/apricot.cwhile ((lp->scb.rfd->stat) & STAT_C)
lp318drivers/net/apricot.cif (i596_debug >2) print_eth(lp->scb.rfd->data);
lp320drivers/net/apricot.cif ((lp->scb.rfd->stat) & STAT_OK)
lp323drivers/net/apricot.cint pkt_len = lp->scb.rfd->count & 0x3fff;
lp331drivers/net/apricot.clp->stats.rx_dropped++;
lp337drivers/net/apricot.cmemcpy(skb->data, lp->scb.rfd->data, pkt_len);
lp340drivers/net/apricot.clp->stats.rx_packets++;
lp346drivers/net/apricot.clp->stats.rx_errors++;
lp347drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0001) lp->stats.collisions++;
lp348drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0080) lp->stats.rx_length_errors++;
lp349drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0100) lp->stats.rx_over_errors++;
lp350drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0200) lp->stats.rx_fifo_errors++;
lp351drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0400) lp->stats.rx_frame_errors++;
lp352drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x0800) lp->stats.rx_crc_errors++;
lp353drivers/net/apricot.cif ((lp->scb.rfd->stat) & 0x1000) lp->stats.rx_length_errors++;
lp356drivers/net/apricot.clp->scb.rfd->stat=0;
lp357drivers/net/apricot.clp->rx_tail->cmd=0;
lp358drivers/net/apricot.clp->rx_tail=lp->scb.rfd;
lp359drivers/net/apricot.clp->scb.rfd=lp->scb.rfd->next;
lp360drivers/net/apricot.clp->rx_tail->count=0;
lp361drivers/net/apricot.clp->rx_tail->cmd=CMD_EOL;
lp371drivers/net/apricot.ci596_cleanup_cmd(struct i596_private *lp)
lp378drivers/net/apricot.cwhile (lp->cmd_head != (struct i596_cmd *) -1)
lp380drivers/net/apricot.cptr = lp->cmd_head;
lp382drivers/net/apricot.clp->cmd_head = lp->cmd_head->next;
lp383drivers/net/apricot.clp->cmd_backlog--;
lp394drivers/net/apricot.clp->stats.tx_errors++;
lp395drivers/net/apricot.clp->stats.tx_aborted_errors++;
lp414drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp418drivers/net/apricot.clp->scb.status, lp->scb.command);
lp422drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
lp426drivers/net/apricot.ci596_reset(struct device *dev, struct i596_private *lp, int ioaddr)
lp432drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp436drivers/net/apricot.clp->scb.status, lp->scb.command);
lp443drivers/net/apricot.clp->scb.command=CUC_ABORT|RX_ABORT;
lp449drivers/net/apricot.cwhile ((lp->scb.status, lp->scb.command) || lp->scb.command)
lp453drivers/net/apricot.clp->scb.status, lp->scb.command);
lp457drivers/net/apricot.ci596_cleanup_cmd(lp);
lp468drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp481drivers/net/apricot.cif (lp->cmd_head != (struct i596_cmd *) -1)
lp482drivers/net/apricot.clp->cmd_tail->next = cmd;
lp485drivers/net/apricot.clp->cmd_head=cmd;
lp486drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp490drivers/net/apricot.clp->scb.status, lp->scb.command);
lp494drivers/net/apricot.clp->scb.cmd = cmd;
lp495drivers/net/apricot.clp->scb.command = CUC_START;
lp498drivers/net/apricot.clp->cmd_tail=cmd;
lp499drivers/net/apricot.clp->cmd_backlog++;
lp501drivers/net/apricot.clp->cmd_head=lp->scb.cmd;
lp504drivers/net/apricot.cif (lp->cmd_backlog > 16) 
lp506drivers/net/apricot.cint tickssofar = jiffies - lp->last_cmd;
lp512drivers/net/apricot.ci596_reset(dev, lp, ioaddr);
lp542drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp555drivers/net/apricot.clp->stats.tx_errors++;
lp557drivers/net/apricot.cif (lp->last_restart == lp->stats.tx_packets) {
lp561drivers/net/apricot.ci596_reset(dev,lp, ioaddr);
lp566drivers/net/apricot.clp->scb.command=CUC_START|RX_START;
lp569drivers/net/apricot.clp->last_restart = lp->stats.tx_packets;
lp601drivers/net/apricot.clp->stats.tx_dropped++;
lp623drivers/net/apricot.clp->stats.tx_packets++;
lp717drivers/net/apricot.cstruct i596_private *lp;
lp736drivers/net/apricot.clp = (struct i596_private *)dev->priv;
lp738drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp741drivers/net/apricot.cprintk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command);
lp744drivers/net/apricot.cstatus = lp->scb.status;
lp760drivers/net/apricot.cwhile ((lp->cmd_head != (struct i596_cmd *) -1) && (lp->cmd_head->status & STAT_C))
lp762drivers/net/apricot.cptr = lp->cmd_head;
lp764drivers/net/apricot.clp->cmd_head = lp->cmd_head->next;
lp765drivers/net/apricot.clp->cmd_backlog--;
lp782drivers/net/apricot.clp->stats.tx_errors++;
lp783drivers/net/apricot.cif ((ptr->status) & 0x0020) lp->stats.collisions++;
lp784drivers/net/apricot.cif (!((ptr->status) & 0x0040)) lp->stats.tx_heartbeat_errors++;
lp785drivers/net/apricot.cif ((ptr->status) & 0x0400) lp->stats.tx_carrier_errors++;
lp786drivers/net/apricot.cif ((ptr->status) & 0x0800) lp->stats.collisions++;
lp787drivers/net/apricot.cif ((ptr->status) & 0x1000) lp->stats.tx_aborted_errors++;
lp827drivers/net/apricot.clp->last_cmd=jiffies;
lp831drivers/net/apricot.cptr = lp->cmd_head;
lp832drivers/net/apricot.cwhile ((ptr != (struct i596_cmd *) -1) && (ptr != lp->cmd_tail))
lp838drivers/net/apricot.cif ((lp->cmd_head != (struct i596_cmd *) -1) && (dev->start)) ack_cmd |= CUC_START;
lp839drivers/net/apricot.clp->scb.cmd = lp->cmd_head;
lp860drivers/net/apricot.cwhile (lp->scb.status, lp->scb.command)
lp863drivers/net/apricot.cprintk("%s: i596 interrupt, timeout status %4.4x command %4.4x.\n", dev->name, lp->scb.status, lp->scb.command);
lp866drivers/net/apricot.clp->scb.command = ack_cmd;
lp883drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp890drivers/net/apricot.cdev->name, lp->scb.status);
lp892drivers/net/apricot.clp->scb.command = CUC_ABORT|RX_ABORT;
lp895drivers/net/apricot.ci596_cleanup_cmd(lp);
lp906drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp908drivers/net/apricot.creturn &lp->stats;
lp921drivers/net/apricot.cstruct i596_private *lp = (struct i596_private *)dev->priv;
lp943drivers/net/apricot.cif (lp->set_conf.next != (struct i596_cmd * ) -1) return;
lp945drivers/net/apricot.clp->i596_config[8] &= ~0x01;
lp947drivers/net/apricot.clp->i596_config[8] |= 0x01;
lp949drivers/net/apricot.ci596_add_cmd(dev, &lp->set_conf);
lp323drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp352drivers/net/at1700.clp->open_time = jiffies;
lp364drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp380drivers/net/at1700.clp->stats.tx_errors++;
lp412drivers/net/at1700.clp->tx_queue++;
lp413drivers/net/at1700.clp->tx_queue_len += length + 2;
lp415drivers/net/at1700.cif (lp->tx_started == 0) {
lp417drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp418drivers/net/at1700.clp->tx_queue = 0;
lp419drivers/net/at1700.clp->tx_queue_len = 0;
lp421drivers/net/at1700.clp->tx_started = 1;
lp423drivers/net/at1700.c} else if (lp->tx_queue_len < 4096 - 1502)
lp442drivers/net/at1700.cstruct net_local *lp;
lp452drivers/net/at1700.clp = (struct net_local *)dev->priv;
lp464drivers/net/at1700.clp->stats.tx_packets++;
lp465drivers/net/at1700.cif (lp->tx_queue) {
lp466drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp467drivers/net/at1700.clp->tx_queue = 0;
lp468drivers/net/at1700.clp->tx_queue_len = 0;
lp473drivers/net/at1700.clp->tx_started = 0;
lp490drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp508drivers/net/at1700.clp->stats.rx_errors++;
lp509drivers/net/at1700.cif (status & 0x08) lp->stats.rx_length_errors++;
lp510drivers/net/at1700.cif (status & 0x04) lp->stats.rx_frame_errors++;
lp511drivers/net/at1700.cif (status & 0x02) lp->stats.rx_crc_errors++;
lp512drivers/net/at1700.cif (status & 0x01) lp->stats.rx_over_errors++;
lp522drivers/net/at1700.clp->stats.rx_errors++;
lp530drivers/net/at1700.clp->stats.rx_dropped++;
lp547drivers/net/at1700.clp->stats.rx_packets++;
lp575drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp578drivers/net/at1700.clp->open_time = 0;
lp599drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp605drivers/net/at1700.creturn &lp->stats;
lp237drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp238drivers/net/atp.clp->addr_mode = CMR2h_Normal;
lp339drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp348drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp365drivers/net/atp.clp->tx_unit_busy = 0;
lp366drivers/net/atp.clp->pac_cnt_in_tx_buf = 0;
lp367drivers/net/atp.clp->saved_tx_size = 0;
lp413drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp425drivers/net/atp.clp->stats.tx_errors++;
lp459drivers/net/atp.clp->pac_cnt_in_tx_buf++;
lp460drivers/net/atp.cif (lp->tx_unit_busy == 0) {
lp462drivers/net/atp.clp->saved_tx_size = 0;         /* Redundant */
lp463drivers/net/atp.clp->re_tx = 0;
lp464drivers/net/atp.clp->tx_unit_busy = 1;
lp466drivers/net/atp.clp->saved_tx_size = length;
lp486drivers/net/atp.cstruct net_local *lp;
lp497drivers/net/atp.clp = (struct net_local *)dev->priv;
lp520drivers/net/atp.clp->stats.rx_over_errors++;
lp526drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp540drivers/net/atp.clp->stats.collisions++;
lp541drivers/net/atp.cif (++lp->re_tx > 15) {
lp542drivers/net/atp.clp->stats.tx_aborted_errors++;
lp551drivers/net/atp.clp->stats.tx_packets++;
lp552drivers/net/atp.clp->pac_cnt_in_tx_buf--;
lp553drivers/net/atp.cif ( lp->saved_tx_size) {
lp554drivers/net/atp.ctrigger_send(ioaddr, lp->saved_tx_size);
lp555drivers/net/atp.clp->saved_tx_size = 0;
lp556drivers/net/atp.clp->re_tx = 0;
lp558drivers/net/atp.clp->tx_unit_busy = 0;
lp570drivers/net/atp.clp->stats.rx_missed_errors++;
lp604drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp619drivers/net/atp.clp->stats.rx_errors++;
lp634drivers/net/atp.clp->stats.rx_dropped++;
lp652drivers/net/atp.clp->stats.rx_packets++;
lp683drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp690drivers/net/atp.clp->addr_mode = CMR2h_OFF;
lp709drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp710drivers/net/atp.creturn &lp->stats;
lp722drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp724drivers/net/atp.clp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
lp725drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp401drivers/net/depca.cstruct depca_private *lp;
lp549drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp551drivers/net/depca.cstrcpy(lp->devname,name);
lp557drivers/net/depca.clp->rx_ring = (struct depca_rx_head *)mem_start;
lp560drivers/net/depca.clp->tx_ring = (struct depca_tx_head *)mem_start;
lp563drivers/net/depca.clp->bus_offset = mem_start & 0x00ff0000;
lp566drivers/net/depca.clp->dma_buffs = mem_start;
lp572drivers/net/depca.cmemset(lp->rx_ring, 0, sizeof(struct depca_rx_head)*j);
lp573drivers/net/depca.cmemset(lp->tx_ring, 0, sizeof(struct depca_tx_head)*j);
lp576drivers/net/depca.cif ((int)(lp->rx_ring) & 0x07) {
lp584drivers/net/depca.clp->ringSize = j;
lp585drivers/net/depca.cif (lp->ringSize > RING_SIZE) lp->ringSize = RING_SIZE;
lp586drivers/net/depca.clp->rmask = lp->ringSize - 1;
lp592drivers/net/depca.cfor (i=0, j = lp->ringSize; j>1; i++) {
lp595drivers/net/depca.clp->rlen = (unsigned long)(i << 29);
lp669drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp688drivers/net/depca.cif (strstr(lp->devname,"DEPCA") == NULL) {
lp702drivers/net/depca.cprintk("\t0x%8.8lx  0x%8.8lx\n",(long)lp->rx_ring,(long)lp->tx_ring);
lp704drivers/net/depca.cfor (i=0;i<lp->ringSize;i++){
lp705drivers/net/depca.cprintk("\t0x%8.8lx  0x%8.8lx\n",(long)&lp->rx_ring[i].base,
lp706drivers/net/depca.c(long)&lp->tx_ring[i].base);
lp709drivers/net/depca.cfor (i=0;i<lp->ringSize;i++){
lp710drivers/net/depca.cprintk("\t0x%8.8lx  0x%8.8lx\n",(long)lp->rx_ring[i].base,
lp711drivers/net/depca.c(long)lp->tx_ring[i].base);
lp713drivers/net/depca.cprintk("Initialisation block at 0x%8.8lx\n",(long)&lp->init_block);
lp714drivers/net/depca.cprintk("\tmode: 0x%4.4x\n",lp->init_block.mode);
lp717drivers/net/depca.cprintk("%2.2x:",(short)lp->init_block.phys_addr[i]);
lp721drivers/net/depca.cprintk("%2.2x",(short)lp->init_block.filter[i]);
lp723drivers/net/depca.cprintk("\n\trx_ring at: 0x%8.8lx\n",(long)lp->init_block.rx_ring);
lp724drivers/net/depca.cprintk("\ttx_ring at: 0x%8.8lx\n",(long)lp->init_block.tx_ring);
lp725drivers/net/depca.cprintk("dma_buffs: 0x%8.8lx\n",(long)lp->dma_buffs);
lp727drivers/net/depca.c(short)lp->ringSize, 
lp728drivers/net/depca.c(char)lp->rmask,
lp729drivers/net/depca.c(long)lp->rlen);
lp767drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp770drivers/net/depca.clp->init_block.mode = DTX | DRX;       /* Disable Rx and Tx. */
lp771drivers/net/depca.clp->cur_rx = lp->cur_tx = 0;
lp772drivers/net/depca.clp->dirty_rx = lp->dirty_tx = 0;
lp775drivers/net/depca.cfor (i = 0; i < lp->ringSize; i++) {
lp776drivers/net/depca.clp->rx_ring[i].base = (lp->dma_buffs + i*PKT_BUF_SZ) | R_OWN;
lp777drivers/net/depca.clp->rx_ring[i].buf_length = -PKT_BUF_SZ;
lp778drivers/net/depca.clp->tx_ring[i].base = (lp->dma_buffs + (i+lp->ringSize) * PKT_BUF_SZ) &
lp784drivers/net/depca.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp787drivers/net/depca.clp->init_block.filter[i] = 0x0000;
lp789drivers/net/depca.clp->init_block.rx_ring = ((unsigned long)lp->rx_ring & LA_MASK) | lp->rlen;
lp790drivers/net/depca.clp->init_block.tx_ring = ((unsigned long)lp->tx_ring & LA_MASK) | lp->rlen;
lp792drivers/net/depca.clp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */ 
lp801drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp851drivers/net/depca.cint entry = lp->cur_tx++;
lp856drivers/net/depca.centry &= lp->rmask;          /* Ring around buffer number. */
lp857drivers/net/depca.cbuf = (unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) & 
lp861drivers/net/depca.cwhile (lp->tx_ring[entry].base < 0);
lp870drivers/net/depca.clp->tx_ring[entry].length = -len;
lp873drivers/net/depca.clp->tx_ring[entry].misc = 0x0000;
lp879drivers/net/depca.cif (skbL <= 0) lp->tx_ring[entry].base |= (T_ENP);
lp880drivers/net/depca.clp->tx_ring[entry].base |= (T_OWN|T_STP);
lp891drivers/net/depca.centry = lp->cur_tx++;
lp892drivers/net/depca.centry &= lp->rmask;          /* Ring around buffer number. */
lp893drivers/net/depca.cbuf = (unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) &
lp897drivers/net/depca.cwhile (lp->tx_ring[entry].base < 0);
lp907drivers/net/depca.clp->tx_ring[entry].length = -len;
lp910drivers/net/depca.clp->tx_ring[entry].misc = 0x0000;
lp916drivers/net/depca.cif (skbL <= 0) lp->tx_ring[entry].base |= T_ENP;
lp917drivers/net/depca.clp->tx_ring[entry].base |= T_OWN;
lp922drivers/net/depca.c(unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) &
lp926drivers/net/depca.cdev->name, entry, (unsigned long) &lp->tx_ring[entry],
lp927drivers/net/depca.clp->tx_ring[entry].base, -lp->tx_ring[entry].length);
lp935drivers/net/depca.cif (lp->tx_ring[(entry+1) & lp->rmask].base >= 0) {
lp953drivers/net/depca.cstruct depca_private *lp;
lp959drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp1010drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1011drivers/net/depca.cint entry = lp->cur_rx & lp->rmask;
lp1014drivers/net/depca.cfor (; lp->rx_ring[entry].base >= 0; entry = (++lp->cur_rx) & lp->rmask) {
lp1015drivers/net/depca.cint status = lp->rx_ring[entry].base >> 16 ;
lp1035drivers/net/depca.cwhile ((status=(lp->rx_ring[(entry+1)&lp->rmask].base >> 16)) < 0);
lp1041drivers/net/depca.clp->stats.rx_errors++;             /* Update the error stats. */
lp1042drivers/net/depca.cif (status & R_FRAM) lp->stats.rx_frame_errors++;
lp1043drivers/net/depca.cif (status & R_OFLO) lp->stats.rx_over_errors++;
lp1044drivers/net/depca.cif (status & R_CRC)  lp->stats.rx_crc_errors++;
lp1045drivers/net/depca.cif (status & R_BUFF) lp->stats.rx_fifo_errors++;
lp1047drivers/net/depca.cshort pkt_len = lp->rx_ring[entry].msg_length;
lp1053drivers/net/depca.clp->stats.rx_dropped++;  /* Really, deferred. */
lp1059drivers/net/depca.c(unsigned char *)((lp->rx_ring[entry].base+lp->bus_offset) &
lp1067drivers/net/depca.clp->stats.rx_packets++;
lp1071drivers/net/depca.clp->rx_ring[entry].base |= R_OWN;
lp1073drivers/net/depca.centry = (++lp->cur_rx) & lp->rmask;
lp1074drivers/net/depca.clp->rx_ring[entry].base |= R_OWN;
lp1092drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1093drivers/net/depca.cint dirty_tx = lp->dirty_tx & lp->rmask;
lp1097drivers/net/depca.cdev->name, dirty_tx, (lp->cur_tx & lp->rmask));
lp1103drivers/net/depca.cfor (; dirty_tx!=(lp->cur_tx & lp->rmask) && lp->tx_ring[dirty_tx].base>0;
lp1104drivers/net/depca.cdirty_tx = ++lp->dirty_tx & lp->rmask) {
lp1105drivers/net/depca.cunsigned long *tmdp = (unsigned long *)(&lp->tx_ring[dirty_tx]);
lp1106drivers/net/depca.cint status = lp->tx_ring[dirty_tx].base >> 16;
lp1113drivers/net/depca.cint err_status = lp->tx_ring[dirty_tx].misc;
lp1115drivers/net/depca.clp->stats.tx_errors++;
lp1116drivers/net/depca.cif (err_status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
lp1117drivers/net/depca.cif (err_status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
lp1118drivers/net/depca.cif (err_status & TMD3_LCOL) lp->stats.tx_window_errors++;
lp1119drivers/net/depca.cif (err_status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
lp1122drivers/net/depca.clp->stats.collisions++;
lp1124drivers/net/depca.clp->stats.tx_packets++;
lp1139drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1161drivers/net/depca.cif (strstr(lp->devname,"DEPCA") == NULL) {
lp1180drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1184drivers/net/depca.coutw((unsigned short)((unsigned long)(&lp->init_block) & LA_MASK), 
lp1187drivers/net/depca.coutw((unsigned short)(((unsigned long)(&lp->init_block) & LA_MASK) >> 16), 
lp1196drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1211drivers/net/depca.cdev->name, i, (long) &lp->init_block, inw(DEPCA_DATA));
lp1216drivers/net/depca.cdev->name, i, (long) &lp->init_block, inw(DEPCA_DATA));
lp1225drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1229drivers/net/depca.creturn &lp->stats;
lp1244drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1249drivers/net/depca.clp->init_block.mode = PROM;       /* Set promiscuous mode */
lp1260drivers/net/depca.clp->init_block.filter[i] = multicast_table[i];
lp1262drivers/net/depca.clp->init_block.mode &= ~PROM; /* Unset promiscuous mode */
lp1264drivers/net/depca.clp->init_block.mode |= PROM;    /* Set promiscuous mode */
lp453drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp466drivers/net/eexpress.clp->stats.tx_errors++;
lp468drivers/net/eexpress.cif (lp->last_restart == lp->stats.tx_packets) {
lp477drivers/net/eexpress.clp->last_restart = lp->stats.tx_packets;
lp509drivers/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;
lp754drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp774drivers/net/eexpress.clp->tx_cmd_link = DUMP_DATA + 4;
lp776drivers/net/eexpress.clp->tx_cmd_link = IDLELOOP + 4;
lp778drivers/net/eexpress.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp812drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp815drivers/net/eexpress.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp839drivers/net/eexpress.clp->rx_tail = cur_rxbuf;
lp845drivers/net/eexpress.coutw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
lp847drivers/net/eexpress.coutw(lp->rx_head, ioaddr);        /* Link */
lp853drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp855drivers/net/eexpress.cshort tx_block = lp->tx_head;
lp880drivers/net/eexpress.coutw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
lp882drivers/net/eexpress.clp->tx_cmd_link = tx_block + 20;
lp885drivers/net/eexpress.clp->tx_head = tx_block + TX_BUF_SIZE;
lp886drivers/net/eexpress.cif (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
lp887drivers/net/eexpress.clp->tx_head = TX_BUF_START;
lp892drivers/net/eexpress.ctx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
lp895drivers/net/eexpress.cif (lp->tx_head != lp->tx_reap)
lp902drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp905drivers/net/eexpress.cshort rx_head = lp->rx_head;
lp906drivers/net/eexpress.cshort rx_tail = lp->rx_tail;
lp930drivers/net/eexpress.clp->stats.rx_errors++;
lp931drivers/net/eexpress.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp932drivers/net/eexpress.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp933drivers/net/eexpress.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp934drivers/net/eexpress.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp935drivers/net/eexpress.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp944drivers/net/eexpress.clp->stats.rx_dropped++;
lp955drivers/net/eexpress.clp->stats.rx_packets++;
lp992drivers/net/eexpress.clp->rx_head = rx_head;
lp993drivers/net/eexpress.clp->rx_tail = rx_tail;
lp384drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp536drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp538drivers/net/ewrk3.clp->shmem_base = mem_start;
lp539drivers/net/ewrk3.clp->shmem_length = shmem_length;
lp540drivers/net/ewrk3.clp->lemac = lemac;
lp541drivers/net/ewrk3.clp->hard_strapped = hard_strapped;
lp543drivers/net/ewrk3.clp->mPage = 64;
lp544drivers/net/ewrk3.cif (cmr & DRAM) lp->mPage <<= 1 ;     /* 2 DRAMS on module */ 
lp635drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp645drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp666drivers/net/ewrk3.cif (lp->shmem_length == 0) {
lp669drivers/net/ewrk3.cprintk("\tstart of shared memory: 0x%08lx\n",lp->shmem_base);
lp670drivers/net/ewrk3.cprintk("\twindow length: 0x%04lx\n",lp->shmem_length);
lp712drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp732drivers/net/ewrk3.cfor (page=1;page<lp->mPage;page++) {      /* Write the free page numbers */
lp736drivers/net/ewrk3.clp->lock = 0;                             /* Ensure there are no locks */
lp747drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp753drivers/net/ewrk3.cif (dev->tbusy || lp->lock) {
lp757drivers/net/ewrk3.c} else if (!lp->hard_strapped) {
lp801drivers/net/ewrk3.cif ((page = inb(EWRK3_FMQ)) < lp->mPage) {
lp807drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp808drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp810drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp811drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp813drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp814drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp816drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp817drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp831drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp846drivers/net/ewrk3.cif (lp->txc) {
lp869drivers/net/ewrk3.clp->lock = 0;         /* unlock the page register */
lp898drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp905drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp962drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp968drivers/net/ewrk3.cif ((page = inb(EWRK3_RQ)) < lp->mPage) {/* Get next entry's buffer page */
lp975drivers/net/ewrk3.cif ((tmpLock = set_bit(0, (void *)&lp->lock)) == 1) {   /* Assert lock */
lp976drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {              /* Get existing page */
lp986drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp988drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp989drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp991drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp992drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp994drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp995drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp1006drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1017drivers/net/ewrk3.clp->stats.rx_errors++;            /* Update the error stats. */
lp1018drivers/net/ewrk3.cif (rx_status & DBE) lp->stats.rx_frame_errors++;
lp1019drivers/net/ewrk3.cif (rx_status & CRC) lp->stats.rx_crc_errors++;
lp1020drivers/net/ewrk3.cif (rx_status & PLL) lp->stats.rx_fifo_errors++;
lp1028drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1048drivers/net/ewrk3.clp->stats.rx_packets++;
lp1051drivers/net/ewrk3.clp->pktStats.bins[i]++;
lp1058drivers/net/ewrk3.clp->pktStats.broadcast++;
lp1060drivers/net/ewrk3.clp->pktStats.multicast++;
lp1064drivers/net/ewrk3.clp->pktStats.unicast++;
lp1067drivers/net/ewrk3.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1068drivers/net/ewrk3.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1069drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1073drivers/net/ewrk3.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1084drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {    /* Replace old page */
lp1090drivers/net/ewrk3.clp->lock = 0;                           /* Unlock the page register */
lp1105drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1112drivers/net/ewrk3.clp->stats.tx_errors++;
lp1113drivers/net/ewrk3.cif (tx_status & MAC_NCL)    lp->stats.tx_carrier_errors++;
lp1114drivers/net/ewrk3.cif (tx_status & MAC_LCL)    lp->stats.tx_window_errors++;
lp1117drivers/net/ewrk3.clp->pktStats.tx_underruns++;
lp1119drivers/net/ewrk3.clp->pktStats.excessive_underruns++;
lp1123drivers/net/ewrk3.clp->stats.collisions++;
lp1125drivers/net/ewrk3.clp->pktStats.excessive_collisions++;
lp1129drivers/net/ewrk3.clp->stats.tx_packets++;
lp1140drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1169drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp1185drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1189drivers/net/ewrk3.creturn &lp->stats;
lp1202drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1209drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1212drivers/net/ewrk3.cmulticast_table = (char *)(lp->shmem_base + PAGE0_HTE);
lp1237drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1245drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1247drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1256drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1264drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1293drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1308drivers/net/ewrk3.clp->lock = 0;                              /* Unlock the page register */
lp1585drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1648drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1649drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1657drivers/net/ewrk3.cmemcpy(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
lp1661drivers/net/ewrk3.clp->lock = 0;                               /* Unlock the page register */
lp1696drivers/net/ewrk3.cmemcpy_tofs(ioc->data, &lp->pktStats, sizeof(lp->pktStats)); 
lp1704drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1760drivers/net/ewrk3.clp->txc = 1;
lp1768drivers/net/ewrk3.clp->txc = 0;
lp300drivers/net/lance.cstruct lance_private *lp;
lp372drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp373drivers/net/lance.clp->rx_buffs = (long)dev->priv + sizeof(struct lance_private);
lp374drivers/net/lance.clp->tx_bounce_buffs = (char (*)[PKT_BUF_SZ])
lp375drivers/net/lance.c(lp->rx_buffs + PKT_BUF_SZ*RX_RING_SIZE);
lp379drivers/net/lance.cif ((int)(lp->rx_ring) & 0x07) {
lp385drivers/net/lance.clp->chip_version = lance_version;
lp387drivers/net/lance.clp->init_block.mode = 0x0003;    /* Disable Rx and Tx. */
lp389drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp390drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp391drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp392drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp393drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp397drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp400drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp508drivers/net/lance.cif (lp->chip_version !=  OLD_LANCE) {
lp532drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp556drivers/net/lance.cif (lp->chip_version == OLD_LANCE)
lp559drivers/net/lance.cif (lp->chip_version != OLD_LANCE) {
lp567drivers/net/lance.cdev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
lp568drivers/net/lance.c(int) &lp->init_block);
lp573drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp575drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp594drivers/net/lance.cdev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
lp603drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp606drivers/net/lance.clp->lock = 0, lp->tx_full = 0;
lp607drivers/net/lance.clp->cur_rx = lp->cur_tx = 0;
lp608drivers/net/lance.clp->dirty_rx = lp->dirty_tx = 0;
lp611drivers/net/lance.clp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
lp612drivers/net/lance.clp->rx_ring[i].buf_length = -PKT_BUF_SZ;
lp617drivers/net/lance.clp->tx_ring[i].base = 0;
lp620drivers/net/lance.clp->init_block.mode = 0x0000;
lp622drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp623drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp624drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp625drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp626drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp632drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp645drivers/net/lance.clp->stats.tx_errors++;
lp650drivers/net/lance.clp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
lp651drivers/net/lance.clp->cur_rx);
lp654drivers/net/lance.clp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
lp655drivers/net/lance.clp->rx_ring[i].msg_length);
lp658drivers/net/lance.clp->tx_ring[i].base, -lp->tx_ring[i].length,
lp659drivers/net/lance.clp->tx_ring[i].misc);
lp694drivers/net/lance.cif (set_bit(0, (void*)&lp->lock) != 0) {
lp704drivers/net/lance.centry = lp->cur_tx & TX_RING_MOD_MASK;
lp710drivers/net/lance.cif (lp->chip_version == OLD_LANCE) {
lp711drivers/net/lance.clp->tx_ring[entry].length =
lp714drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
lp716drivers/net/lance.clp->tx_ring[entry].misc = 0x0000;
lp724drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
lp725drivers/net/lance.clp->tx_ring[entry].base =
lp726drivers/net/lance.c(int)(lp->tx_bounce_buffs + entry) | 0x83000000;
lp729drivers/net/lance.clp->tx_skbuff[entry] = skb;
lp730drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
lp732drivers/net/lance.clp->cur_tx++;
lp741drivers/net/lance.clp->lock = 0;
lp742drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
lp745drivers/net/lance.clp->tx_full = 1;
lp757drivers/net/lance.cstruct lance_private *lp;
lp766drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp786drivers/net/lance.cint dirty_tx = lp->dirty_tx;
lp788drivers/net/lance.cwhile (dirty_tx < lp->cur_tx) {
lp790drivers/net/lance.cint status = lp->tx_ring[entry].base;
lp795drivers/net/lance.clp->tx_ring[entry].base = 0;
lp799drivers/net/lance.cint err_status = lp->tx_ring[entry].misc;
lp800drivers/net/lance.clp->stats.tx_errors++;
lp801drivers/net/lance.cif (err_status & 0x0400) lp->stats.tx_aborted_errors++;
lp802drivers/net/lance.cif (err_status & 0x0800) lp->stats.tx_carrier_errors++;
lp803drivers/net/lance.cif (err_status & 0x1000) lp->stats.tx_window_errors++;
lp806drivers/net/lance.clp->stats.tx_fifo_errors++;
lp815drivers/net/lance.clp->stats.collisions++;
lp816drivers/net/lance.clp->stats.tx_packets++;
lp821drivers/net/lance.cif (lp->tx_skbuff[entry]) {
lp822drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
lp823drivers/net/lance.clp->tx_skbuff[entry] = 0;
lp829drivers/net/lance.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp831drivers/net/lance.cdirty_tx, lp->cur_tx, lp->tx_full);
lp836drivers/net/lance.cif (lp->tx_full && dev->tbusy
lp837drivers/net/lance.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp839drivers/net/lance.clp->tx_full = 0;
lp844drivers/net/lance.clp->dirty_tx = dirty_tx;
lp848drivers/net/lance.cif (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
lp849drivers/net/lance.cif (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
lp874drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp875drivers/net/lance.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
lp879drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
lp880drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
lp888drivers/net/lance.clp->stats.rx_errors++; /* end of a packet.*/
lp889drivers/net/lance.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp890drivers/net/lance.cif (status & 0x10) lp->stats.rx_over_errors++;
lp891drivers/net/lance.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp892drivers/net/lance.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp893drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
lp896drivers/net/lance.cshort pkt_len = lp->rx_ring[entry].msg_length;
lp903drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
lp907drivers/net/lance.clp->stats.rx_dropped++;
lp908drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp909drivers/net/lance.clp->cur_rx++;
lp916drivers/net/lance.c(unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
lp919drivers/net/lance.clp->stats.rx_packets++;
lp924drivers/net/lance.clp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
lp925drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp926drivers/net/lance.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
lp939drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp944drivers/net/lance.cif (lp->chip_version != OLD_LANCE) {
lp946drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp971drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp975drivers/net/lance.cif (lp->chip_version != OLD_LANCE) {
lp979drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp984drivers/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++;
lp362drivers/net/skeleton.cstruct net_local *lp;
lp372drivers/net/skeleton.clp = (struct net_local *)dev->priv;
lp381drivers/net/skeleton.clp->stats.tx_packets++;
lp387drivers/net/skeleton.clp->stats.tx_window_errors++;
lp399drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp411drivers/net/skeleton.clp->stats.rx_errors++;
lp412drivers/net/skeleton.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp413drivers/net/skeleton.cif (status & 0x10) lp->stats.rx_over_errors++;
lp414drivers/net/skeleton.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp415drivers/net/skeleton.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp423drivers/net/skeleton.clp->stats.rx_dropped++;
lp436drivers/net/skeleton.clp->stats.rx_packets++;
lp450drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp453drivers/net/skeleton.clp->open_time = 0;
lp481drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp486drivers/net/skeleton.clp->stats.rx_missed_errors = inw(ioaddr+1);
lp489drivers/net/skeleton.creturn &lp->stats;
lp439drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp445drivers/net/znet.clp->stats.tx_packets++;
lp446drivers/net/znet.clp->stats.collisions += tx_status & 0xf;
lp448drivers/net/znet.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp449drivers/net/znet.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp450drivers/net/znet.cif (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
lp451drivers/net/znet.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp454drivers/net/znet.clp->stats.tx_errors++;
lp474drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp541drivers/net/znet.clp->stats.rx_errors++;
lp542drivers/net/znet.cif (status & 0x0800) lp->stats.rx_crc_errors++;
lp543drivers/net/znet.cif (status & 0x0400) lp->stats.rx_frame_errors++;
lp544drivers/net/znet.cif (status & 0x0200) lp->stats.rx_over_errors++; /* Wrong. */
lp545drivers/net/znet.cif (status & 0x0100) lp->stats.rx_fifo_errors++;
lp546drivers/net/znet.cif (status & 0x0080) lp->stats.rx_length_errors++;
lp548drivers/net/znet.clp->stats.rx_length_errors++;
lp558drivers/net/znet.clp->stats.rx_dropped++;
lp586drivers/net/znet.clp->stats.rx_dropped++;
lp590drivers/net/znet.clp->stats.rx_packets++;
lp636drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp638drivers/net/znet.creturn &lp->stats;
lp68fs/xiafs/bitmap.cregister long * lp;
lp70fs/xiafs/bitmap.clp=(long *)bh->b_data;
lp72fs/xiafs/bitmap.c*lp++=0;
lp234fs/xiafs/inode.cdt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
lp240fs/xiafs/inode.cif ((tmp=*lp)) {
lp242fs/xiafs/inode.cif (tmp == *lp)
lp253fs/xiafs/inode.cif (*lp) {
lp258fs/xiafs/inode.c*lp = tmp;
lp268fs/xiafs/inode.cu_long *lp;
lp281fs/xiafs/inode.clp = nr + (u_long *) bh->b_data;
lp283fs/xiafs/inode.cif ((tmp=*lp)) {
lp285fs/xiafs/inode.cif (tmp == *lp) {
lp302fs/xiafs/inode.cif (*lp) {
lp307fs/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;
lp40kernel/ldt.cunsigned long *lp;
lp75kernel/ldt.clp = (unsigned long *) &current->ldt[ldt_info.entry_number];
lp78kernel/ldt.c*lp = 0;
lp79kernel/ldt.c*(lp+1) = 0;
lp82kernel/ldt.c*lp = ((ldt_info.base_addr & 0x0000ffff) << 16) |
lp84kernel/ldt.c*(lp+1) = (ldt_info.base_addr & 0xff000000) |
lp143net/inet/protocol.cstruct inet_protocol *lp = NULL;
lp164net/inet/protocol.cif (p->copy == 0 && lp != NULL) lp->copy = 0;
lp170net/inet/protocol.clp = p;