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];
lp160drivers/char/lp.cwhile (irq != lp->irq) {
lp161drivers/char/lp.cif (++lp >= &lp_table[LP_NO])
lp165drivers/char/lp.cwake_up(&lp->lp_wait_q);
lp173drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp179drivers/char/lp.cmemcpy_fromfs(lp->lp_buffer, buf, copy_size);
lp182drivers/char/lp.cif (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
lp216drivers/char/lp.cinterruptible_sleep_on(&lp->lp_wait_q);
lp441drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp450drivers/char/lp.clp->lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
lp451drivers/char/lp.cif (!lp->lp_buffer)
lp466drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp467drivers/char/lp.clp->lp_buffer = NULL;
lp474drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp475drivers/char/lp.clp->lp_buffer = NULL;
lp336drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp349drivers/net/3c501.clp->stats.tx_errors++;
lp379drivers/net/3c501.clp->tx_pkt_start = gp_start;
lp380drivers/net/3c501.clp->collisions = 0;
lp390drivers/net/3c501.clp->loading=1;
lp401drivers/net/3c501.cif(lp->loading==2)    /* A receive upset our load, despite our best efforts */
lp424drivers/net/3c501.cstruct net_local *lp;
lp434drivers/net/3c501.clp = (struct net_local *)dev->priv;
lp443drivers/net/3c501.clp->loading=2;    /* So we can spot loading interruptions */
lp475drivers/net/3c501.clp->stats.tx_aborted_errors++;
lp483drivers/net/3c501.coutw(lp->tx_pkt_start, GP_LOW);
lp485drivers/net/3c501.clp->stats.collisions++;
lp492drivers/net/3c501.clp->stats.tx_packets++;
lp517drivers/net/3c501.clp->stats.rx_missed_errors++;
lp519drivers/net/3c501.clp->stats.rx_length_errors++;
lp553drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp566drivers/net/3c501.clp->stats.rx_over_errors++;
lp583drivers/net/3c501.clp->stats.rx_dropped++;
lp598drivers/net/3c501.clp->stats.rx_packets++;
lp652drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp653drivers/net/3c501.creturn &lp->stats;
lp460drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp475drivers/net/3c507.cif (lp->last_restart == lp->stats.tx_packets) {
lp484drivers/net/3c507.clp->last_restart = lp->stats.tx_packets;
lp526drivers/net/3c507.cstruct net_local *lp;
lp538drivers/net/3c507.clp = (struct net_local *)dev->priv;
lp551drivers/net/3c507.cwhile (lp->tx_reap != lp->tx_head) {
lp552drivers/net/3c507.cunsigned short tx_status = shmem[lp->tx_reap>>1];
lp555drivers/net/3c507.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp559drivers/net/3c507.clp->stats.tx_packets++;
lp560drivers/net/3c507.clp->stats.collisions += tx_status & 0xf;
lp564drivers/net/3c507.clp->stats.tx_errors++;
lp565drivers/net/3c507.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp566drivers/net/3c507.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp567drivers/net/3c507.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp568drivers/net/3c507.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp571drivers/net/3c507.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp572drivers/net/3c507.clp->tx_reap += TX_BUF_SIZE;
lp573drivers/net/3c507.cif (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
lp574drivers/net/3c507.clp->tx_reap = TX_BUF_START;
lp581drivers/net/3c507.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp657drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp661drivers/net/3c507.creturn &lp->stats;
lp668drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp672drivers/net/3c507.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp698drivers/net/3c507.clp->rx_tail = cur_rxbuf;
lp705drivers/net/3c507.c(dev->mem_start + lp->rx_tail + 2);
lp707drivers/net/3c507.c*write_ptr++ = lp->rx_head;        /* Link */
lp714drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp737drivers/net/3c507.clp->tx_cmd_link = IDLELOOP + 4;
lp738drivers/net/3c507.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp773drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp775drivers/net/3c507.cushort tx_block = lp->tx_head;
lp799drivers/net/3c507.c*(ushort*)(dev->mem_start + lp->tx_cmd_link) = tx_block;
lp800drivers/net/3c507.clp->tx_cmd_link = tx_block + 20;
lp803drivers/net/3c507.clp->tx_head = tx_block + TX_BUF_SIZE;
lp804drivers/net/3c507.cif (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
lp805drivers/net/3c507.clp->tx_head = TX_BUF_START;
lp809drivers/net/3c507.cdev->name, ioaddr, length, tx_block, lp->tx_head);
lp812drivers/net/3c507.cif (lp->tx_head != lp->tx_reap)
lp819drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp821drivers/net/3c507.cushort rx_head = lp->rx_head;
lp822drivers/net/3c507.cushort rx_tail = lp->rx_tail;
lp842drivers/net/3c507.clp->stats.rx_errors++;
lp843drivers/net/3c507.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp844drivers/net/3c507.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp845drivers/net/3c507.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp846drivers/net/3c507.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp847drivers/net/3c507.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp856drivers/net/3c507.clp->stats.rx_dropped++;
lp868drivers/net/3c507.clp->stats.rx_packets++;
lp883drivers/net/3c507.clp->rx_head = rx_head;
lp884drivers/net/3c507.clp->rx_tail = rx_tail;
lp392drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp464drivers/net/3c509.cif (tx_status & 0x38) lp->stats.tx_aborted_errors++;
lp537drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp544drivers/net/3c509.creturn &lp->stats;
lp554drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp562drivers/net/3c509.clp->stats.tx_carrier_errors   += inb(ioaddr + 0);
lp563drivers/net/3c509.clp->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
lp565drivers/net/3c509.clp->stats.collisions      += inb(ioaddr + 3);
lp566drivers/net/3c509.clp->stats.tx_window_errors    += inb(ioaddr + 4);
lp567drivers/net/3c509.clp->stats.rx_fifo_errors    += inb(ioaddr + 5);
lp568drivers/net/3c509.clp->stats.tx_packets      += inb(ioaddr + 6);
lp583drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp593drivers/net/3c509.clp->stats.rx_errors++;
lp595drivers/net/3c509.ccase 0x0000:    lp->stats.rx_over_errors++; break;
lp596drivers/net/3c509.ccase 0x0800:    lp->stats.rx_length_errors++; break;
lp597drivers/net/3c509.ccase 0x1000:    lp->stats.rx_frame_errors++; break;
lp598drivers/net/3c509.ccase 0x1800:    lp->stats.rx_length_errors++; break;
lp599drivers/net/3c509.ccase 0x2000:    lp->stats.rx_frame_errors++; break;
lp600drivers/net/3c509.ccase 0x2800:    lp->stats.rx_crc_errors++; break;
lp621drivers/net/3c509.clp->stats.rx_packets++;
lp627drivers/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++;
lp357drivers/net/apricot.cmemcpy(skb_put(skb,pkt_len), 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);
lp219drivers/net/arcnet.c#define TBUSY lp->adev->tbusy \
lp220drivers/net/arcnet.c=lp->edev->tbusy
lp221drivers/net/arcnet.c#define IF_TBUSY (lp->adev->tbusy \
lp222drivers/net/arcnet.c|| lp->edev->tbusy)
lp223drivers/net/arcnet.c#define START lp->adev->start \
lp224drivers/net/arcnet.c=lp->edev->start
lp511drivers/net/arcnet.cstruct arcnet_local *lp;
lp620drivers/net/arcnet.clp=(struct arcnet_local *)(dev->priv);
lp653drivers/net/arcnet.clp->arcnum,lp->arcnum);
lp654drivers/net/arcnet.cif (lp->arcnum==0)
lp656drivers/net/arcnet.cif (lp->arcnum==255)
lp658drivers/net/arcnet.cdev->dev_addr[0]=lp->arcnum;
lp659drivers/net/arcnet.clp->sequence=1;
lp660drivers/net/arcnet.clp->recbuf=0;
lp852drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp854drivers/net/arcnet.cint delayval,recbuf=lp->recbuf;
lp879drivers/net/arcnet.clp->arcnum=cardmem[1];  /* save address for later use */
lp882drivers/net/arcnet.crecbuf=lp->recbuf=0;
lp883drivers/net/arcnet.clp->txbuf=2;
lp904drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp906drivers/net/arcnet.cether_setup(lp->edev);
lp908drivers/net/arcnet.cdev->dev_addr[5]=lp->arcnum;
lp910drivers/net/arcnet.clp->edev->open=NULL;
lp911drivers/net/arcnet.clp->edev->stop=NULL;
lp912drivers/net/arcnet.clp->edev->hard_start_xmit=arcnetE_send_packet;
lp916drivers/net/arcnet.clp->edev->name);
lp939drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp960drivers/net/arcnet.clp->intx=0;
lp961drivers/net/arcnet.clp->in_txhandler=0;
lp964drivers/net/arcnet.clp->adev=dev;
lp967drivers/net/arcnet.clp->adev->name);
lp970drivers/net/arcnet.clp->edev=(struct device *)kmalloc(sizeof(struct device),GFP_KERNEL);
lp971drivers/net/arcnet.cif (lp->edev == NULL)
lp973drivers/net/arcnet.cmemcpy(lp->edev,dev,sizeof(struct device));
lp974drivers/net/arcnet.clp->edev->name=(char *)kmalloc(10,GFP_KERNEL);
lp975drivers/net/arcnet.cif (lp->edev->name == NULL) {
lp976drivers/net/arcnet.ckfree(lp->edev);
lp977drivers/net/arcnet.clp->edev = NULL;
lp980drivers/net/arcnet.csprintf(lp->edev->name,"%se",dev->name);
lp981drivers/net/arcnet.clp->edev->init=arcnetE_init;
lp982drivers/net/arcnet.cregister_netdev(lp->edev);
lp1001drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1013drivers/net/arcnet.clp->adev=NULL;
lp1016drivers/net/arcnet.clp->edev->start=0;
lp1017drivers/net/arcnet.clp->edev->priv=NULL;
lp1018drivers/net/arcnet.cdev_close(lp->edev);
lp1019drivers/net/arcnet.cunregister_netdev(lp->edev);
lp1020drivers/net/arcnet.ckfree(lp->edev->name);
lp1021drivers/net/arcnet.ckfree(lp->edev);
lp1022drivers/net/arcnet.clp->edev=NULL;
lp1047drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1050drivers/net/arcnet.clp->intx++;
lp1054drivers/net/arcnet.cinb(STATUS),lp->intx);
lp1056drivers/net/arcnet.cif (lp->in_txhandler)
lp1059drivers/net/arcnet.clp->intx--;
lp1068drivers/net/arcnet.cint recbuf=lp->recbuf;
lp1075drivers/net/arcnet.cstatus,tickssofar,lp->outgoing.skb,
lp1076drivers/net/arcnet.clp->outgoing.numsegs,
lp1077drivers/net/arcnet.clp->outgoing.segnum);
lp1078drivers/net/arcnet.clp->intx--;
lp1084drivers/net/arcnet.cstatus,lp->intx,lp->in_txhandler,tickssofar);
lp1086drivers/net/arcnet.clp->stats.tx_errors++;
lp1096drivers/net/arcnet.cif (lp->outgoing.skb)
lp1098drivers/net/arcnet.cdev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
lp1099drivers/net/arcnet.clp->stats.tx_dropped++;
lp1101drivers/net/arcnet.clp->outgoing.skb=NULL;
lp1104drivers/net/arcnet.clp->intx--;
lp1107drivers/net/arcnet.clp->txready=0;
lp1108drivers/net/arcnet.clp->sending=0;
lp1122drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp1124drivers/net/arcnet.clp->intx--;
lp1128drivers/net/arcnet.cif (lp->txready)  /* transmit already in progress! */
lp1136drivers/net/arcnet.clp->stats.tx_errors++;
lp1137drivers/net/arcnet.clp->intx--;
lp1138drivers/net/arcnet.clp->txready=0;  /* we definitely need this line! */
lp1148drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp1149drivers/net/arcnet.clp->intx--;
lp1153drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1172drivers/net/arcnet.cout->hdr->sequence=(lp->sequence++);
lp1174drivers/net/arcnet.cif (lp->txready && inb(STATUS)&TXFREEflag)
lp1196drivers/net/arcnet.cif (!lp->sending)
lp1220drivers/net/arcnet.cif (lp->txready && inb(STATUS)&TXFREEflag)
lp1223drivers/net/arcnet.cif (!lp->txready)
lp1229drivers/net/arcnet.cif (!lp->sending)
lp1233drivers/net/arcnet.cif (!lp->sending)
lp1252drivers/net/arcnet.clp->intx--;
lp1253drivers/net/arcnet.clp->stats.tx_packets++;
lp1265drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1267drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1269drivers/net/arcnet.cif (lp->txready)
lp1308drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1311drivers/net/arcnet.c(union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
lp1316drivers/net/arcnet.clp->txbuf=lp->txbuf^1;  /* XOR with 1 to alternate between 2 and 3 */
lp1326drivers/net/arcnet.cmemset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
lp1397drivers/net/arcnet.clp->outgoing.lastload_dest=hdr->daddr;
lp1399drivers/net/arcnet.clp->txready=lp->txbuf;  /* packet is ready for sending */
lp1408drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp1415drivers/net/arcnet.cif (!(inb(STATUS)&TXFREEflag) || !lp->txready) return;
lp1418drivers/net/arcnet.coutb(TXcmd|(lp->txready<<3),COMMAND);
lp1423drivers/net/arcnet.clp->txready=0;
lp1424drivers/net/arcnet.clp->sending++;
lp1426drivers/net/arcnet.clp->outgoing.lasttrans_dest=lp->outgoing.lastload_dest;
lp1427drivers/net/arcnet.clp->outgoing.lastload_dest=0;
lp1437drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1473drivers/net/arcnet.c(union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
lp1482drivers/net/arcnet.clp->adev->name,lp->edev->name);
lp1492drivers/net/arcnet.clp->txbuf=lp->txbuf^1; /* XOR with 1 to alternate btw 2 & 3 */
lp1496drivers/net/arcnet.cmemset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
lp1556drivers/net/arcnet.clp->outgoing.lastload_dest=daddr;
lp1558drivers/net/arcnet.clp->txready=lp->txbuf;  /* packet is ready for sending */
lp1604drivers/net/arcnet.cstruct arcnet_local *lp;
lp1613drivers/net/arcnet.clp = (struct arcnet_local *)dev->priv;
lp1655drivers/net/arcnet.clp->stats.tx_carrier_errors++;
lp1662drivers/net/arcnet.cint recbuf=lp->recbuf=!lp->recbuf;
lp1678drivers/net/arcnet.cif (status&TXFREEflag && !lp->in_txhandler && lp->sending)
lp1680drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1682drivers/net/arcnet.clp->in_txhandler++;
lp1683drivers/net/arcnet.clp->sending--;
lp1692drivers/net/arcnet.cif (lp->outgoing.lasttrans_dest != 0)
lp1697drivers/net/arcnet.clp->outgoing.lasttrans_dest);
lp1698drivers/net/arcnet.clp->stats.tx_errors++;
lp1705drivers/net/arcnet.clp->outgoing.lasttrans_dest);
lp1711drivers/net/arcnet.cif (lp->txready)
lp1717drivers/net/arcnet.cif (lp->intx)
lp1719drivers/net/arcnet.clp->in_txhandler--;
lp1723drivers/net/arcnet.cif (!lp->outgoing.skb)
lp1729drivers/net/arcnet.cif (!lp->txready && IF_TBUSY)
lp1735drivers/net/arcnet.clp->in_txhandler--;
lp1746drivers/net/arcnet.cif (lp->txready && !lp->sending)
lp1761drivers/net/arcnet.cif (!lp->txready && IF_TBUSY)
lp1769drivers/net/arcnet.clp->in_txhandler--;
lp1778drivers/net/arcnet.cif (dev->start && lp->sending )
lp1801drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1817drivers/net/arcnet.clp->stats.rx_errors++;
lp1895drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1919drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp1930drivers/net/arcnet.clp->stats.tx_dropped++;
lp1931drivers/net/arcnet.clp->stats.rx_errors++;
lp1940drivers/net/arcnet.clp->stats.rx_dropped++;
lp1986drivers/net/arcnet.clp->stats.rx_frame_errors++;
lp2006drivers/net/arcnet.clp->stats.rx_packets++;
lp2027drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp2039drivers/net/arcnet.clp->stats.tx_dropped++;
lp2040drivers/net/arcnet.clp->stats.rx_fifo_errors++;
lp2053drivers/net/arcnet.clp->stats.tx_dropped++;
lp2054drivers/net/arcnet.clp->stats.rx_over_errors++;
lp2066drivers/net/arcnet.clp->stats.rx_dropped++;
lp2076drivers/net/arcnet.clp->stats.rx_dropped++;
lp2106drivers/net/arcnet.clp->stats.rx_errors++;
lp2127drivers/net/arcnet.clp->stats.tx_dropped++;
lp2128drivers/net/arcnet.clp->stats.rx_fifo_errors++;
lp2173drivers/net/arcnet.clp->stats.rx_packets++;
lp2185drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2195drivers/net/arcnet.clp->stats.rx_dropped++;
lp2200drivers/net/arcnet.cskb->dev = lp->edev;
lp2223drivers/net/arcnet.clp->stats.rx_packets++;
lp2241drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2243drivers/net/arcnet.creturn &lp->stats;
lp2256drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp2394drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *) (dev->priv);
lp2424drivers/net/arcnet.clp->stats.rx_frame_errors++;
lp326drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp351drivers/net/at1700.clp->tx_started = 0;
lp352drivers/net/at1700.clp->tx_queue = 0;
lp353drivers/net/at1700.clp->tx_queue_len = 0;
lp373drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp389drivers/net/at1700.clp->stats.tx_errors++;
lp397drivers/net/at1700.clp->tx_started = 0;
lp398drivers/net/at1700.clp->tx_queue = 0;
lp399drivers/net/at1700.clp->tx_queue_len = 0;
lp424drivers/net/at1700.clp->tx_queue++;
lp425drivers/net/at1700.clp->tx_queue_len += length + 2;
lp427drivers/net/at1700.cif (lp->tx_started == 0) {
lp429drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp430drivers/net/at1700.clp->tx_queue = 0;
lp431drivers/net/at1700.clp->tx_queue_len = 0;
lp433drivers/net/at1700.clp->tx_started = 1;
lp435drivers/net/at1700.c} else if (lp->tx_queue_len < 4096 - 1502)
lp453drivers/net/at1700.cstruct net_local *lp;
lp463drivers/net/at1700.clp = (struct net_local *)dev->priv;
lp475drivers/net/at1700.clp->stats.tx_packets++;
lp476drivers/net/at1700.cif (lp->tx_queue) {
lp477drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp478drivers/net/at1700.clp->tx_queue = 0;
lp479drivers/net/at1700.clp->tx_queue_len = 0;
lp484drivers/net/at1700.clp->tx_started = 0;
lp501drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp520drivers/net/at1700.clp->stats.rx_errors++;
lp521drivers/net/at1700.cif (status & 0x08) lp->stats.rx_length_errors++;
lp522drivers/net/at1700.cif (status & 0x04) lp->stats.rx_frame_errors++;
lp523drivers/net/at1700.cif (status & 0x02) lp->stats.rx_crc_errors++;
lp524drivers/net/at1700.cif (status & 0x01) lp->stats.rx_over_errors++;
lp535drivers/net/at1700.clp->stats.rx_errors++;
lp545drivers/net/at1700.clp->stats.rx_dropped++;
lp554drivers/net/at1700.clp->stats.rx_packets++;
lp607drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp613drivers/net/at1700.creturn &lp->stats;
lp236drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp237drivers/net/atp.clp->addr_mode = CMR2h_Normal;
lp344drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp353drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp370drivers/net/atp.clp->tx_unit_busy = 0;
lp371drivers/net/atp.clp->pac_cnt_in_tx_buf = 0;
lp372drivers/net/atp.clp->saved_tx_size = 0;
lp418drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp430drivers/net/atp.clp->stats.tx_errors++;
lp464drivers/net/atp.clp->pac_cnt_in_tx_buf++;
lp465drivers/net/atp.cif (lp->tx_unit_busy == 0) {
lp467drivers/net/atp.clp->saved_tx_size = 0;         /* Redundant */
lp468drivers/net/atp.clp->re_tx = 0;
lp469drivers/net/atp.clp->tx_unit_busy = 1;
lp471drivers/net/atp.clp->saved_tx_size = length;
lp490drivers/net/atp.cstruct net_local *lp;
lp501drivers/net/atp.clp = (struct net_local *)dev->priv;
lp524drivers/net/atp.clp->stats.rx_over_errors++;
lp530drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp544drivers/net/atp.clp->stats.collisions++;
lp545drivers/net/atp.cif (++lp->re_tx > 15) {
lp546drivers/net/atp.clp->stats.tx_aborted_errors++;
lp555drivers/net/atp.clp->stats.tx_packets++;
lp556drivers/net/atp.clp->pac_cnt_in_tx_buf--;
lp557drivers/net/atp.cif ( lp->saved_tx_size) {
lp558drivers/net/atp.ctrigger_send(ioaddr, lp->saved_tx_size);
lp559drivers/net/atp.clp->saved_tx_size = 0;
lp560drivers/net/atp.clp->re_tx = 0;
lp562drivers/net/atp.clp->tx_unit_busy = 0;
lp574drivers/net/atp.clp->stats.rx_missed_errors++;
lp624drivers/net/atp.cstruct net_local *lp = (struct net_local *)atp_timed_dev->priv;
lp627drivers/net/atp.clp->stats.tx_errors++;
lp629drivers/net/atp.clp->stats.tx_dropped++;
lp631drivers/net/atp.clp->stats.collisions++;
lp633drivers/net/atp.clp->stats.rx_errors++;
lp648drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp663drivers/net/atp.clp->stats.rx_errors++;
lp678drivers/net/atp.clp->stats.rx_dropped++;
lp696drivers/net/atp.clp->stats.rx_packets++;
lp727drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp734drivers/net/atp.clp->addr_mode = CMR2h_OFF;
lp753drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp754drivers/net/atp.creturn &lp->stats;
lp766drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp775drivers/net/atp.clp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
lp776drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp270drivers/net/de4x5.cimr |= lp->irq_en;\
lp276drivers/net/de4x5.cimr &= ~lp->irq_en;\
lp281drivers/net/de4x5.cimr |= lp->irq_mask;\
lp287drivers/net/de4x5.cimr &= ~lp->irq_mask;\
lp397drivers/net/de4x5.c#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
lp398drivers/net/de4x5.clp->tx_old+lp->txRingSize-lp->tx_new-1:\
lp399drivers/net/de4x5.clp->tx_old               -lp->tx_new-1)
lp532drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp537drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp548drivers/net/de4x5.cif (lp->bus == PCI) {
lp550drivers/net/de4x5.cif ((lp->chipset == DC21040) || (lp->chipset == DC21041)) {
lp552drivers/net/de4x5.c} else if (lp->chipset == DC21140) {
lp564drivers/net/de4x5.cif (lp->bus == EISA) {
lp569drivers/net/de4x5.ciobase, lp->bus_num, lp->device);
lp579drivers/net/de4x5.ctmpbus = lp->bus;
lp580drivers/net/de4x5.ctmpchs = lp->chipset;
lp583drivers/net/de4x5.cstruct de4x5_private *lp;
lp597drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp599drivers/net/de4x5.clp->bus = tmpbus;
lp600drivers/net/de4x5.clp->chipset = tmpchs;
lp606drivers/net/de4x5.clp->autosense = AUTO;
lp608drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp609drivers/net/de4x5.cif ((lp->chipset == DC21040) && (de4x5_autosense & TP_NW)) {
lp612drivers/net/de4x5.cif ((lp->chipset == DC21041) && (de4x5_autosense & BNC_AUI)) {
lp615drivers/net/de4x5.clp->autosense = de4x5_autosense & 0x001f;
lp617drivers/net/de4x5.clp->autosense = de4x5_autosense & 0x00c0;
lp621drivers/net/de4x5.csprintf(lp->adapter_name,"%s (%s)", name, dev->name);
lp622drivers/net/de4x5.crequest_region(iobase, (lp->bus == PCI ? DE4X5_PCI_TOTAL_SIZE :
lp624drivers/net/de4x5.clp->adapter_name);
lp636drivers/net/de4x5.clp->rx_ring[i].status = 0;
lp637drivers/net/de4x5.clp->rx_ring[i].des1 = RX_BUFF_SZ;
lp638drivers/net/de4x5.clp->rx_ring[i].buf = virt_to_bus(tmp + i * RX_BUFF_SZ);
lp639drivers/net/de4x5.clp->rx_ring[i].next = (u32)NULL;
lp646drivers/net/de4x5.clp->rxRingSize = NUM_RX_DESC;
lp647drivers/net/de4x5.clp->txRingSize = NUM_TX_DESC;
lp650drivers/net/de4x5.clp->rx_ring[lp->rxRingSize - 1].des1 |= RD_RER;
lp651drivers/net/de4x5.clp->tx_ring[lp->txRingSize - 1].des1 |= TD_TER;
lp654drivers/net/de4x5.coutl(virt_to_bus(lp->rx_ring), DE4X5_RRBA);
lp655drivers/net/de4x5.coutl(virt_to_bus(lp->tx_ring), DE4X5_TRBA);
lp658drivers/net/de4x5.clp->irq_mask = IMR_RIM | IMR_TIM | IMR_TUM ;
lp659drivers/net/de4x5.clp->irq_en   = IMR_NIM | IMR_AIM;
lp661drivers/net/de4x5.clp->tx_enable = TRUE;
lp702drivers/net/de4x5.cif (status) release_region(iobase, (lp->bus == PCI ? 
lp737drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp742drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp743drivers/net/de4x5.cif (lp) {
lp744drivers/net/de4x5.ckfree_s(bus_to_virt(lp->rx_ring[0].buf),
lp760drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp768drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp773drivers/net/de4x5.cif (request_irq(dev->irq, (void *)de4x5_interrupt, 0, lp->adapter_name)) {
lp792drivers/net/de4x5.cprintk("\t0x%8.8lx  0x%8.8lx\n",(u_long)lp->rx_ring,(u_long)lp->tx_ring);
lp794drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp796drivers/net/de4x5.cprintk("0x%8.8lx  ",(u_long)&lp->rx_ring[i].status);
lp799drivers/net/de4x5.cprintk("...0x%8.8lx\n",(u_long)&lp->rx_ring[i].status);
lp801drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp803drivers/net/de4x5.cprintk("0x%8.8lx  ", (u_long)&lp->tx_ring[i].status);
lp806drivers/net/de4x5.cprintk("...0x%8.8lx\n", (u_long)&lp->tx_ring[i].status);
lp808drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp810drivers/net/de4x5.cprintk("0x%8.8x  ",lp->rx_ring[i].buf);
lp813drivers/net/de4x5.cprintk("...0x%8.8x\n",lp->rx_ring[i].buf);
lp815drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp817drivers/net/de4x5.cprintk("0x%8.8x  ", lp->tx_ring[i].buf);
lp820drivers/net/de4x5.cprintk("...0x%8.8x\n", lp->tx_ring[i].buf);
lp822drivers/net/de4x5.c(short)lp->rxRingSize, 
lp823drivers/net/de4x5.c(short)lp->txRingSize); 
lp873drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp887drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp889drivers/net/de4x5.clp->setup_f = HASH_PERF;
lp892drivers/net/de4x5.clp->setup_f = PERFECT;
lp894drivers/net/de4x5.coutl(virt_to_bus(lp->rx_ring), DE4X5_RRBA);
lp895drivers/net/de4x5.coutl(virt_to_bus(lp->tx_ring), DE4X5_TRBA);
lp897drivers/net/de4x5.clp->rx_new = lp->rx_old = 0;
lp898drivers/net/de4x5.clp->tx_new = lp->tx_old = 0;
lp900drivers/net/de4x5.cfor (i = 0; i < lp->rxRingSize; i++) {
lp901drivers/net/de4x5.clp->rx_ring[i].status = R_OWN;
lp904drivers/net/de4x5.cfor (i = 0; i < lp->txRingSize; i++) {
lp905drivers/net/de4x5.clp->tx_ring[i].status = 0;
lp913drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp914drivers/net/de4x5.cload_packet(dev, lp->setup_frame, HASH_F|TD_SET|SETUP_FRAME_LEN, NULL);
lp916drivers/net/de4x5.cload_packet(dev, lp->setup_frame, PERFECT_F|TD_SET|SETUP_FRAME_LEN, NULL);
lp922drivers/net/de4x5.cif (lp->tx_ring[lp->tx_new].status >= 0) j=1;
lp932drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp933drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp949drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp971drivers/net/de4x5.cif (dev->tbusy || (lp->lostMedia > LOST_MEDIA_THRESHOLD)) {
lp974drivers/net/de4x5.c(lp->lostMedia <= LOST_MEDIA_THRESHOLD)) {
lp978drivers/net/de4x5.cprintk("%s: transmit timed out, status %08x, tbusy:%ld, lostMedia:%d tickssofar:%ld, resetting.\n",dev->name, inl(DE4X5_STS), dev->tbusy, lp->lostMedia, tickssofar);
lp985drivers/net/de4x5.cfor (i=lp->tx_old; i!=lp->tx_new; i=(++i)%lp->txRingSize) {
lp986drivers/net/de4x5.cif (lp->skb[i] != NULL) {
lp987drivers/net/de4x5.cif (lp->skb[i]->len != FAKE_FRAME_LEN) {
lp988drivers/net/de4x5.cif (lp->tx_ring[i].status == T_OWN) {
lp989drivers/net/de4x5.cdev_queue_xmit(lp->skb[i], dev, SOPRI_NORMAL);
lp991drivers/net/de4x5.cdev_kfree_skb(lp->skb[i], FREE_WRITE);
lp994drivers/net/de4x5.cdev_kfree_skb(lp->skb[i], FREE_WRITE);
lp996drivers/net/de4x5.clp->skb[i] = NULL;
lp1045drivers/net/de4x5.cif (lp->tx_enable) {
lp1049drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize; /* Ensure a wrap */
lp1080drivers/net/de4x5.cstruct de4x5_private *lp;
lp1087drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp1096drivers/net/de4x5.cwhile ((sts = inl(DE4X5_STS)) & lp->irq_mask) { /* Read IRQ status */
lp1109drivers/net/de4x5.clp->lostMedia = LOST_MEDIA_THRESHOLD + 1;
lp1110drivers/net/de4x5.clp->irq_mask &= ~IMR_LFM;
lp1136drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1141drivers/net/de4x5.cfor (entry = lp->rx_new; lp->rx_ring[entry].status >= 0;entry = lp->rx_new) {
lp1142drivers/net/de4x5.cstatus = lp->rx_ring[entry].status;
lp1145drivers/net/de4x5.clp->rx_old = entry;
lp1150drivers/net/de4x5.clp->stats.rx_errors++;              /* Update the error stats. */
lp1151drivers/net/de4x5.cif (status & (RD_RF | RD_TL)) lp->stats.rx_frame_errors++;
lp1152drivers/net/de4x5.cif (status & RD_CE)           lp->stats.rx_crc_errors++;
lp1153drivers/net/de4x5.cif (status & RD_OF)           lp->stats.rx_fifo_errors++;
lp1156drivers/net/de4x5.cshort pkt_len = (short)(lp->rx_ring[entry].status >> 16) - 4;
lp1162drivers/net/de4x5.cif (entry < lp->rx_old) {         /* Wrapped buffer */
lp1163drivers/net/de4x5.cshort len = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
lp1164drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
lp1165drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
lp1167drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), pkt_len);
lp1175drivers/net/de4x5.clp->stats.rx_packets++;
lp1178drivers/net/de4x5.clp->pktStats.bins[i]++;
lp1185drivers/net/de4x5.clp->pktStats.broadcast++;
lp1187drivers/net/de4x5.clp->pktStats.multicast++;
lp1191drivers/net/de4x5.clp->pktStats.unicast++;
lp1194drivers/net/de4x5.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1195drivers/net/de4x5.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1196drivers/net/de4x5.cmemset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
lp1200drivers/net/de4x5.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1206drivers/net/de4x5.cfor (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)%lp->rxRingSize) {
lp1207drivers/net/de4x5.clp->rx_ring[lp->rx_old].status = R_OWN;
lp1210drivers/net/de4x5.clp->rx_ring[entry].status = R_OWN;
lp1217drivers/net/de4x5.clp->rx_new = (++lp->rx_new) % lp->rxRingSize;
lp1229drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1234drivers/net/de4x5.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
lp1235drivers/net/de4x5.cstatus = lp->tx_ring[entry].status;
lp1239drivers/net/de4x5.clp->stats.tx_errors++; 
lp1240drivers/net/de4x5.cif (status & TD_NC)  lp->stats.tx_carrier_errors++;
lp1241drivers/net/de4x5.cif (status & TD_LC)  lp->stats.tx_window_errors++;
lp1242drivers/net/de4x5.cif (status & TD_UF)  lp->stats.tx_fifo_errors++;
lp1243drivers/net/de4x5.cif (status & TD_LC)  lp->stats.collisions++;
lp1244drivers/net/de4x5.cif (status & TD_EC)  lp->pktStats.excessive_collisions++;
lp1245drivers/net/de4x5.cif (status & TD_DE)  lp->stats.tx_aborted_errors++;
lp1249drivers/net/de4x5.clp->lostMedia++;
lp1250drivers/net/de4x5.cif (lp->lostMedia > LOST_MEDIA_THRESHOLD) { /* Trip autosense */
lp1257drivers/net/de4x5.clp->stats.tx_packets++;
lp1258drivers/net/de4x5.clp->lostMedia = 0;                         /* Remove transient problem */
lp1261drivers/net/de4x5.cif (lp->skb[entry] != NULL) {
lp1262drivers/net/de4x5.cdev_kfree_skb(lp->skb[entry], FREE_WRITE);
lp1263drivers/net/de4x5.clp->skb[entry] = NULL;
lp1267drivers/net/de4x5.clp->tx_old = (++lp->tx_old) % lp->txRingSize;
lp1276drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1282drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp1284drivers/net/de4x5.cif (((lp->media == _100Mb) &&  (gep & GEP_SLNK)) ||
lp1285drivers/net/de4x5.c((lp->media == _10Mb)  &&  (gep & GEP_LNP))  ||
lp1286drivers/net/de4x5.c((lp->media == _10Mb)  && !(gep & GEP_SLNK)) ||
lp1287drivers/net/de4x5.c(lp->media == NC)) {
lp1288drivers/net/de4x5.cif (lp->linkProb || ((lp->media == NC) && (!(gep & GEP_LNP)))) {
lp1289drivers/net/de4x5.clp->lostMedia = LOST_MEDIA_THRESHOLD + 1;
lp1290drivers/net/de4x5.clp->linkProb = 0;
lp1293drivers/net/de4x5.cswitch(lp->media) {
lp1295drivers/net/de4x5.clp->linkProb = 0;
lp1300drivers/net/de4x5.clp->linkProb = 1;                    /* Flag a potential problem */
lp1305drivers/net/de4x5.clp->linkProb = 1;                    /* Flag a potential problem */
lp1311drivers/net/de4x5.clp->linkProb = 0;                        /* Link OK */
lp1322drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1350drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp1361drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1364drivers/net/de4x5.clp->stats.rx_missed_errors = (int) (inl(DE4X5_MFC) & (MFC_OVFL | MFC_CNTR));
lp1366drivers/net/de4x5.creturn &lp->stats;
lp1371drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1373drivers/net/de4x5.clp->tx_ring[lp->tx_new].buf = virt_to_bus(buf);
lp1374drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 &= TD_TER;
lp1375drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 |= flags;
lp1376drivers/net/de4x5.clp->skb[lp->tx_new] = skb;
lp1378drivers/net/de4x5.clp->tx_ring[lp->tx_new].status = T_OWN;
lp1396drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1403drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp1404drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp1407drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET | 
lp1411drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1432drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1442drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp1466drivers/net/de4x5.clp->setup_frame[byte] |= bit;
lp1500drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1506drivers/net/de4x5.clp->bus = EISA;
lp1524drivers/net/de4x5.clp->bus = EISA;
lp1525drivers/net/de4x5.clp->chipset = device;
lp1571drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1576drivers/net/de4x5.clp->bus = PCI;
lp1596drivers/net/de4x5.clp->device = dev_num;
lp1597drivers/net/de4x5.clp->bus_num = pb;
lp1600drivers/net/de4x5.clp->chipset = device;
lp1759drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1762drivers/net/de4x5.clp->tx_enable = YES;
lp1764drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp1771drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp1772drivers/net/de4x5.clp->media = (lp->autosense == AUTO ? TP : lp->autosense);
lp1774drivers/net/de4x5.c} else if (lp->chipset == DC21041) {
lp1775drivers/net/de4x5.clp->media = (lp->autosense == AUTO ? TP_NW : lp->autosense);
lp1777drivers/net/de4x5.c} else if (lp->chipset == DC21140) {
lp1779drivers/net/de4x5.clp->media = (lp->autosense == AUTO ? _10Mb : lp->autosense);
lp1784drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp1785drivers/net/de4x5.cprintk("media is %s\n", (lp->media == NC  ? "unconnected!" :
lp1786drivers/net/de4x5.c(lp->media == TP  ? "TP." :
lp1787drivers/net/de4x5.c(lp->media == ANS ? "TP/Nway." :
lp1788drivers/net/de4x5.c(lp->media == BNC ? "BNC." : 
lp1789drivers/net/de4x5.c(lp->media == AUI ? "AUI." : 
lp1793drivers/net/de4x5.cprintk("mode is %s\n",(lp->media == NC      ? "link down.":
lp1794drivers/net/de4x5.c(lp->media == _100Mb  ? "100Mb/s." :
lp1795drivers/net/de4x5.c(lp->media == _10Mb   ? "10Mb/s." :
lp1801drivers/net/de4x5.cif (lp->media) {
lp1802drivers/net/de4x5.clp->lostMedia = 0;
lp1804drivers/net/de4x5.cif ((lp->media == TP) || (lp->media == ANS)) {
lp1805drivers/net/de4x5.clp->irq_mask |= IMR_LFM;
lp1810drivers/net/de4x5.creturn (lp->media);
lp1815drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1820drivers/net/de4x5.cswitch (lp->media) {
lp1827drivers/net/de4x5.cif (linkBad && (lp->autosense == AUTO)) {
lp1828drivers/net/de4x5.clp->media = BNC_AUI;
lp1839drivers/net/de4x5.cif (linkBad && (lp->autosense == AUTO)) {
lp1840drivers/net/de4x5.clp->media = NC;
lp1866drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1870drivers/net/de4x5.cswitch (lp->media) {
lp1878drivers/net/de4x5.clp->media = ANS;
lp1880drivers/net/de4x5.clp->media = AUI;
lp1889drivers/net/de4x5.cif (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
lp1890drivers/net/de4x5.clp->media = TP;
lp1901drivers/net/de4x5.cif (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
lp1903drivers/net/de4x5.clp->media = AUI;
lp1905drivers/net/de4x5.clp->media = BNC;
lp1917drivers/net/de4x5.cif (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
lp1918drivers/net/de4x5.clp->media = BNC;
lp1929drivers/net/de4x5.cif (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
lp1930drivers/net/de4x5.clp->media = NC;
lp1932drivers/net/de4x5.cif (ping_media(dev)) lp->media = NC;
lp1951drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1955drivers/net/de4x5.cswitch(lp->media) {
lp1977drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2029drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2037drivers/net/de4x5.centry = lp->tx_new;                        /* Remember the ring position */
lp2043drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp2044drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp2049drivers/net/de4x5.cif (lp->tx_ring[entry].status >= 0) linkBad=0;
lp2054drivers/net/de4x5.creturn ((linkBad || (lp->tx_ring[entry].status & TD_ES)) ? 1 : 0);
lp2063drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2090drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2106drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2110drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp2228drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp2234drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2236drivers/net/de4x5.cif (lp->bus == PCI) {
lp2258drivers/net/de4x5.cshort *p = (short *)&lp->srom;
lp2272drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp2278drivers/net/de4x5.cif (lp->bus == PCI) {
lp2279drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2287drivers/net/de4x5.cdev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
lp2288drivers/net/de4x5.cdev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
lp2301drivers/net/de4x5.cif (lp->bus == PCI) {
lp2302drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2425drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2427drivers/net/de4x5.cchar *pa = lp->setup_frame;
lp2431drivers/net/de4x5.cmemset(lp->setup_frame, 0, SETUP_FRAME_LEN);
lp2434drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp2435drivers/net/de4x5.cfor (pa=lp->setup_frame+IMPERF_PA_OFFSET, i=0; i<ETH_ALEN; i++) {
lp2439drivers/net/de4x5.c*(lp->setup_frame + (HASH_TABLE_LEN >> 3) - 3) = 0x80; /* B'cast address */
lp2456drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2459drivers/net/de4x5.clp->irq_mask |= IMR_TMM;
lp2460drivers/net/de4x5.coutl(lp->irq_mask, DE4X5_IMR);
lp2468drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2471drivers/net/de4x5.clp->irq_mask &= ~IMR_TMM;
lp2472drivers/net/de4x5.coutl(lp->irq_mask, DE4X5_IMR);
lp2498drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2536drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp2537drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp2540drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET | 
lp2543drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp2577drivers/net/de4x5.cmemcpy_tofs(ioc->data, lp->setup_frame, ioc->len); 
lp2614drivers/net/de4x5.cioc->len = sizeof(lp->pktStats);
lp2620drivers/net/de4x5.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
lp2627drivers/net/de4x5.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp2676drivers/net/de4x5.ctmp.addr[j++] = lp->rxRingSize;
lp2677drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->rx_ring; j+=4;
lp2678drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->tx_ring; j+=4;
lp2680drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp2682drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp2685drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp2686drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp2688drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp2691drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp2693drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp2695drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->rx_ring[i].buf; j+=4;
lp2698drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->rx_ring[i].buf; j+=4;
lp2699drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp2701drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->tx_ring[i].buf; j+=4;
lp2704drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->tx_ring[i].buf; j+=4;
lp2706drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize;i++){
lp2707drivers/net/de4x5.ctmp.lval[j>>2] = lp->rx_ring[i].status; j+=4;
lp2709drivers/net/de4x5.cfor (i=0;i<lp->txRingSize;i++){
lp2710drivers/net/de4x5.ctmp.lval[j>>2] = lp->tx_ring[i].status; j+=4;
lp2722drivers/net/de4x5.ctmp.addr[j++] = lp->txRingSize;
lp2763drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *) thisDE4X5.priv;
lp2768drivers/net/de4x5.cif (lp) {
lp2769drivers/net/de4x5.ckfree_s(bus_to_virt(lp->rx_ring[0].buf), RX_BUFF_SZ * NUM_RX_DESC + ALIGN);
lp2774drivers/net/de4x5.crelease_region(thisDE4X5.base_addr, (lp->bus == PCI ? 
lp16drivers/net/de4x5.h#define DE4X5_BMR    iobase+(0x000 << lp->bus)  /* Bus Mode Register */
lp17drivers/net/de4x5.h#define DE4X5_TPD    iobase+(0x008 << lp->bus)  /* Transmit Poll Demand Reg */
lp18drivers/net/de4x5.h#define DE4X5_RPD    iobase+(0x010 << lp->bus)  /* Receive Poll Demand Reg */
lp19drivers/net/de4x5.h#define DE4X5_RRBA   iobase+(0x018 << lp->bus)  /* RX Ring Base Address Reg */
lp20drivers/net/de4x5.h#define DE4X5_TRBA   iobase+(0x020 << lp->bus)  /* TX Ring Base Address Reg */
lp21drivers/net/de4x5.h#define DE4X5_STS    iobase+(0x028 << lp->bus)  /* Status Register */
lp22drivers/net/de4x5.h#define DE4X5_OMR    iobase+(0x030 << lp->bus)  /* Operation Mode Register */
lp23drivers/net/de4x5.h#define DE4X5_IMR    iobase+(0x038 << lp->bus)  /* Interrupt Mask Register */
lp24drivers/net/de4x5.h#define DE4X5_MFC    iobase+(0x040 << lp->bus)  /* Missed Frame Counter */
lp25drivers/net/de4x5.h#define DE4X5_APROM  iobase+(0x048 << lp->bus)  /* Ethernet Address PROM */
lp26drivers/net/de4x5.h#define DE4X5_BROM   iobase+(0x048 << lp->bus)  /* Boot ROM Register */
lp27drivers/net/de4x5.h#define DE4X5_SROM   iobase+(0x048 << lp->bus)  /* Serial ROM Register */
lp28drivers/net/de4x5.h#define DE4X5_DDR    iobase+(0x050 << lp->bus)  /* Data Diagnostic Register */
lp29drivers/net/de4x5.h#define DE4X5_FDR    iobase+(0x058 << lp->bus)  /* Full Duplex Register */
lp30drivers/net/de4x5.h#define DE4X5_GPT    iobase+(0x058 << lp->bus)  /* General Purpose Timer Reg.*/
lp31drivers/net/de4x5.h#define DE4X5_GEP    iobase+(0x060 << lp->bus)  /* General Purpose Register */
lp32drivers/net/de4x5.h#define DE4X5_SISR   iobase+(0x060 << lp->bus)  /* SIA Status Register */
lp33drivers/net/de4x5.h#define DE4X5_SICR   iobase+(0x068 << lp->bus)  /* SIA Connectivity Register */
lp34drivers/net/de4x5.h#define DE4X5_STRR   iobase+(0x070 << lp->bus)  /* SIA TX/RX Register */
lp35drivers/net/de4x5.h#define DE4X5_SIGR   iobase+(0x078 << lp->bus)  /* SIA General Register */
lp360drivers/net/depca.c#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
lp361drivers/net/depca.clp->tx_old+lp->txRingMask-lp->tx_new:\
lp362drivers/net/depca.clp->tx_old               -lp->tx_new-1)
lp452drivers/net/depca.cstruct depca_private *lp;
lp516drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp518drivers/net/depca.clp->adapter = adapter;
lp519drivers/net/depca.csprintf(lp->adapter_name,"%s (%s)", name, dev->name);
lp520drivers/net/depca.crequest_region(ioaddr, DEPCA_TOTAL_SIZE, lp->adapter_name);
lp523drivers/net/depca.clp->sh_mem = mem_start;
lp528drivers/net/depca.clp->rx_ring = (struct depca_rx_desc *)mem_start;
lp531drivers/net/depca.clp->tx_ring = (struct depca_tx_desc *)mem_start;
lp534drivers/net/depca.clp->bus_offset = mem_start & 0x00ff0000;
lp537drivers/net/depca.clp->dma_buffs = mem_start;
lp540drivers/net/depca.clp->rxRingMask = NUM_RX_DESC - 1;
lp541drivers/net/depca.clp->txRingMask = NUM_TX_DESC - 1;
lp544drivers/net/depca.cfor (i=0, j = lp->rxRingMask; j>0; i++) {
lp547drivers/net/depca.clp->rx_rlen = (s32)(i << 29);
lp548drivers/net/depca.cfor (i=0, j = lp->txRingMask; j>0; i++) {
lp551drivers/net/depca.clp->tx_rlen = (s32)(i << 29);
lp571drivers/net/depca.cswitch (lp->adapter) {
lp657drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp661drivers/net/depca.cstruct depca_init *p = (struct depca_init *)lp->sh_mem;
lp663drivers/net/depca.cif (request_irq(dev->irq, &depca_interrupt, 0, lp->adapter_name)) {
lp684drivers/net/depca.cmemcpy_toio((char *)lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
lp688drivers/net/depca.cprintk("\t0x%lx  0x%lx\n",(u_long)lp->rx_ring, (u_long)lp->tx_ring);
lp690drivers/net/depca.cfor (i=0;i<lp->rxRingMask;i++){
lp692drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
lp695drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
lp697drivers/net/depca.cfor (i=0;i<lp->txRingMask;i++){
lp699drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
lp702drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
lp704drivers/net/depca.cfor (i=0;i<lp->rxRingMask;i++){
lp706drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->rx_ring[i].base));
lp709drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
lp711drivers/net/depca.cfor (i=0;i<lp->txRingMask;i++){
lp713drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->tx_ring[i].base));
lp716drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
lp718drivers/net/depca.cprintk("Initialisation block at 0x%8.8lx\n",lp->sh_mem);
lp732drivers/net/depca.cprintk("dma_buffs: 0x%8.8lx\n",lp->dma_buffs);
lp734drivers/net/depca.c(int)lp->rxRingMask + 1, 
lp735drivers/net/depca.clp->rx_rlen);
lp737drivers/net/depca.c(int)lp->txRingMask + 1, 
lp738drivers/net/depca.clp->tx_rlen);
lp772drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp779drivers/net/depca.clp->rx_new = lp->tx_new = 0;
lp780drivers/net/depca.clp->rx_old = lp->tx_old = 0;
lp783drivers/net/depca.cfor (i = 0; i <= lp->rxRingMask; i++) {
lp784drivers/net/depca.cwritel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
lp785drivers/net/depca.cwritew(-RX_BUFF_SZ, &lp->rx_ring[i].buf_length);
lp786drivers/net/depca.clp->rx_memcpy[i]=(char *)(p+lp->bus_offset);
lp788drivers/net/depca.cfor (i = 0; i <= lp->txRingMask; i++) {
lp789drivers/net/depca.cwritel((p=lp->dma_buffs+(i+lp->txRingMask+1)*TX_BUFF_SZ) & 0x00ffffff,
lp790drivers/net/depca.c&lp->tx_ring[i].base);
lp791drivers/net/depca.clp->tx_memcpy[i]=(char *)(p+lp->bus_offset);
lp795drivers/net/depca.clp->init_block.rx_ring = ((u32)((u_long)lp->rx_ring)&LA_MASK) | lp->rx_rlen;
lp796drivers/net/depca.clp->init_block.tx_ring = ((u32)((u_long)lp->tx_ring)&LA_MASK) | lp->tx_rlen;
lp801drivers/net/depca.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp804drivers/net/depca.clp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */
lp815drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp876drivers/net/depca.cstruct depca_private *lp;
lp883drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp926drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp930drivers/net/depca.cfor (entry=lp->rx_new; 
lp931drivers/net/depca.c!(readl(&lp->rx_ring[entry].base) & R_OWN);
lp932drivers/net/depca.centry=lp->rx_new){
lp933drivers/net/depca.cstatus = readl(&lp->rx_ring[entry].base) >> 16 ;
lp935drivers/net/depca.clp->rx_old = entry;
lp939drivers/net/depca.clp->stats.rx_errors++;                 /* Update the error stats. */
lp940drivers/net/depca.cif (status & R_FRAM) lp->stats.rx_frame_errors++;
lp941drivers/net/depca.cif (status & R_OFLO) lp->stats.rx_over_errors++;
lp942drivers/net/depca.cif (status & R_CRC)  lp->stats.rx_crc_errors++;
lp943drivers/net/depca.cif (status & R_BUFF) lp->stats.rx_fifo_errors++;
lp945drivers/net/depca.cshort len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
lp954drivers/net/depca.cif (entry < lp->rx_old) {         /* Wrapped buffer */
lp955drivers/net/depca.clen = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
lp956drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], len);
lp957drivers/net/depca.cmemcpy_fromio(buf + len, lp->rx_memcpy[0], pkt_len-len);
lp959drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], pkt_len);
lp972drivers/net/depca.clp->stats.rx_packets++;
lp975drivers/net/depca.clp->pktStats.bins[i]++;
lp981drivers/net/depca.clp->pktStats.broadcast++;
lp983drivers/net/depca.clp->pktStats.multicast++;
lp987drivers/net/depca.clp->pktStats.unicast++;
lp990drivers/net/depca.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp991drivers/net/depca.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp992drivers/net/depca.cmemset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
lp996drivers/net/depca.clp->stats.rx_dropped++;  /* Really, deferred. */
lp1001drivers/net/depca.cfor (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)&lp->rxRingMask) {
lp1002drivers/net/depca.cwritel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, 
lp1003drivers/net/depca.c&lp->rx_ring[lp->rx_old].base);
lp1005drivers/net/depca.cwritel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
lp1011drivers/net/depca.clp->rx_new = (++lp->rx_new) & lp->rxRingMask;
lp1023drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1028drivers/net/depca.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
lp1029drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].base) >> 16 ;
lp1034drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].misc);
lp1035drivers/net/depca.clp->stats.tx_errors++;
lp1036drivers/net/depca.cif (status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
lp1037drivers/net/depca.cif (status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
lp1038drivers/net/depca.cif (status & TMD3_LCOL) lp->stats.tx_window_errors++;
lp1039drivers/net/depca.cif (status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
lp1046drivers/net/depca.clp->stats.collisions++;
lp1048drivers/net/depca.clp->stats.tx_packets++;
lp1052drivers/net/depca.clp->tx_old = (++lp->tx_old) & lp->txRingMask;
lp1061drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1084drivers/net/depca.cif (lp->adapter != DEPCA) {
lp1103drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1107drivers/net/depca.coutw((u16)(lp->sh_mem & LA_MASK), DEPCA_DATA);
lp1109drivers/net/depca.coutw((u16)((lp->sh_mem & LA_MASK) >> 16), DEPCA_DATA);
lp1120drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1125drivers/net/depca.cmemcpy_toio((char *)lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
lp1138drivers/net/depca.cdev->name, i, lp->sh_mem, inw(DEPCA_DATA));
lp1142drivers/net/depca.cdev->name, i, lp->sh_mem, inw(DEPCA_DATA));
lp1152drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1156drivers/net/depca.creturn &lp->stats;
lp1169drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1175drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1182drivers/net/depca.clp->init_block.mode &= ~PROM;   /* Unset promiscuous mode */
lp1184drivers/net/depca.clp->init_block.mode |= PROM;    /* Set promiscuous mode */
lp1201drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1208drivers/net/depca.clp->init_block.mcast_table[i] = (char)0xff;
lp1213drivers/net/depca.clp->init_block.mcast_table[i]=0;
lp1234drivers/net/depca.clp->init_block.mcast_table[byte] |= bit;
lp1569drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1572drivers/net/depca.centry = lp->tx_new;                     /* Ring around buffer number. */
lp1573drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
lp1574drivers/net/depca.cif (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
lp1580drivers/net/depca.clen = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
lp1581drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
lp1582drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
lp1584drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
lp1589drivers/net/depca.cfor (i = entry; i != end; i = (++i) & lp->txRingMask) {
lp1591drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
lp1592drivers/net/depca.cwritew(0x0000, &lp->tx_ring[i].misc);       /* clears other error flags */
lp1593drivers/net/depca.cwritew(-TX_BUFF_SZ, &lp->tx_ring[i].length);/* packet length in buffer */
lp1597drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
lp1598drivers/net/depca.cwritew(0x0000, &lp->tx_ring[end].misc);       /* clears other error flags */
lp1599drivers/net/depca.cwritew(-len, &lp->tx_ring[end].length);       /* packet length in last buff */
lp1602drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
lp1604drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
lp1608drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
lp1609drivers/net/depca.cif (i == 0) i=lp->txRingMask+1;
lp1611drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
lp1613drivers/net/depca.clp->tx_new = (++end) & lp->txRingMask;     /* update current pointers */
lp1661drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1691drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);/* Wait for the ring to empty */
lp1708drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1712drivers/net/depca.clp->init_block.mode |= PROM;      /* Set promiscuous mode */
lp1726drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1730drivers/net/depca.clp->init_block.mode &= ~PROM;     /* Clear promiscuous mode */
lp1747drivers/net/depca.cmemcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len); 
lp1784drivers/net/depca.cioc->len = sizeof(lp->pktStats);
lp1786drivers/net/depca.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
lp1794drivers/net/depca.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1806drivers/net/depca.cmemcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
lp509drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp517drivers/net/eepro.clp->eepro = 1; /* Yes, an Intel EtherExpress Pro/10 */
lp518drivers/net/eepro.celse lp->eepro = 0; /* No, it is a generic 82585 lan card */
lp574drivers/net/eepro.clp->rx_start = (RCV_LOWER_LIMIT << 8) ;
lp585drivers/net/eepro.clp->tx_start = lp->tx_end = XMT_LOWER_LIMIT << 8; /* or = RCV_RAM */
lp586drivers/net/eepro.clp->tx_last = 0;  
lp606drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp621drivers/net/eepro.clp->stats.tx_errors++;
lp629drivers/net/eepro.clp->tx_start = lp->tx_end = RCV_RAM; 
lp630drivers/net/eepro.clp->tx_last = 0;
lp726drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp743drivers/net/eepro.clp->tx_start = lp->tx_end = RCV_RAM ;
lp744drivers/net/eepro.clp->tx_last = 0;  
lp777drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp779drivers/net/eepro.creturn &lp->stats;
lp791drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp835drivers/net/eepro.coutw(lp->tx_end, ioaddr + HOST_ADDRESS_REG);
lp849drivers/net/eepro.coutw(lp->tx_end, ioaddr + XMT_BAR);
lp853drivers/net/eepro.ci = lp->tx_end + XMT_HEADER + 6*(num_addrs + 1);
lp854drivers/net/eepro.cif (lp->tx_start != lp->tx_end) { 
lp857drivers/net/eepro.coutw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
lp859drivers/net/eepro.coutw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
lp862drivers/net/eepro.clp->tx_end = i ;
lp863drivers/net/eepro.c} else lp->tx_start = lp->tx_end = i ;
lp941drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp951drivers/net/eepro.cif (lp->tx_end > lp->tx_start)
lp952drivers/net/eepro.ctx_available = XMT_RAM - (lp->tx_end - lp->tx_start);
lp953drivers/net/eepro.celse if (lp->tx_end < lp->tx_start)
lp954drivers/net/eepro.ctx_available = lp->tx_start - lp->tx_end;
lp966drivers/net/eepro.clast = lp->tx_end;
lp986drivers/net/eepro.cif (lp->tx_start != lp->tx_end) { 
lp989drivers/net/eepro.cif (lp->tx_end != last) {
lp990drivers/net/eepro.coutw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
lp993drivers/net/eepro.coutw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
lp1004drivers/net/eepro.cif (lp->tx_start == lp->tx_end) {
lp1007drivers/net/eepro.clp->tx_start = last;   /* I don't like to change tx_start here */
lp1011drivers/net/eepro.clp->tx_last = last;
lp1012drivers/net/eepro.clp->tx_end = end;
lp1031drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp1034drivers/net/eepro.cshort rcv_car = lp->rx_start;
lp1057drivers/net/eepro.clp->stats.rx_dropped++;
lp1067drivers/net/eepro.clp->stats.rx_packets++;
lp1071drivers/net/eepro.clp->stats.rx_errors++;
lp1073drivers/net/eepro.clp->stats.rx_over_errors++;
lp1075drivers/net/eepro.clp->stats.rx_frame_errors++;
lp1077drivers/net/eepro.clp->stats.rx_crc_errors++;
lp1082drivers/net/eepro.clp->stats.rx_length_errors++;
lp1086drivers/net/eepro.crcv_car = lp->rx_start + RCV_HEADER + rcv_size;
lp1087drivers/net/eepro.clp->rx_start = rcv_next_frame;
lp1103drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp1108drivers/net/eepro.cwhile (lp->tx_start != lp->tx_end) { 
lp1110drivers/net/eepro.coutw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
lp1114drivers/net/eepro.clp->tx_start = inw(ioaddr+IO_PORT);
lp1122drivers/net/eepro.clp->stats.tx_packets++;
lp1124drivers/net/eepro.clp->stats.tx_errors++;
lp1126drivers/net/eepro.clp->stats.tx_carrier_errors++;
lp1131drivers/net/eepro.clp->stats.collisions += (xmt_status & 0x000f);
lp1133drivers/net/eepro.clp->stats.tx_heartbeat_errors++;
lp459drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp472drivers/net/eexpress.clp->stats.tx_errors++;
lp474drivers/net/eexpress.cif (lp->last_restart == lp->stats.tx_packets) {
lp483drivers/net/eexpress.clp->last_restart = lp->stats.tx_packets;
lp515drivers/net/eexpress.clp->stats.tx_aborted_errors++;
lp526drivers/net/eexpress.cstruct net_local *lp;
lp537drivers/net/eexpress.clp = (struct net_local *)dev->priv;
lp549drivers/net/eexpress.cwhile (lp->tx_reap != lp->tx_head) {   /* if (status & 0x8000) */
lp551drivers/net/eexpress.coutw(lp->tx_reap, ioaddr + READ_PTR);
lp554drivers/net/eexpress.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp558drivers/net/eexpress.clp->stats.tx_packets++;
lp559drivers/net/eexpress.clp->stats.collisions += tx_status & 0xf;
lp563drivers/net/eexpress.clp->stats.tx_errors++;
lp564drivers/net/eexpress.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp565drivers/net/eexpress.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp566drivers/net/eexpress.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp567drivers/net/eexpress.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp570drivers/net/eexpress.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp571drivers/net/eexpress.clp->tx_reap += TX_BUF_SIZE;
lp572drivers/net/eexpress.cif (lp->tx_reap > TX_BUF_END - TX_BUF_SIZE)
lp573drivers/net/eexpress.clp->tx_reap = TX_BUF_START;
lp580drivers/net/eexpress.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp599drivers/net/eexpress.clp->tx_cmd_link = IDLELOOP + 4;
lp600drivers/net/eexpress.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp610drivers/net/eexpress.clp->stats.rx_errors++;
lp614drivers/net/eexpress.cdev->name, status, lp->rx_head, lp->rx_tail);
lp675drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp679drivers/net/eexpress.creturn &lp->stats;
lp759drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp779drivers/net/eexpress.clp->tx_cmd_link = DUMP_DATA + 4;
lp781drivers/net/eexpress.clp->tx_cmd_link = IDLELOOP + 4;
lp783drivers/net/eexpress.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp817drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp820drivers/net/eexpress.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp844drivers/net/eexpress.clp->rx_tail = cur_rxbuf;
lp850drivers/net/eexpress.coutw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
lp852drivers/net/eexpress.coutw(lp->rx_head, ioaddr);        /* Link */
lp858drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp860drivers/net/eexpress.cshort tx_block = lp->tx_head;
lp885drivers/net/eexpress.coutw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
lp887drivers/net/eexpress.clp->tx_cmd_link = tx_block + 20;
lp890drivers/net/eexpress.clp->tx_head = tx_block + TX_BUF_SIZE;
lp891drivers/net/eexpress.cif (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
lp892drivers/net/eexpress.clp->tx_head = TX_BUF_START;
lp897drivers/net/eexpress.ctx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
lp900drivers/net/eexpress.cif (lp->tx_head != lp->tx_reap)
lp907drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp910drivers/net/eexpress.cshort rx_head = lp->rx_head;
lp911drivers/net/eexpress.cshort rx_tail = lp->rx_tail;
lp935drivers/net/eexpress.clp->stats.rx_errors++;
lp936drivers/net/eexpress.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp937drivers/net/eexpress.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp938drivers/net/eexpress.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp939drivers/net/eexpress.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp940drivers/net/eexpress.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp949drivers/net/eexpress.clp->stats.rx_dropped++;
lp961drivers/net/eexpress.clp->stats.rx_packets++;
lp998drivers/net/eexpress.clp->rx_head = rx_head;
lp999drivers/net/eexpress.clp->rx_tail = rx_tail;
lp399drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp553drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp555drivers/net/ewrk3.clp->shmem_base = mem_start;
lp556drivers/net/ewrk3.clp->shmem_length = shmem_length;
lp557drivers/net/ewrk3.clp->lemac = lemac;
lp558drivers/net/ewrk3.clp->hard_strapped = hard_strapped;
lp560drivers/net/ewrk3.clp->mPage = 64;
lp561drivers/net/ewrk3.cif (cmr & DRAM) lp->mPage <<= 1 ;     /* 2 DRAMS on module */ 
lp652drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp662drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp683drivers/net/ewrk3.cif (lp->shmem_length == 0) {
lp686drivers/net/ewrk3.cprintk("\tstart of shared memory: 0x%08lx\n",lp->shmem_base);
lp687drivers/net/ewrk3.cprintk("\twindow length: 0x%04lx\n",lp->shmem_length);
lp729drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp749drivers/net/ewrk3.cfor (page=1;page<lp->mPage;page++) {      /* Write the free page numbers */
lp753drivers/net/ewrk3.clp->lock = 0;                             /* Ensure there are no locks */
lp764drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp770drivers/net/ewrk3.cif (dev->tbusy || lp->lock) {
lp774drivers/net/ewrk3.c} else if (!lp->hard_strapped) {
lp818drivers/net/ewrk3.cif ((page = inb(EWRK3_FMQ)) < lp->mPage) {
lp824drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp825drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp827drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp828drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp830drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp831drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp833drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp834drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp848drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp863drivers/net/ewrk3.cif (lp->txc) {
lp886drivers/net/ewrk3.clp->lock = 0;         /* unlock the page register */
lp914drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp921drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp978drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp984drivers/net/ewrk3.cif ((page = inb(EWRK3_RQ)) < lp->mPage) {/* Get next entry's buffer page */
lp991drivers/net/ewrk3.cif ((tmpLock = set_bit(0, (void *)&lp->lock)) == 1) {   /* Assert lock */
lp992drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {              /* Get existing page */
lp1002drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1004drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp1005drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp1007drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp1008drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp1010drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp1011drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp1022drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1033drivers/net/ewrk3.clp->stats.rx_errors++;            /* Update the error stats. */
lp1034drivers/net/ewrk3.cif (rx_status & DBE) lp->stats.rx_frame_errors++;
lp1035drivers/net/ewrk3.cif (rx_status & CRC) lp->stats.rx_crc_errors++;
lp1036drivers/net/ewrk3.cif (rx_status & PLL) lp->stats.rx_fifo_errors++;
lp1046drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1066drivers/net/ewrk3.clp->stats.rx_packets++;
lp1069drivers/net/ewrk3.clp->pktStats.bins[i]++;
lp1076drivers/net/ewrk3.clp->pktStats.broadcast++;
lp1078drivers/net/ewrk3.clp->pktStats.multicast++;
lp1082drivers/net/ewrk3.clp->pktStats.unicast++;
lp1085drivers/net/ewrk3.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1086drivers/net/ewrk3.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1087drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1091drivers/net/ewrk3.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1102drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {    /* Replace old page */
lp1108drivers/net/ewrk3.clp->lock = 0;                           /* Unlock the page register */
lp1123drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1130drivers/net/ewrk3.clp->stats.tx_errors++;
lp1131drivers/net/ewrk3.cif (tx_status & MAC_NCL)    lp->stats.tx_carrier_errors++;
lp1132drivers/net/ewrk3.cif (tx_status & MAC_LCL)    lp->stats.tx_window_errors++;
lp1135drivers/net/ewrk3.clp->pktStats.tx_underruns++;
lp1137drivers/net/ewrk3.clp->pktStats.excessive_underruns++;
lp1141drivers/net/ewrk3.clp->stats.collisions++;
lp1143drivers/net/ewrk3.clp->pktStats.excessive_collisions++;
lp1147drivers/net/ewrk3.clp->stats.tx_packets++;
lp1158drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1187drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp1203drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1207drivers/net/ewrk3.creturn &lp->stats;
lp1220drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1227drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1230drivers/net/ewrk3.cmulticast_table = (char *)(lp->shmem_base + PAGE0_HTE);
lp1255drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1262drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1264drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1273drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1282drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1310drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1327drivers/net/ewrk3.clp->lock = 0;                              /* Unlock the page register */
lp1615drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1687drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1688drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1696drivers/net/ewrk3.cmemcpy(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
lp1700drivers/net/ewrk3.clp->lock = 0;                               /* Unlock the page register */
lp1737drivers/net/ewrk3.cerr = verify_area(VERIFY_WRITE, (void *)ioc->data, sizeof(lp->pktStats));
lp1741drivers/net/ewrk3.cmemcpy_tofs(ioc->data, &lp->pktStats, sizeof(lp->pktStats)); 
lp1749drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1820drivers/net/ewrk3.clp->txc = 1;
lp1828drivers/net/ewrk3.clp->txc = 0;
lp311drivers/net/hp100.cstruct hp100_private *lp;
lp414drivers/net/hp100.clp = (struct hp100_private *)dev -> priv;
lp415drivers/net/hp100.clp -> id = eid;
lp416drivers/net/hp100.clp -> mem_mapped = mem_mapped;
lp417drivers/net/hp100.clp -> mem_ptr_phys = mem_ptr_phys;
lp418drivers/net/hp100.clp -> mem_ptr_virt = mem_ptr_virt;
lp420drivers/net/hp100.clp -> soft_model = hp100_inb( SOFT_MODEL );
lp421drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;
lp422drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;
lp428drivers/net/hp100.clp -> memory_size = 0x200 << ( ( hp100_inb( SRAM ) & 0xe0 ) >> 5 );
lp429drivers/net/hp100.clp -> rx_ratio = hp100_rx_ratio;
lp449drivers/net/hp100.clp -> lan_type = hp100_sense_lan( dev );
lp452drivers/net/hp100.cdev -> name, lp -> id -> name, ioaddr, dev -> irq );
lp459drivers/net/hp100.clp -> memory_size >> ( 10 - 4 ), lp -> rx_ratio );
lp469drivers/net/hp100.cif ( lp -> lan_type != HP100_LAN_ERR )
lp471drivers/net/hp100.cswitch ( lp -> lan_type ) {
lp495drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp497drivers/net/hp100.cif ( request_irq( dev -> irq, hp100_interrupt, SA_INTERRUPT, lp -> id -> name ) )
lp513drivers/net/hp100.clp -> lan_type = hp100_sense_lan( dev );
lp514drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;
lp515drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;
lp544drivers/net/hp100.chp100_outw( ( lp -> memory_size * lp -> rx_ratio ) / 100, RX_MEM_STOP );
lp545drivers/net/hp100.chp100_outw( lp -> memory_size - 1, TX_MEM_STOP );
lp548drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp549drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp559drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp566drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )  /* relogin */
lp589drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp591drivers/net/hp100.cif ( lp -> lan_type < 0 )
lp594drivers/net/hp100.cif ( ( lp -> lan_type = hp100_sense_lan( dev ) ) < 0 )
lp600drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp601drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp611drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 && lp -> hub_status < 0 )
lp616drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp628drivers/net/hp100.cif ( lp -> lan_type != i )
lp632drivers/net/hp100.clp -> lan_type = i;
lp634drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp635drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp674drivers/net/hp100.cif ( lp -> mem_mapped )
lp676drivers/net/hp100.cif ( lp -> mem_ptr_virt )
lp678drivers/net/hp100.cmemcpy( lp -> mem_ptr_virt, skb -> data, skb -> len );
lp680drivers/net/hp100.cmemset( lp -> mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb -> len );
lp684drivers/net/hp100.cmemcpy_toio( lp -> mem_ptr_phys, skb -> data, skb -> len );
lp686drivers/net/hp100.cmemset_io( lp -> mem_ptr_phys, 0, HP100_MIN_PACKET_SIZE - skb -> len );
lp697drivers/net/hp100.clp -> stats.tx_packets++;
lp718drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp723drivers/net/hp100.cif ( lp -> lan_type < 0 )
lp725drivers/net/hp100.cif ( ( lp -> lan_type = hp100_sense_lan( dev ) ) == HP100_LAN_100 )
lp726drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp744drivers/net/hp100.cif ( lp -> mem_mapped )
lp746drivers/net/hp100.cif ( lp -> mem_ptr_virt )
lp747drivers/net/hp100.cheader = *(__u32 *)lp -> mem_ptr_virt;
lp749drivers/net/hp100.cheader = readl( lp -> mem_ptr_phys );
lp769drivers/net/hp100.clp -> stats.rx_dropped++;
lp777drivers/net/hp100.cif ( lp -> mem_mapped )
lp779drivers/net/hp100.cif ( lp -> mem_ptr_virt )
lp780drivers/net/hp100.cmemcpy( ptr, lp -> mem_ptr_virt, ( pkt_len + 3 ) & ~3 );
lp782drivers/net/hp100.cmemcpy_fromio( ptr, lp -> mem_ptr_phys, ( pkt_len + 3 ) & ~3 );
lp788drivers/net/hp100.clp -> stats.rx_packets++;
lp799drivers/net/hp100.clp -> stats.multicast++; break;
lp825drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp829drivers/net/hp100.clp -> stats.rx_errors += val;
lp830drivers/net/hp100.clp -> stats.rx_over_errors += val;
lp832drivers/net/hp100.clp -> stats.rx_errors += val;
lp833drivers/net/hp100.clp -> stats.rx_crc_errors += val;
lp835drivers/net/hp100.clp -> stats.tx_errors += val;
lp836drivers/net/hp100.clp -> stats.tx_aborted_errors += val;
lp869drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp881drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE6;  /* promiscuous mode, all good */
lp882drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE6;  /* packets on the net */
lp887drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE5;  /* multicast mode, packets for me */
lp888drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE5;  /* broadcasts and all multicasts */
lp892drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;  /* normal mode, packets for me */
lp893drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;  /* and broadcasts */
lp896drivers/net/hp100.chp100_outb( lp -> mac2_mode, MAC_CFG_2 );
lp898drivers/net/hp100.chp100_orb( lp -> mac1_mode |
lp915drivers/net/hp100.cstruct hp100_private *lp;
lp941drivers/net/hp100.clp = (struct hp100_private *)dev -> priv;
lp959drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp964drivers/net/hp100.chp100_outb( lp -> mac2_mode, MAC_CFG_2 );
lp966drivers/net/hp100.chp100_orb( lp -> mac1_mode |
lp972drivers/net/hp100.cif ( lp -> mem_mapped )
lp1020drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp1030drivers/net/hp100.cif ( lp -> id -> id == 0x02019F022 ) /* HP J27248B doesn't have 100Mb/s interface */
lp338drivers/net/lance.cstruct lance_private *lp;
lp408drivers/net/lance.clp = (struct lance_private *) kmalloc(sizeof(*lp), GFP_DMA | GFP_KERNEL);
lp409drivers/net/lance.cdev->priv = lp;
lp410drivers/net/lance.clp->name = chipname;
lp411drivers/net/lance.clp->rx_buffs = (unsigned long) kmalloc(PKT_BUF_SZ*RX_RING_SIZE, GFP_DMA | GFP_KERNEL);
lp412drivers/net/lance.clp->tx_bounce_buffs = NULL;
lp414drivers/net/lance.clp->tx_bounce_buffs = kmalloc(PKT_BUF_SZ*TX_RING_SIZE, GFP_DMA | GFP_KERNEL);
lp416drivers/net/lance.clp->chip_version = lance_version;
lp418drivers/net/lance.clp->init_block.mode = 0x0003;    /* Disable Rx and Tx. */
lp420drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp421drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp422drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp423drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp424drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp428drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp431drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp539drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
lp563drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp568drivers/net/lance.crequest_irq(dev->irq, &lance_interrupt, 0, lp->name)) {
lp587drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_MUST_UNRESET)
lp590drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
lp598drivers/net/lance.cdev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
lp599drivers/net/lance.c(int) &lp->init_block);
lp604drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp606drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp629drivers/net/lance.cdev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
lp649drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp653drivers/net/lance.cif (lp->tx_skbuff[i]) {
lp654drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[i],FREE_WRITE);
lp655drivers/net/lance.clp->tx_skbuff[i] = NULL;
lp665drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp668drivers/net/lance.clp->lock = 0, lp->tx_full = 0;
lp669drivers/net/lance.clp->cur_rx = lp->cur_tx = 0;
lp670drivers/net/lance.clp->dirty_rx = lp->dirty_tx = 0;
lp673drivers/net/lance.clp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
lp674drivers/net/lance.clp->rx_ring[i].buf_length = -PKT_BUF_SZ;
lp679drivers/net/lance.clp->tx_ring[i].base = 0;
lp682drivers/net/lance.clp->init_block.mode = 0x0000;
lp684drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp685drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp686drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp687drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp688drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp694drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp697drivers/net/lance.c(chip_table[lp->chip_version].flags & LANCE_MUST_REINIT_RING)) {
lp708drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp722drivers/net/lance.clp->stats.tx_errors++;
lp727drivers/net/lance.clp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
lp728drivers/net/lance.clp->cur_rx);
lp731drivers/net/lance.clp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
lp732drivers/net/lance.clp->rx_ring[i].msg_length);
lp735drivers/net/lance.clp->tx_ring[i].base, -lp->tx_ring[i].length,
lp736drivers/net/lance.clp->tx_ring[i].misc);
lp770drivers/net/lance.cif (set_bit(0, (void*)&lp->lock) != 0) {
lp780drivers/net/lance.centry = lp->cur_tx & TX_RING_MOD_MASK;
lp786drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_MUST_PAD) {
lp787drivers/net/lance.clp->tx_ring[entry].length =
lp790drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
lp792drivers/net/lance.clp->tx_ring[entry].misc = 0x0000;
lp800drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
lp801drivers/net/lance.clp->tx_ring[entry].base =
lp802drivers/net/lance.c(int)(lp->tx_bounce_buffs + entry) | 0x83000000;
lp805drivers/net/lance.clp->tx_skbuff[entry] = skb;
lp806drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
lp808drivers/net/lance.clp->cur_tx++;
lp818drivers/net/lance.clp->lock = 0;
lp819drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
lp822drivers/net/lance.clp->tx_full = 1;
lp833drivers/net/lance.cstruct lance_private *lp;
lp843drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp865drivers/net/lance.cint dirty_tx = lp->dirty_tx;
lp867drivers/net/lance.cwhile (dirty_tx < lp->cur_tx) {
lp869drivers/net/lance.cint status = lp->tx_ring[entry].base;
lp874drivers/net/lance.clp->tx_ring[entry].base = 0;
lp878drivers/net/lance.cint err_status = lp->tx_ring[entry].misc;
lp879drivers/net/lance.clp->stats.tx_errors++;
lp880drivers/net/lance.cif (err_status & 0x0400) lp->stats.tx_aborted_errors++;
lp881drivers/net/lance.cif (err_status & 0x0800) lp->stats.tx_carrier_errors++;
lp882drivers/net/lance.cif (err_status & 0x1000) lp->stats.tx_window_errors++;
lp885drivers/net/lance.clp->stats.tx_fifo_errors++;
lp894drivers/net/lance.clp->stats.collisions++;
lp895drivers/net/lance.clp->stats.tx_packets++;
lp900drivers/net/lance.cif (lp->tx_skbuff[entry]) {
lp901drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
lp902drivers/net/lance.clp->tx_skbuff[entry] = 0;
lp908drivers/net/lance.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp910drivers/net/lance.cdirty_tx, lp->cur_tx, lp->tx_full);
lp915drivers/net/lance.cif (lp->tx_full && dev->tbusy
lp916drivers/net/lance.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp918drivers/net/lance.clp->tx_full = 0;
lp923drivers/net/lance.clp->dirty_tx = dirty_tx;
lp927drivers/net/lance.cif (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
lp928drivers/net/lance.cif (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
lp960drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp961drivers/net/lance.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
lp965drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
lp966drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
lp974drivers/net/lance.clp->stats.rx_errors++; /* end of a packet.*/
lp975drivers/net/lance.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp976drivers/net/lance.cif (status & 0x10) lp->stats.rx_over_errors++;
lp977drivers/net/lance.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp978drivers/net/lance.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp979drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
lp982drivers/net/lance.cshort pkt_len = (lp->rx_ring[entry].msg_length & 0xfff)-4;
lp989drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
lp993drivers/net/lance.clp->stats.rx_dropped++;
lp994drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp995drivers/net/lance.clp->cur_rx++;
lp1003drivers/net/lance.c(unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
lp1007drivers/net/lance.clp->stats.rx_packets++;
lp1012drivers/net/lance.clp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
lp1013drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp1014drivers/net/lance.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
lp1027drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp1032drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
lp1034drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp1059drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp1064drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
lp1069drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp1074drivers/net/lance.creturn &lp->stats;
lp155drivers/net/pi2.cstatic void rts(struct pi_local *lp, int x);
lp156drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp);
lp157drivers/net/pi2.cstatic void b_txint(struct pi_local *lp);
lp158drivers/net/pi2.cstatic void b_exint(struct pi_local *lp);
lp159drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp);
lp160drivers/net/pi2.cstatic void a_txint(struct pi_local *lp);
lp161drivers/net/pi2.cstatic void a_exint(struct pi_local *lp);
lp199drivers/net/pi2.cstatic void switchbuffers(struct pi_local *lp)
lp201drivers/net/pi2.cif (lp->rcvbuf == lp->rxdmabuf1)
lp202drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf2;
lp204drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf1;
lp207drivers/net/pi2.cstatic void hardware_send_packet(struct pi_local *lp, struct sk_buff *skb)
lp212drivers/net/pi2.clp->stats.tx_packets++;
lp216drivers/net/pi2.ckickflag = (skb_peek(&lp->sndq) == NULL) && (lp->sndbuf == NULL);
lp219drivers/net/pi2.cskb_queue_tail(&lp->sndq, skb);
lp222drivers/net/pi2.cswitch (lp->base & 2) {
lp224drivers/net/pi2.ca_txint(lp);  /* process interrupt */
lp229drivers/net/pi2.cif (lp->tstate == IDLE)
lp230drivers/net/pi2.cb_txint(lp);
lp237drivers/net/pi2.cstatic void setup_rx_dma(struct pi_local *lp)
lp247drivers/net/pi2.cdma_abs = (unsigned long) (lp->rcvbuf->data);
lp248drivers/net/pi2.cdmachan = lp->dmachan;
lp249drivers/net/pi2.ccmd = lp->base + CTL;
lp255drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | WT_RDY_RT | INT_ERR_Rx | EXT_INT_ENAB);
lp265drivers/net/pi2.cset_dma_count(dmachan, lp->bufsiz);
lp271drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Rx_CRC);
lp274drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1,
lp280drivers/net/pi2.cstatic void setup_tx_dma(struct pi_local *lp, int length)
lp289drivers/net/pi2.cdmachan = lp->dmachan;
lp290drivers/net/pi2.cdma_abs = (unsigned long) (lp->txdmabuf);
lp308drivers/net/pi2.cstatic void tdelay(struct pi_local *lp, int time)
lp314drivers/net/pi2.cif (lp->base & 2) {    /* If A channel */
lp317drivers/net/pi2.cport = lp->cardbase + TMR1;
lp321drivers/net/pi2.cport = lp->cardbase + TMR2;
lp322drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R1, INT_ALL_Rx | EXT_INT_ENAB);
lp326drivers/net/pi2.coutb_p(sc | LSB_MSB | MODE0, lp->cardbase + TMRCMD);
lp333drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R15, CTSIE);
lp334drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_EXT_INT);
lp342drivers/net/pi2.cstatic void a_txint(struct pi_local *lp)
lp350drivers/net/pi2.ccmd = CTL + lp->base;
lp352drivers/net/pi2.cswitch (lp->tstate) {
lp355drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp356drivers/net/pi2.crts(lp, OFF);
lp366drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp367drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp368drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp369drivers/net/pi2.clp->tstate = DEFER;
lp370drivers/net/pi2.ctdelay(lp, 100);
lp372drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp376drivers/net/pi2.cif (random() > lp->persist) {
lp377drivers/net/pi2.clp->tstate = DEFER;
lp378drivers/net/pi2.ctdelay(lp, lp->slotime);
lp383drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp384drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp385drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp386drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp396drivers/net/pi2.cstatic void a_exint(struct pi_local *lp)
lp406drivers/net/pi2.cst = rdscc(lp->cardbase, lp->base + CTL, R0);  /* Fetch status */
lp409drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R0, RES_EXT_INT);
lp410drivers/net/pi2.ccmd = lp->base + CTL;
lp412drivers/net/pi2.cif ((lp->rstate >= ACTIVE) && (st & BRK_ABRT)) {
lp413drivers/net/pi2.csetup_rx_dma(lp);
lp414drivers/net/pi2.clp->rstate = ACTIVE;
lp416drivers/net/pi2.cswitch (lp->tstate) {
lp418drivers/net/pi2.cfree_p(lp->sndbuf);
lp419drivers/net/pi2.clp->sndbuf = NULL;
lp420drivers/net/pi2.clp->tstate = FLAGOUT;
lp421drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp424drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp426drivers/net/pi2.clp->tstate = IDLE;
lp427drivers/net/pi2.crts(lp, OFF);
lp434drivers/net/pi2.cdisable_dma(lp->dmachan);
lp437drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp442drivers/net/pi2.clength = lp->sndbuf->len - 1;
lp443drivers/net/pi2.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
lp447drivers/net/pi2.csetup_tx_dma(lp, length);
lp451drivers/net/pi2.cenable_dma(lp->dmachan);
lp454drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC | RES_Tx_P);
lp457drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
lp460drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_RDY_ENAB | WT_FN_RDYFN | EXT_INT_ENAB);
lp463drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
lp467drivers/net/pi2.clp->tstate = ACTIVE;
lp473drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp474drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp475drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp476drivers/net/pi2.clp->tstate = DEFER;
lp477drivers/net/pi2.ctdelay(lp, 100);
lp479drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R15, CTSIE | DCDIE);
lp483drivers/net/pi2.cif (random() > lp->persist) {
lp484drivers/net/pi2.clp->tstate = DEFER;
lp485drivers/net/pi2.ctdelay(lp, lp->slotime);
lp490drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp491drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp492drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp493drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp503drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp)
lp516drivers/net/pi2.ccmd = lp->base + CTL;
lp518drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* Get special condition bits from R1 */
lp520drivers/net/pi2.clp->rstate = RXERROR;
lp525drivers/net/pi2.cclear_dma_ff(lp->dmachan);
lp526drivers/net/pi2.cbytecount = lp->bufsiz - get_dma_residue(lp->dmachan);
lp528drivers/net/pi2.cif ((rse & CRC_ERR) || (lp->rstate > ACTIVE) || (bytecount < 10)) {
lp530drivers/net/pi2.clp->stats.rx_crc_errors++;
lp532drivers/net/pi2.cif (lp->rstate == RXERROR) {
lp533drivers/net/pi2.clp->stats.rx_errors++;
lp534drivers/net/pi2.clp->stats.rx_over_errors++;
lp537drivers/net/pi2.clp->rstate = ACTIVE;
lp538drivers/net/pi2.csetup_rx_dma(lp);
lp542drivers/net/pi2.cpkt_len = lp->rcvbuf->cnt = bytecount - 2 + 1;
lp545drivers/net/pi2.ccur_buf = lp->rcvbuf;
lp546drivers/net/pi2.cswitchbuffers(lp);
lp547drivers/net/pi2.csetup_rx_dma(lp);
lp556drivers/net/pi2.clp->stats.rx_dropped++;
lp572drivers/net/pi2.clp->stats.rx_packets++;
lp575drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, ERR_RES);  /* error reset */
lp579drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp)
lp591drivers/net/pi2.ccmd = CTL + lp->base;
lp593drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
lp595drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0)) & Rx_CH_AV) {
lp602drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp603drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp605drivers/net/pi2.clp->rstate = RXERROR;  /* set error flag */
lp606drivers/net/pi2.clp->stats.rx_errors++;
lp607drivers/net/pi2.clp->stats.rx_over_errors++;
lp608drivers/net/pi2.c} else if (lp->rcvbuf->cnt >= lp->bufsiz) {
lp611drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp612drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp613drivers/net/pi2.clp->rstate = TOOBIG;/* when set, chars are not stored */
lp616drivers/net/pi2.cif (lp->rstate == ACTIVE) {  /* If no errors... */
lp617drivers/net/pi2.c*lp->rcp++ = rdscc(lp->cardbase, cmd, R8);  /* char to rcv buff */
lp618drivers/net/pi2.clp->rcvbuf->cnt++;  /* bump count */
lp621drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp622drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
lp623drivers/net/pi2.clp->rstate = ACTIVE;
lp628drivers/net/pi2.cif (lp->rcvbuf->cnt > 0) {
lp629drivers/net/pi2.cif ((rse & CRC_ERR) || (lp->rstate > ACTIVE) || (lp->rcvbuf->cnt < 10)) {
lp630drivers/net/pi2.cif ((lp->rcvbuf->cnt >= 10) && (rse & CRC_ERR)) {
lp631drivers/net/pi2.clp->stats.rx_crc_errors++;
lp633drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp634drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp637drivers/net/pi2.cpkt_len = lp->rcvbuf->cnt -= 2;  /* Toss 2 crc bytes */
lp645drivers/net/pi2.clp->stats.rx_dropped++;
lp655drivers/net/pi2.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
lp660drivers/net/pi2.clp->stats.rx_packets++;
lp662drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp663drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp667drivers/net/pi2.clp->rstate = ACTIVE;  /* and clear error status */
lp673drivers/net/pi2.cstatic void b_txint(struct pi_local *lp)
lp681drivers/net/pi2.ccmd = CTL + lp->base;
lp683drivers/net/pi2.cswitch (lp->tstate) {
lp685drivers/net/pi2.clp->tstate = FLAGOUT;
lp686drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp691drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp695drivers/net/pi2.crts(lp, OFF);
lp700drivers/net/pi2.clp->txptr = lp->sndbuf->data;
lp701drivers/net/pi2.clp->txptr++;    /* Ignore KISS control byte */
lp702drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
lp707drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp708drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp709drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp710drivers/net/pi2.clp->tstate = DEFER;
lp711drivers/net/pi2.ctdelay(lp, 100);
lp713drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp717drivers/net/pi2.cif (random() > lp->persist) {
lp718drivers/net/pi2.clp->tstate = DEFER;
lp719drivers/net/pi2.ctdelay(lp, lp->slotime);
lp723drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp724drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp725drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp731drivers/net/pi2.cif (lp->txcnt--) {
lp732drivers/net/pi2.cc = *lp->txptr++;
lp734drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp738drivers/net/pi2.cfree_p(lp->sndbuf);
lp739drivers/net/pi2.clp->sndbuf = NULL;
lp740drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & 0x40)) {
lp743drivers/net/pi2.clp->stats.tx_errors++;
lp744drivers/net/pi2.clp->stats.tx_fifo_errors++;
lp745drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp746drivers/net/pi2.clp->tstate = FLAGOUT;
lp747drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp751drivers/net/pi2.clp->tstate = UNDERRUN;  /* Now we expect to underrun */
lp753drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp754drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
lp756drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
lp758drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_P);  /* reset Tx Int Pend */
lp773drivers/net/pi2.cstatic void b_exint(struct pi_local *lp)
lp780drivers/net/pi2.ccmd = CTL + lp->base;
lp783drivers/net/pi2.cst = rdscc(lp->cardbase, cmd, R0);  /* Fetch status */
lp785drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp788drivers/net/pi2.cswitch (lp->tstate) {
lp790drivers/net/pi2.cfree_p(lp->sndbuf);
lp791drivers/net/pi2.clp->sndbuf = NULL;
lp792drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp793drivers/net/pi2.clp->tstate = FLAGOUT;
lp794drivers/net/pi2.clp->stats.tx_errors++;
lp795drivers/net/pi2.clp->stats.tx_fifo_errors++;
lp796drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp800drivers/net/pi2.clp->tstate = CRCOUT;
lp805drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp809drivers/net/pi2.crts(lp, OFF);
lp810drivers/net/pi2.clp->tstate = IDLE;
lp814drivers/net/pi2.clp->txptr = lp->sndbuf->data;
lp815drivers/net/pi2.clp->txptr++;    /* Ignore KISS control byte */
lp816drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
lp818drivers/net/pi2.clp->txcnt--;
lp819drivers/net/pi2.cc = *lp->txptr++;
lp820drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
lp823drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp824drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
lp826drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
lp829drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
lp830drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
lp834drivers/net/pi2.cif (lp->txcnt) {
lp835drivers/net/pi2.clp->txcnt--;
lp836drivers/net/pi2.cc = *lp->txptr++;
lp838drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
lp840drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp846drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
lp847drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp848drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);  /* Tx/Ext ints */
lp850drivers/net/pi2.clp->tstate = ACTIVE;  /* char going out now */
lp858drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp859drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp860drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp861drivers/net/pi2.clp->tstate = DEFER;
lp862drivers/net/pi2.ctdelay(lp, 100);
lp864drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp868drivers/net/pi2.cif (random() > lp->persist) {
lp869drivers/net/pi2.clp->tstate = DEFER;
lp870drivers/net/pi2.ctdelay(lp, lp->slotime);
lp874drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp875drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp876drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp883drivers/net/pi2.clp->txcnt--;
lp884drivers/net/pi2.cc = *lp->txptr++;
lp885drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
lp888drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp889drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
lp891drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
lp894drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
lp895drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
lp899drivers/net/pi2.cif (lp->txcnt) {
lp900drivers/net/pi2.clp->txcnt--;
lp901drivers/net/pi2.cc = *lp->txptr++;
lp903drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
lp905drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp911drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
lp912drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp914drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);
lp916drivers/net/pi2.clp->tstate = ACTIVE;  /* char going out now */
lp926drivers/net/pi2.cif ((lp->rstate == ACTIVE) && (st & BRK_ABRT)) {
lp927drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp928drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp929drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp930drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp931drivers/net/pi2.clp->rcvbuf->cnt = 0;  /* rewind on DCD transition */
lp997drivers/net/pi2.cstatic void rts(struct pi_local *lp, int x)
lp1005drivers/net/pi2.ccmd = CTL + lp->base;
lp1010drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
lp1011drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Rx off */
lp1012drivers/net/pi2.clp->rstate = IDLE;
lp1015drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp1017drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);  /* No interrupts */
lp1020drivers/net/pi2.cif (!lp->clockmode) {
lp1021drivers/net/pi2.cif (lp->speed) {  /* if internally clocked */
lp1022drivers/net/pi2.cbr = lp->speed;  /* get desired speed */
lp1023drivers/net/pi2.ctc = (lp->xtal / br) - 2;  /* calc 1X BRG divisor */
lp1024drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1025drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1028drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | TxENAB | Tx8 | DTR);
lp1031drivers/net/pi2.clp->tstate = IDLE;
lp1032drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);  /*  TX off */
lp1034drivers/net/pi2.cif (!lp->clockmode) {
lp1035drivers/net/pi2.cif (lp->speed) {  /* if internally clocked */
lp1038drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
lp1039drivers/net/pi2.cbr = lp->speed;  /* get desired speed */
lp1041drivers/net/pi2.ctc = ((lp->xtal / 32) / br) - 2;
lp1042drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1043drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1045drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);
lp1047drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);
lp1051drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Make sure rx is off */
lp1052drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
lp1053drivers/net/pi2.cdummy = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
lp1054drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1055drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1057drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1060drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | Rx8);
lp1061drivers/net/pi2.clp->rstate = ACTIVE;  /* Normal state */
lp1064drivers/net/pi2.csetup_rx_dma(lp);
lp1067drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp1068drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp1069drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
lp1071drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* allow ABORT int */
lp1092drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1100drivers/net/pi2.ccmd = CTL + lp->base;
lp1106drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRA);  /* Reset channel A */
lp1107drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R2, 0xff);  /* Initialize interrupt vector */
lp1110drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRB);  /* Reset channel B */
lp1115drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);
lp1118drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
lp1121drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R4, SDLC | X1CLK);
lp1124drivers/net/pi2.cif (lp->speed) {    /* Use internal clocking */
lp1125drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
lp1126drivers/net/pi2.cif (!lp->clockmode)
lp1128drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCBR | RCDPLL | TRxCDP | TRxCOI);
lp1131drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCDPLL | RCDPLL | TRxCBR | TRxCOI);
lp1133drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
lp1135drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCTRxCP);
lp1139drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R6, 0);
lp1142drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R7, FLAG);
lp1147drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
lp1150drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* 8 bits/char */
lp1153drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);  /* BRG off, keep Pclk source */
lp1157drivers/net/pi2.cif (lp->speed) {
lp1158drivers/net/pi2.cbr = lp->speed;    /* get desired speed */
lp1159drivers/net/pi2.ctc = ((lp->xtal / 32) / br) - 2;  /* calc 32X BRG divisor */
lp1164drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1165drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1168drivers/net/pi2.crts(lp, OFF);    /* TX OFF and RX ON */
lp1170drivers/net/pi2.cif (lp->speed) {
lp1172drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSBR);
lp1175drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSRTxC);
lp1177drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);  /* SEARCH mode, keep BRG src */
lp1178drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);  /* Enable the BRG */
lp1181drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
lp1183drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* ABORT int */
lp1186drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | RxCRC_ENAB | Rx8);
lp1302drivers/net/pi2.cstruct pi_local *lp;
lp1313drivers/net/pi2.clp = (struct pi_local *) dev->priv;
lp1319drivers/net/pi2.clp->txdmabuf = get_dma_buffer(&mem_ptr);
lp1320drivers/net/pi2.clp->rxdmabuf1 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp1321drivers/net/pi2.clp->rxdmabuf2 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp1324drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf1;
lp1325drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp1326drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp1329drivers/net/pi2.cskb_queue_head_init(&lp->sndq);
lp1333drivers/net/pi2.clp->xtal = (unsigned long) SINGLE / 2;
lp1335drivers/net/pi2.clp->xtal = (unsigned long) DOUBLE / 2;
lp1336drivers/net/pi2.clp->base = dev->base_addr;
lp1337drivers/net/pi2.clp->cardbase = dev->base_addr & 0x3f0;
lp1339drivers/net/pi2.clp->speed = DEF_A_SPEED;
lp1341drivers/net/pi2.clp->txdelay = DEF_A_TXDELAY;
lp1342drivers/net/pi2.clp->persist = DEF_A_PERSIST;
lp1343drivers/net/pi2.clp->slotime = DEF_A_SLOTIME;
lp1344drivers/net/pi2.clp->squeldelay = DEF_A_SQUELDELAY;
lp1345drivers/net/pi2.clp->clockmode = DEF_A_CLOCKMODE;
lp1348drivers/net/pi2.clp->speed = DEF_B_SPEED;
lp1350drivers/net/pi2.clp->txdelay = DEF_B_TXDELAY;
lp1351drivers/net/pi2.clp->persist = DEF_B_PERSIST;
lp1352drivers/net/pi2.clp->slotime = DEF_B_SLOTIME;
lp1353drivers/net/pi2.clp->squeldelay = DEF_B_SQUELDELAY;
lp1354drivers/net/pi2.clp->clockmode = DEF_B_CLOCKMODE;
lp1356drivers/net/pi2.clp->bufsiz = DMA_BUFF_SIZE;
lp1357drivers/net/pi2.clp->tstate = IDLE;
lp1364drivers/net/pi2.clp->dmachan = dev->dma;
lp1365drivers/net/pi2.cif (lp->dmachan < 1 || lp->dmachan > 3)
lp1366drivers/net/pi2.cprintk("PI: DMA channel %d out of range\n", lp->dmachan);
lp1374drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R1, EXT_INT_ENAB);
lp1376drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
lp1379drivers/net/pi2.ctdelay(lp, 1);
lp1387drivers/net/pi2.cwrtscc(lp->cardbase, dev->base_addr + CTL, R9, FHWRES);  /* Hardware reset */
lp1389drivers/net/pi2.cwrtscc(lp->cardbase, dev->base_addr + CTL, R9, 0);
lp1458drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1471drivers/net/pi2.clp->tstate = IDLE;
lp1480drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
lp1483drivers/net/pi2.clp->open_time = jiffies;
lp1494drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1503drivers/net/pi2.chardware_send_packet(lp, skb);
lp1514drivers/net/pi2.cstruct pi_local *lp;
lp1529drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;  /* Assume channel A */
lp1530drivers/net/pi2.cwhile ((st = rdscc(lp->cardbase, pi0a.base_addr | CHANA | CTL, R3)) != 0) {
lp1533drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1534drivers/net/pi2.cb_txint(lp);
lp1537drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1538drivers/net/pi2.ca_rxint(&pi0a, lp);
lp1541drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1542drivers/net/pi2.ca_txint(lp);
lp1545drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1546drivers/net/pi2.ca_exint(lp);
lp1549drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1550drivers/net/pi2.cb_rxint(&pi0b, lp);
lp1553drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1554drivers/net/pi2.cb_exint(lp);
lp1559drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_H_IUS);
lp1569drivers/net/pi2.cstruct pi_local *lp;
lp1575drivers/net/pi2.clp = (struct pi_local *) dev->priv;
lp1579drivers/net/pi2.cdisable_dma(lp->dmachan);
lp1581drivers/net/pi2.clp->open_time = 0;
lp1587drivers/net/pi2.cwhile ((ptr = skb_dequeue(&lp->sndq)) != NULL)
lp1598drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1616drivers/net/pi2.clp->txdelay = rq.txdelay;
lp1617drivers/net/pi2.clp->persist = rq.persist;
lp1618drivers/net/pi2.clp->slotime = rq.slotime;
lp1619drivers/net/pi2.clp->squeldelay = rq.squeldelay;
lp1620drivers/net/pi2.clp->clockmode = rq.clockmode;
lp1621drivers/net/pi2.clp->speed = rq.speed;
lp1638drivers/net/pi2.cfree_dma(lp->dmachan);
lp1639drivers/net/pi2.cdev->dma = lp->dmachan = rq.dmachan;
lp1640drivers/net/pi2.cif (request_dma(lp->dmachan,"pi2")) 
lp1655drivers/net/pi2.crq.speed = lp->speed;
lp1656drivers/net/pi2.crq.txdelay = lp->txdelay;
lp1657drivers/net/pi2.crq.persist = lp->persist;
lp1658drivers/net/pi2.crq.slotime = lp->slotime;
lp1659drivers/net/pi2.crq.squeldelay = lp->squeldelay;
lp1660drivers/net/pi2.crq.clockmode = lp->clockmode;
lp1661drivers/net/pi2.crq.dmachan = lp->dmachan;
lp1678drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1680drivers/net/pi2.creturn &lp->stats;
lp354drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp369drivers/net/seeq8005.clp->open_time = jiffies;
lp428drivers/net/seeq8005.cstruct net_local *lp;
lp441drivers/net/seeq8005.clp = (struct net_local *)dev->priv;
lp457drivers/net/seeq8005.clp->stats.tx_packets++;
lp479drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp491drivers/net/seeq8005.coutw( lp->receive_ptr, SEEQ_DMAAR);
lp498drivers/net/seeq8005.cprintk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
lp508drivers/net/seeq8005.cif (next_packet < lp->receive_ptr) {
lp509drivers/net/seeq8005.cpkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
lp511drivers/net/seeq8005.cpkt_len = next_packet - lp->receive_ptr - 4;
lp520drivers/net/seeq8005.clp->receive_ptr = next_packet;
lp527drivers/net/seeq8005.clp->stats.rx_errors++;
lp528drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_SHORT) lp->stats.rx_frame_errors++;
lp529drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_DRIB) lp->stats.rx_frame_errors++;
lp530drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_OVERSIZE) lp->stats.rx_over_errors++;
lp531drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_CRC_ERR) lp->stats.rx_crc_errors++;
lp534drivers/net/seeq8005.coutw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
lp543drivers/net/seeq8005.clp->stats.rx_dropped++;
lp563drivers/net/seeq8005.clp->stats.rx_packets++;
lp577drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp580drivers/net/seeq8005.clp->open_time = 0;
lp603drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp605drivers/net/seeq8005.creturn &lp->stats;
lp638drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp661drivers/net/seeq8005.clp->receive_ptr = (DEFAULT_TEA+1)<<8;  /* so we can find our packet_header */
lp662drivers/net/seeq8005.coutw( lp->receive_ptr, SEEQ_RPR);  /* Receive Pointer Register is set to recv buffer memory */
lp304drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp323drivers/net/skeleton.clp->open_time = jiffies;
lp337drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp377drivers/net/skeleton.clp->stats.tx_aborted_errors++;
lp388drivers/net/skeleton.cstruct net_local *lp;
lp398drivers/net/skeleton.clp = (struct net_local *)dev->priv;
lp407drivers/net/skeleton.clp->stats.tx_packets++;
lp413drivers/net/skeleton.clp->stats.tx_window_errors++;
lp425drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp437drivers/net/skeleton.clp->stats.rx_errors++;
lp438drivers/net/skeleton.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp439drivers/net/skeleton.cif (status & 0x10) lp->stats.rx_over_errors++;
lp440drivers/net/skeleton.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp441drivers/net/skeleton.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp450drivers/net/skeleton.clp->stats.rx_dropped++;
lp462drivers/net/skeleton.clp->stats.rx_packets++;
lp476drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp479drivers/net/skeleton.clp->open_time = 0;
lp509drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp514drivers/net/skeleton.clp->stats.rx_missed_errors = inw(ioaddr+1);
lp517drivers/net/skeleton.creturn &lp->stats;
lp460drivers/net/tulip.cstruct tulip_private *lp;
lp469drivers/net/tulip.clp = (struct tulip_private *)dev->priv;
lp491drivers/net/tulip.cint dirty_tx = lp->dirty_tx;
lp493drivers/net/tulip.cwhile (dirty_tx < lp->cur_tx) {
lp495drivers/net/tulip.cint status = lp->tx_ring[entry].status;
lp502drivers/net/tulip.clp->stats.tx_errors++;
lp503drivers/net/tulip.cif (status & 0x4104) lp->stats.tx_aborted_errors++;
lp504drivers/net/tulip.cif (status & 0x0C00) lp->stats.tx_carrier_errors++;
lp505drivers/net/tulip.cif (status & 0x0200) lp->stats.tx_window_errors++;
lp506drivers/net/tulip.cif (status & 0x0002) lp->stats.tx_fifo_errors++;
lp507drivers/net/tulip.cif (status & 0x0080) lp->stats.tx_heartbeat_errors++;
lp509drivers/net/tulip.cif (status & 0x0100) lp->stats.collisions16++;
lp513drivers/net/tulip.cif (status & 0x0001) lp->stats.tx_deferred++;
lp515drivers/net/tulip.clp->stats.collisions += (status >> 3) & 15;
lp516drivers/net/tulip.clp->stats.tx_packets++;
lp520drivers/net/tulip.cdev_kfree_skb(lp->tx_skbuff[entry], FREE_WRITE);
lp525drivers/net/tulip.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp527drivers/net/tulip.cdirty_tx, lp->cur_tx, lp->tx_full);
lp532drivers/net/tulip.cif (lp->tx_full && dev->tbusy
lp533drivers/net/tulip.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp535drivers/net/tulip.clp->tx_full = 0;
lp540drivers/net/tulip.clp->dirty_tx = dirty_tx;
lp545drivers/net/tulip.cif (csr5 & 0x0008) lp->stats.tx_errors++; /* Tx babble. */
lp547drivers/net/tulip.clp->stats.rx_errors++;
lp548drivers/net/tulip.clp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;
lp586drivers/net/tulip.cstruct tulip_private *lp = (struct tulip_private *)dev->priv;
lp587drivers/net/tulip.cint entry = lp->cur_rx % RX_RING_SIZE;
lp593drivers/net/tulip.cwhile (lp->rx_ring[entry].status >= 0) {
lp594drivers/net/tulip.cint status = lp->rx_ring[entry].status;
lp603drivers/net/tulip.clp->stats.rx_errors++; /* end of a packet.*/
lp604drivers/net/tulip.cif (status & 0x0890) lp->stats.rx_length_errors++;
lp605drivers/net/tulip.cif (status & 0x0004) lp->stats.rx_frame_errors++;
lp606drivers/net/tulip.cif (status & 0x0002) lp->stats.rx_crc_errors++;
lp607drivers/net/tulip.cif (status & 0x0001) lp->stats.rx_fifo_errors++;
lp610drivers/net/tulip.cshort pkt_len = lp->rx_ring[entry].status >> 16;
lp619drivers/net/tulip.cif (lp->rx_ring[(entry+i) % RX_RING_SIZE].status < 0)
lp623drivers/net/tulip.clp->stats.rx_dropped++;
lp624drivers/net/tulip.clp->rx_ring[entry].status = 0x80000000;
lp625drivers/net/tulip.clp->cur_rx++;
lp631drivers/net/tulip.cmemcpy(skb_put(skb,pkt_len), lp->rx_ring[entry].buffer1, pkt_len);
lp634drivers/net/tulip.clp->stats.rx_packets++;
lp637drivers/net/tulip.clp->rx_ring[entry].status = 0x80000000;
lp638drivers/net/tulip.centry = (++lp->cur_rx) % RX_RING_SIZE;
lp197drivers/net/wavelan.cnet_local  *lp;
lp201drivers/net/wavelan.clp = (net_local *)dev->priv;
lp205drivers/net/wavelan.clp->hacr &= ~HACR_INTRON;
lp206drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp216drivers/net/wavelan.cnet_local  *lp;
lp220drivers/net/wavelan.clp = (net_local *)dev->priv;
lp224drivers/net/wavelan.clp->hacr |= HACR_INTRON;
lp225drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp387drivers/net/wavelan.cnet_local  *lp;
lp392drivers/net/wavelan.clp = (net_local *)dev->priv;
lp436drivers/net/wavelan.cif (lp->promiscuous && lp->full_promiscuous)
lp453drivers/net/wavelan.cm.mmw_netw_id_l = lp->nwid[1];
lp454drivers/net/wavelan.cm.mmw_netw_id_h = lp->nwid[0];
lp464drivers/net/wavelan.cnet_local  *lp;
lp469drivers/net/wavelan.clp = (net_local *)dev->priv;
lp479drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp503drivers/net/wavelan.cnet_local  *lp;
lp509drivers/net/wavelan.clp = (net_local *)dev->priv;
lp514drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp543drivers/net/wavelan.cnet_local  *lp;
lp556drivers/net/wavelan.clp = (net_local *)dev->priv;
lp558drivers/net/wavelan.clp->nresets++;
lp561drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp575drivers/net/wavelan.cpsa_read(ioaddr, lp->hacr, 0, (unsigned char *)&psa, sizeof(psa));
lp599drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp702drivers/net/wavelan.cAC_CFG_PRM(lp->promiscuous);
lp866drivers/net/wavelan.cnet_local  *lp;
lp1021drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1025drivers/net/wavelan.cfirst_wavelan = lp;
lp1026drivers/net/wavelan.clp->prev = lp;
lp1027drivers/net/wavelan.clp->next = lp;
lp1031drivers/net/wavelan.clp->prev = first_wavelan->prev;
lp1032drivers/net/wavelan.clp->next = first_wavelan;
lp1033drivers/net/wavelan.cfirst_wavelan->prev->next = lp;
lp1034drivers/net/wavelan.cfirst_wavelan->prev = lp;
lp1036drivers/net/wavelan.clp->dev = dev;
lp1038drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp1040drivers/net/wavelan.clp->full_promiscuous = enable_full_promiscuous;
lp1041drivers/net/wavelan.clp->nwid[0] = psa.psa_nwid[0];
lp1042drivers/net/wavelan.clp->nwid[1] = psa.psa_nwid[1];
lp1044drivers/net/wavelan.clp->watchdog.function = wavelan_watchdog;
lp1045drivers/net/wavelan.clp->watchdog.data = (unsigned long)dev;
lp1076drivers/net/wavelan.cnet_local  *lp;
lp1085drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1091drivers/net/wavelan.clp->rx_head = OFFSET_RU;
lp1093drivers/net/wavelan.cfor (i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next)
lp1095drivers/net/wavelan.crx_next = (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ;
lp1110drivers/net/wavelan.clp->rx_last = rx;
lp1113drivers/net/wavelan.cobram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset), (unsigned char *)&lp->rx_head, sizeof(lp->rx_head));
lp1118drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1143drivers/net/wavelan.cnet_local  *lp;
lp1150drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1152drivers/net/wavelan.clp->tx_first_free = OFFSET_CU;
lp1153drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1199drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1213drivers/net/wavelan.clp->tx_n_in_use = 0;
lp1222drivers/net/wavelan.cnet_local  *lp;
lp1230drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1287drivers/net/wavelan.cnet_local  *lp;
lp1300drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1304drivers/net/wavelan.ctxblock = lp->tx_first_free;
lp1308drivers/net/wavelan.clp->tx_first_free += TXBLOCKZ;
lp1309drivers/net/wavelan.cif (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1310drivers/net/wavelan.clp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
lp1317drivers/net/wavelan.clp->tx_n_in_use++;
lp1362drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1363drivers/net/wavelan.clp->tx_first_in_use = txblock;
lp1365drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1370drivers/net/wavelan.cif (lp->watchdog.next == (timer_list *)0)
lp1489drivers/net/wavelan.cnet_local  *lp;
lp1493drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1504drivers/net/wavelan.cobram_read(ioaddr, lp->rx_head, (unsigned char *)&fd, sizeof(fd));
lp1531drivers/net/wavelan.clp->stats.rx_errors++;
lp1538drivers/net/wavelan.clp->stats.rx_length_errors++;
lp1544drivers/net/wavelan.clp->stats.rx_over_errors++;
lp1550drivers/net/wavelan.clp->stats.rx_fifo_errors++;
lp1556drivers/net/wavelan.clp->stats.rx_frame_errors++;
lp1562drivers/net/wavelan.clp->stats.rx_crc_errors++;
lp1648drivers/net/wavelan.clp->stats.rx_dropped++;
lp1686drivers/net/wavelan.clp->stats.rx_packets++;
lp1691drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_status), (unsigned char *)&fd.fd_status, sizeof(fd.fd_status));
lp1694drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1697drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_last, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1699drivers/net/wavelan.clp->rx_last = lp->rx_head;
lp1700drivers/net/wavelan.clp->rx_head = fd.fd_link_offset;
lp1715drivers/net/wavelan.cwavelan_complete(device *dev, unsigned short ioaddr, net_local *lp)
lp1725drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1728drivers/net/wavelan.cobram_read(ioaddr, acoff(lp->tx_first_in_use, ac_status), (unsigned char *)&tx_status, sizeof(tx_status));
lp1735drivers/net/wavelan.c--lp->tx_n_in_use;
lp1742drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1743drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1746drivers/net/wavelan.clp->tx_first_in_use += TXBLOCKZ;
lp1747drivers/net/wavelan.cif (lp->tx_first_in_use >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1748drivers/net/wavelan.clp->tx_first_in_use -= NTXBLOCKS * TXBLOCKZ;
lp1755drivers/net/wavelan.clp->stats.tx_packets++;
lp1757drivers/net/wavelan.clp->stats.collisions += ncollisions;
lp1765drivers/net/wavelan.clp->stats.tx_errors++;
lp1768drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1774drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1779drivers/net/wavelan.clp->stats.tx_fifo_errors++;
lp1784drivers/net/wavelan.clp->stats.tx_heartbeat_errors++;
lp1790drivers/net/wavelan.clp->stats.tx_aborted_errors++;
lp1808drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1822drivers/net/wavelan.cnet_local  *lp;
lp1831drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1833drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1839drivers/net/wavelan.clp->watchdog.expires = jiffies+WATCHDOG_JIFFIES;
lp1840drivers/net/wavelan.cadd_timer(&lp->watchdog);
lp1848drivers/net/wavelan.cnreaped = wavelan_complete(dev, ioaddr, lp);
lp1850drivers/net/wavelan.cprintk("%s: warning: wavelan_watchdog(): %d reaped, %d remain.\n", dev->name, nreaped, lp->tx_n_in_use);
lp1868drivers/net/wavelan.cnet_local  *lp;
lp1880drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1914drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1926drivers/net/wavelan.c(void)wavelan_complete(dev, ioaddr, lp);
lp1971drivers/net/wavelan.cnet_local  *lp;
lp1978drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1988drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp2018drivers/net/wavelan.cnet_local  *lp;
lp2020drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2022drivers/net/wavelan.creturn &lp->stats;
lp2029drivers/net/wavelan.cnet_local  *lp;
lp2035drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2043drivers/net/wavelan.clp->promiscuous = 1;
lp2054drivers/net/wavelan.clp->promiscuous = 0;
lp2080drivers/net/wavelan.cnet_local  *lp;
lp2084drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2086drivers/net/wavelan.cif (lp == (net_local *)0)
lp2104drivers/net/wavelan.clp->correct_nwid += (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l;
lp2105drivers/net/wavelan.clp->wrong_nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
lp2113drivers/net/wavelan.clp->correct_nwid,
lp2114drivers/net/wavelan.clp->wrong_nwid,
lp2118drivers/net/wavelan.clp->tx_n_in_use,
lp2119drivers/net/wavelan.clp->nresets
lp2145drivers/net/wavelan.cnet_local  *lp;
lp2147drivers/net/wavelan.clp = first_wavelan;
lp2150drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
lp2164drivers/net/wavelan.cwhile ((lp = lp->next) != first_wavelan);
lp2219drivers/net/wavelan.cwavelan_cu_show_one(device *dev, net_local *lp, int i, unsigned short p)
lp2432drivers/net/wavelan.cnet_local  *lp;
lp2434drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2447drivers/net/wavelan.cnet_local  *lp;
lp2451drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2456drivers/net/wavelan.cfor (i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++)
lp2458drivers/net/wavelan.cwavelan_cu_show_one(dev, lp, i, p);
lp2483drivers/net/wavelan.cnet_local  *lp;
lp2485drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2488drivers/net/wavelan.cprintk(" tx_n_in_use=%d,", lp->tx_n_in_use);
lp2489drivers/net/wavelan.cprintk(" hacr=0x%x,", lp->hacr);
lp2490drivers/net/wavelan.cprintk(" rx_head=0x%x,", lp->rx_head);
lp2491drivers/net/wavelan.cprintk(" rx_last=0x%x,", lp->rx_last);
lp2492drivers/net/wavelan.cprintk(" tx_first_free=0x%x,", lp->tx_first_free);
lp2493drivers/net/wavelan.cprintk(" tx_first_in_use=0x%x,", lp->tx_first_in_use);
lp437drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp443drivers/net/znet.clp->stats.tx_packets++;
lp444drivers/net/znet.clp->stats.collisions += tx_status & 0xf;
lp446drivers/net/znet.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp447drivers/net/znet.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp448drivers/net/znet.cif (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
lp449drivers/net/znet.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp452drivers/net/znet.clp->stats.tx_errors++;
lp472drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp539drivers/net/znet.clp->stats.rx_errors++;
lp540drivers/net/znet.cif (status & 0x0800) lp->stats.rx_crc_errors++;
lp541drivers/net/znet.cif (status & 0x0400) lp->stats.rx_frame_errors++;
lp542drivers/net/znet.cif (status & 0x0200) lp->stats.rx_over_errors++; /* Wrong. */
lp543drivers/net/znet.cif (status & 0x0100) lp->stats.rx_fifo_errors++;
lp544drivers/net/znet.cif (status & 0x0080) lp->stats.rx_length_errors++;
lp546drivers/net/znet.clp->stats.rx_length_errors++;
lp555drivers/net/znet.clp->stats.rx_dropped++;
lp575drivers/net/znet.clp->stats.rx_packets++;
lp621drivers/net/znet.cstruct net_local *lp = (struct net_local *)dev->priv;
lp623drivers/net/znet.creturn &lp->stats;
lp5drivers/scsi/eata_dma_proc.cu32 *lp, h_lp;
lp9drivers/scsi/eata_dma_proc.clp = (u32 *)p;
lp10drivers/scsi/eata_dma_proc.csp = ((short *)lp) + 1;      /* Convert Header */
lp12drivers/scsi/eata_dma_proc.clp++;
lp15drivers/scsi/eata_dma_proc.csp = (u16 *)lp;      /* Convert SubHeader */
lp17drivers/scsi/eata_dma_proc.cbp = (u8 *) lp;
lp19drivers/scsi/eata_dma_proc.clp++;
lp20drivers/scsi/eata_dma_proc.cfor (h_lp = (u32)lp; (u32)lp < h_lp + ((u32)*(bp + 3)); lp++)
lp21drivers/scsi/eata_dma_proc.c*lp = ntohl(*lp);
lp22drivers/scsi/eata_dma_proc.c}while ((u32)lp < ((u32)p) + 4 + h_sp);
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;
lp185net/ipv4/protocol.cstruct inet_protocol *lp = NULL;
lp209net/ipv4/protocol.cif (p->copy == 0 && lp != NULL) 
lp210net/ipv4/protocol.clp->copy = 0;
lp215net/ipv4/protocol.clp = p;