taglinefilesource code
lp40arch/i386/kernel/ldt.cunsigned long *lp;
lp76arch/i386/kernel/ldt.clp = (unsigned long *) &current->ldt[ldt_info.entry_number];
lp79arch/i386/kernel/ldt.c*lp = 0;
lp80arch/i386/kernel/ldt.c*(lp+1) = 0;
lp83arch/i386/kernel/ldt.c*lp = ((ldt_info.base_addr & 0x0000ffff) << 16) |
lp85arch/i386/kernel/ldt.c*(lp+1) = (ldt_info.base_addr & 0xff000000) |
lp158drivers/char/lp.cstruct lp_struct *lp = &lp_table[0];
lp161drivers/char/lp.cwhile (irq != lp->irq) {
lp162drivers/char/lp.cif (++lp >= lp_end)
lp166drivers/char/lp.cwake_up(&lp->lp_wait_q);
lp175drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp181drivers/char/lp.cmemcpy_fromfs(lp->lp_buffer, buf, copy_size);
lp184drivers/char/lp.cif (lp_char_interrupt(lp->lp_buffer[bytes_written], minor)) {
lp213drivers/char/lp.cinterruptible_sleep_on(&lp->lp_wait_q);
lp448drivers/char/lp.cstruct lp_struct *lp = &lp_table[minor];
lp457drivers/char/lp.clp->lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
lp458drivers/char/lp.cif (!lp->lp_buffer)
lp473drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp474drivers/char/lp.clp->lp_buffer = NULL;
lp481drivers/char/lp.ckfree_s(lp->lp_buffer, LP_BUFFER_SIZE);
lp482drivers/char/lp.clp->lp_buffer = NULL;
lp335drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp348drivers/net/3c501.clp->stats.tx_errors++;
lp378drivers/net/3c501.clp->tx_pkt_start = gp_start;
lp379drivers/net/3c501.clp->collisions = 0;
lp389drivers/net/3c501.clp->loading=1;
lp400drivers/net/3c501.cif(lp->loading==2)    /* A receive upset our load, despite our best efforts */
lp423drivers/net/3c501.cstruct net_local *lp;
lp433drivers/net/3c501.clp = (struct net_local *)dev->priv;
lp442drivers/net/3c501.clp->loading=2;    /* So we can spot loading interruptions */
lp474drivers/net/3c501.clp->stats.tx_aborted_errors++;
lp482drivers/net/3c501.coutw(lp->tx_pkt_start, GP_LOW);
lp484drivers/net/3c501.clp->stats.collisions++;
lp491drivers/net/3c501.clp->stats.tx_packets++;
lp516drivers/net/3c501.clp->stats.rx_missed_errors++;
lp518drivers/net/3c501.clp->stats.rx_length_errors++;
lp552drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp565drivers/net/3c501.clp->stats.rx_over_errors++;
lp582drivers/net/3c501.clp->stats.rx_dropped++;
lp597drivers/net/3c501.clp->stats.rx_packets++;
lp651drivers/net/3c501.cstruct net_local *lp = (struct net_local *)dev->priv;
lp652drivers/net/3c501.creturn &lp->stats;
lp449drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp464drivers/net/3c507.cif (lp->last_restart == lp->stats.tx_packets) {
lp473drivers/net/3c507.clp->last_restart = lp->stats.tx_packets;
lp515drivers/net/3c507.cstruct net_local *lp;
lp527drivers/net/3c507.clp = (struct net_local *)dev->priv;
lp540drivers/net/3c507.cwhile (lp->tx_reap != lp->tx_head) {
lp541drivers/net/3c507.cunsigned short tx_status = shmem[lp->tx_reap>>1];
lp544drivers/net/3c507.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp548drivers/net/3c507.clp->stats.tx_packets++;
lp549drivers/net/3c507.clp->stats.collisions += tx_status & 0xf;
lp553drivers/net/3c507.clp->stats.tx_errors++;
lp554drivers/net/3c507.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp555drivers/net/3c507.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp556drivers/net/3c507.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp557drivers/net/3c507.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp560drivers/net/3c507.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp561drivers/net/3c507.clp->tx_reap += TX_BUF_SIZE;
lp562drivers/net/3c507.cif (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
lp563drivers/net/3c507.clp->tx_reap = TX_BUF_START;
lp570drivers/net/3c507.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp642drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp646drivers/net/3c507.creturn &lp->stats;
lp653drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp657drivers/net/3c507.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp683drivers/net/3c507.clp->rx_tail = cur_rxbuf;
lp690drivers/net/3c507.c(dev->mem_start + lp->rx_tail + 2);
lp692drivers/net/3c507.c*write_ptr++ = lp->rx_head;        /* Link */
lp699drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp722drivers/net/3c507.clp->tx_cmd_link = IDLELOOP + 4;
lp723drivers/net/3c507.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp758drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp760drivers/net/3c507.cushort tx_block = lp->tx_head;
lp784drivers/net/3c507.c*(ushort*)(dev->mem_start + lp->tx_cmd_link) = tx_block;
lp785drivers/net/3c507.clp->tx_cmd_link = tx_block + 20;
lp788drivers/net/3c507.clp->tx_head = tx_block + TX_BUF_SIZE;
lp789drivers/net/3c507.cif (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
lp790drivers/net/3c507.clp->tx_head = TX_BUF_START;
lp794drivers/net/3c507.cdev->name, ioaddr, length, tx_block, lp->tx_head);
lp797drivers/net/3c507.cif (lp->tx_head != lp->tx_reap)
lp804drivers/net/3c507.cstruct net_local *lp = (struct net_local *)dev->priv;
lp806drivers/net/3c507.cushort rx_head = lp->rx_head;
lp807drivers/net/3c507.cushort rx_tail = lp->rx_tail;
lp827drivers/net/3c507.clp->stats.rx_errors++;
lp828drivers/net/3c507.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp829drivers/net/3c507.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp830drivers/net/3c507.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp831drivers/net/3c507.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp832drivers/net/3c507.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp841drivers/net/3c507.clp->stats.rx_dropped++;
lp853drivers/net/3c507.clp->stats.rx_packets++;
lp868drivers/net/3c507.clp->rx_head = rx_head;
lp869drivers/net/3c507.clp->rx_tail = rx_tail;
lp380drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp452drivers/net/3c509.cif (tx_status & 0x38) lp->stats.tx_aborted_errors++;
lp525drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp532drivers/net/3c509.creturn &lp->stats;
lp542drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp550drivers/net/3c509.clp->stats.tx_carrier_errors   += inb(ioaddr + 0);
lp551drivers/net/3c509.clp->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
lp553drivers/net/3c509.clp->stats.collisions      += inb(ioaddr + 3);
lp554drivers/net/3c509.clp->stats.tx_window_errors    += inb(ioaddr + 4);
lp555drivers/net/3c509.clp->stats.rx_fifo_errors    += inb(ioaddr + 5);
lp556drivers/net/3c509.clp->stats.tx_packets      += inb(ioaddr + 6);
lp571drivers/net/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
lp581drivers/net/3c509.clp->stats.rx_errors++;
lp583drivers/net/3c509.ccase 0x0000:    lp->stats.rx_over_errors++; break;
lp584drivers/net/3c509.ccase 0x0800:    lp->stats.rx_length_errors++; break;
lp585drivers/net/3c509.ccase 0x1000:    lp->stats.rx_frame_errors++; break;
lp586drivers/net/3c509.ccase 0x1800:    lp->stats.rx_length_errors++; break;
lp587drivers/net/3c509.ccase 0x2000:    lp->stats.rx_frame_errors++; break;
lp588drivers/net/3c509.ccase 0x2800:    lp->stats.rx_crc_errors++; break;
lp609drivers/net/3c509.clp->stats.rx_packets++;
lp615drivers/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);
lp231drivers/net/arcnet.c#define TBUSY lp->adev->tbusy \
lp232drivers/net/arcnet.c=lp->wdev->tbusy
lp233drivers/net/arcnet.c#define IF_TBUSY (lp->adev->tbusy \
lp234drivers/net/arcnet.c|| lp->wdev->tbusy)
lp235drivers/net/arcnet.c#define START lp->adev->start \
lp236drivers/net/arcnet.c=lp->wdev->start
lp517drivers/net/arcnet.cstruct arcnet_local *lp;
lp611drivers/net/arcnet.clp=(struct arcnet_local *)(dev->priv);
lp644drivers/net/arcnet.clp->arcnum,lp->arcnum);
lp645drivers/net/arcnet.cif (lp->arcnum==0)
lp647drivers/net/arcnet.cif (lp->arcnum==255)
lp649drivers/net/arcnet.cdev->dev_addr[0]=lp->arcnum;
lp650drivers/net/arcnet.clp->sequence=1;
lp651drivers/net/arcnet.clp->recbuf=0;
lp839drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp841drivers/net/arcnet.cint delayval,recbuf=lp->recbuf;
lp866drivers/net/arcnet.clp->arcnum=cardmem[1];  /* save address for later use */
lp869drivers/net/arcnet.crecbuf=lp->recbuf=0;
lp870drivers/net/arcnet.clp->txbuf=2;
lp891drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp893drivers/net/arcnet.cether_setup(lp->wdev);
lp895drivers/net/arcnet.cdev->dev_addr[5]=lp->arcnum;
lp897drivers/net/arcnet.clp->wdev->open=NULL;
lp898drivers/net/arcnet.clp->wdev->stop=NULL;
lp899drivers/net/arcnet.clp->wdev->hard_start_xmit=arcnetW_send_packet;
lp903drivers/net/arcnet.clp->wdev->name);
lp926drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp947drivers/net/arcnet.clp->intx=0;
lp948drivers/net/arcnet.clp->in_txhandler=0;
lp951drivers/net/arcnet.clp->adev=dev;
lp954drivers/net/arcnet.clp->adev->name);
lp957drivers/net/arcnet.clp->wdev=(struct device *)kmalloc(sizeof(struct device),GFP_KERNEL);
lp958drivers/net/arcnet.cmemcpy(lp->wdev,dev,sizeof(struct device));
lp959drivers/net/arcnet.clp->wdev->name=(char *)kmalloc(10,GFP_KERNEL);
lp960drivers/net/arcnet.csprintf(lp->wdev->name,"%sw",dev->name);
lp961drivers/net/arcnet.clp->wdev->init=arcnetW_init;
lp962drivers/net/arcnet.cregister_netdev(lp->wdev);
lp981drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp993drivers/net/arcnet.clp->adev=NULL;
lp996drivers/net/arcnet.clp->wdev->start=0;
lp997drivers/net/arcnet.clp->wdev->priv=NULL;
lp998drivers/net/arcnet.cunregister_netdev(lp->wdev);
lp999drivers/net/arcnet.ckfree(lp->wdev->name);
lp1000drivers/net/arcnet.ckfree(lp->wdev);
lp1001drivers/net/arcnet.clp->wdev=NULL;
lp1026drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1029drivers/net/arcnet.clp->intx++;
lp1033drivers/net/arcnet.cinb(STATUS),lp->intx);
lp1035drivers/net/arcnet.cif (lp->in_txhandler)
lp1038drivers/net/arcnet.clp->intx--;
lp1047drivers/net/arcnet.cint recbuf=lp->recbuf;
lp1054drivers/net/arcnet.cstatus,tickssofar,lp->outgoing.skb,
lp1055drivers/net/arcnet.clp->outgoing.numsegs,
lp1056drivers/net/arcnet.clp->outgoing.segnum);
lp1057drivers/net/arcnet.clp->intx--;
lp1063drivers/net/arcnet.cstatus,lp->intx,lp->in_txhandler,tickssofar);
lp1065drivers/net/arcnet.clp->stats.tx_errors++;
lp1075drivers/net/arcnet.cif (lp->outgoing.skb)
lp1077drivers/net/arcnet.cdev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
lp1078drivers/net/arcnet.clp->stats.tx_dropped++;
lp1080drivers/net/arcnet.clp->outgoing.skb=NULL;
lp1083drivers/net/arcnet.clp->intx--;
lp1086drivers/net/arcnet.clp->txready=0;
lp1087drivers/net/arcnet.clp->sending=0;
lp1101drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp1103drivers/net/arcnet.clp->intx--;
lp1107drivers/net/arcnet.cif (lp->txready)  /* transmit already in progress! */
lp1115drivers/net/arcnet.clp->stats.tx_errors++;
lp1116drivers/net/arcnet.clp->intx--;
lp1117drivers/net/arcnet.clp->txready=0;  /* we definitely need this line! */
lp1127drivers/net/arcnet.cinb(STATUS),lp->intx,jiffies-dev->trans_start);
lp1128drivers/net/arcnet.clp->intx--;
lp1132drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1151drivers/net/arcnet.cout->hdr->sequence=(lp->sequence++);
lp1153drivers/net/arcnet.cif (lp->txready && inb(STATUS)&TXFREEflag)
lp1175drivers/net/arcnet.cif (!lp->sending)
lp1199drivers/net/arcnet.cif (lp->txready && inb(STATUS)&TXFREEflag)
lp1202drivers/net/arcnet.cif (!lp->txready)
lp1208drivers/net/arcnet.cif (!lp->sending)
lp1212drivers/net/arcnet.cif (!lp->sending)
lp1231drivers/net/arcnet.clp->intx--;
lp1232drivers/net/arcnet.clp->stats.tx_packets++;
lp1244drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1246drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1248drivers/net/arcnet.cif (lp->txready)
lp1287drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1290drivers/net/arcnet.c(union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
lp1295drivers/net/arcnet.clp->txbuf=lp->txbuf^1;  /* XOR with 1 to alternate between 2 and 3 */
lp1305drivers/net/arcnet.cmemset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
lp1376drivers/net/arcnet.clp->outgoing.lastload_dest=hdr->daddr;
lp1378drivers/net/arcnet.clp->txready=lp->txbuf;  /* packet is ready for sending */
lp1387drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)dev->priv;
lp1394drivers/net/arcnet.cif (!(inb(STATUS)&TXFREEflag) || !lp->txready) return;
lp1397drivers/net/arcnet.coutb(TXcmd|(lp->txready<<3),COMMAND);
lp1402drivers/net/arcnet.clp->txready=0;
lp1403drivers/net/arcnet.clp->sending++;
lp1405drivers/net/arcnet.clp->outgoing.lasttrans_dest=lp->outgoing.lastload_dest;
lp1406drivers/net/arcnet.clp->outgoing.lastload_dest=0;
lp1416drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1452drivers/net/arcnet.c(union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
lp1461drivers/net/arcnet.clp->adev->name,lp->wdev->name);
lp1471drivers/net/arcnet.clp->txbuf=lp->txbuf^1; /* XOR with 1 to alternate btw 2 & 3 */
lp1475drivers/net/arcnet.cmemset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
lp1535drivers/net/arcnet.clp->outgoing.lastload_dest=daddr;
lp1537drivers/net/arcnet.clp->txready=lp->txbuf;  /* packet is ready for sending */
lp1583drivers/net/arcnet.cstruct arcnet_local *lp;
lp1592drivers/net/arcnet.clp = (struct arcnet_local *)dev->priv;
lp1634drivers/net/arcnet.clp->stats.tx_carrier_errors++;
lp1641drivers/net/arcnet.cint recbuf=lp->recbuf=!lp->recbuf;
lp1657drivers/net/arcnet.cif (status&TXFREEflag && !lp->in_txhandler && lp->sending)
lp1659drivers/net/arcnet.cstruct Outgoing *out=&(lp->outgoing);
lp1661drivers/net/arcnet.clp->in_txhandler++;
lp1662drivers/net/arcnet.clp->sending--;
lp1671drivers/net/arcnet.cif (lp->outgoing.lasttrans_dest != 0)
lp1676drivers/net/arcnet.clp->outgoing.lasttrans_dest);
lp1677drivers/net/arcnet.clp->stats.tx_errors++;
lp1684drivers/net/arcnet.clp->outgoing.lasttrans_dest);
lp1690drivers/net/arcnet.cif (lp->txready)
lp1696drivers/net/arcnet.cif (lp->intx)
lp1698drivers/net/arcnet.clp->in_txhandler--;
lp1702drivers/net/arcnet.cif (!lp->outgoing.skb)
lp1708drivers/net/arcnet.cif (!lp->txready && IF_TBUSY)
lp1714drivers/net/arcnet.clp->in_txhandler--;
lp1725drivers/net/arcnet.cif (lp->txready && !lp->sending)
lp1740drivers/net/arcnet.cif (!lp->txready && IF_TBUSY)
lp1748drivers/net/arcnet.clp->in_txhandler--;
lp1757drivers/net/arcnet.cif (dev->start && lp->sending )
lp1780drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1796drivers/net/arcnet.clp->stats.rx_errors++;
lp1869drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp1893drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp1904drivers/net/arcnet.clp->stats.tx_dropped++;
lp1905drivers/net/arcnet.clp->stats.rx_errors++;
lp1914drivers/net/arcnet.clp->stats.rx_dropped++;
lp1960drivers/net/arcnet.clp->stats.rx_frame_errors++;
lp1978drivers/net/arcnet.clp->stats.rx_packets++;
lp1999drivers/net/arcnet.cstruct Incoming *in=&lp->incoming[saddr];
lp2011drivers/net/arcnet.clp->stats.tx_dropped++;
lp2012drivers/net/arcnet.clp->stats.rx_fifo_errors++;
lp2025drivers/net/arcnet.clp->stats.tx_dropped++;
lp2026drivers/net/arcnet.clp->stats.rx_over_errors++;
lp2038drivers/net/arcnet.clp->stats.rx_dropped++;
lp2048drivers/net/arcnet.clp->stats.rx_dropped++;
lp2078drivers/net/arcnet.clp->stats.rx_errors++;
lp2099drivers/net/arcnet.clp->stats.tx_dropped++;
lp2100drivers/net/arcnet.clp->stats.rx_fifo_errors++;
lp2142drivers/net/arcnet.clp->stats.rx_packets++;
lp2154drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2164drivers/net/arcnet.clp->stats.rx_dropped++;
lp2169drivers/net/arcnet.cskb->dev = lp->wdev;
lp2190drivers/net/arcnet.clp->stats.rx_packets++;
lp2208drivers/net/arcnet.cstruct arcnet_local *lp = (struct arcnet_local *)dev->priv;
lp2210drivers/net/arcnet.creturn &lp->stats;
lp2223drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
lp2351drivers/net/arcnet.cstruct arcnet_local *lp=(struct arcnet_local *) (dev->priv);
lp2379drivers/net/arcnet.clp->stats.rx_frame_errors++;
lp322drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp347drivers/net/at1700.clp->tx_started = 0;
lp348drivers/net/at1700.clp->tx_queue = 0;
lp349drivers/net/at1700.clp->tx_queue_len = 0;
lp365drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp381drivers/net/at1700.clp->stats.tx_errors++;
lp389drivers/net/at1700.clp->tx_started = 0;
lp390drivers/net/at1700.clp->tx_queue = 0;
lp391drivers/net/at1700.clp->tx_queue_len = 0;
lp416drivers/net/at1700.clp->tx_queue++;
lp417drivers/net/at1700.clp->tx_queue_len += length + 2;
lp419drivers/net/at1700.cif (lp->tx_started == 0) {
lp421drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp422drivers/net/at1700.clp->tx_queue = 0;
lp423drivers/net/at1700.clp->tx_queue_len = 0;
lp425drivers/net/at1700.clp->tx_started = 1;
lp427drivers/net/at1700.c} else if (lp->tx_queue_len < 4096 - 1502)
lp445drivers/net/at1700.cstruct net_local *lp;
lp455drivers/net/at1700.clp = (struct net_local *)dev->priv;
lp467drivers/net/at1700.clp->stats.tx_packets++;
lp468drivers/net/at1700.cif (lp->tx_queue) {
lp469drivers/net/at1700.coutb(0x80 | lp->tx_queue, ioaddr + TX_START);
lp470drivers/net/at1700.clp->tx_queue = 0;
lp471drivers/net/at1700.clp->tx_queue_len = 0;
lp476drivers/net/at1700.clp->tx_started = 0;
lp493drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp512drivers/net/at1700.clp->stats.rx_errors++;
lp513drivers/net/at1700.cif (status & 0x08) lp->stats.rx_length_errors++;
lp514drivers/net/at1700.cif (status & 0x04) lp->stats.rx_frame_errors++;
lp515drivers/net/at1700.cif (status & 0x02) lp->stats.rx_crc_errors++;
lp516drivers/net/at1700.cif (status & 0x01) lp->stats.rx_over_errors++;
lp527drivers/net/at1700.clp->stats.rx_errors++;
lp537drivers/net/at1700.clp->stats.rx_dropped++;
lp546drivers/net/at1700.clp->stats.rx_packets++;
lp574drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp596drivers/net/at1700.cstruct net_local *lp = (struct net_local *)dev->priv;
lp602drivers/net/at1700.creturn &lp->stats;
lp234drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp235drivers/net/atp.clp->addr_mode = CMR2h_Normal;
lp342drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp351drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp368drivers/net/atp.clp->tx_unit_busy = 0;
lp369drivers/net/atp.clp->pac_cnt_in_tx_buf = 0;
lp370drivers/net/atp.clp->saved_tx_size = 0;
lp416drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp428drivers/net/atp.clp->stats.tx_errors++;
lp462drivers/net/atp.clp->pac_cnt_in_tx_buf++;
lp463drivers/net/atp.cif (lp->tx_unit_busy == 0) {
lp465drivers/net/atp.clp->saved_tx_size = 0;         /* Redundant */
lp466drivers/net/atp.clp->re_tx = 0;
lp467drivers/net/atp.clp->tx_unit_busy = 1;
lp469drivers/net/atp.clp->saved_tx_size = length;
lp488drivers/net/atp.cstruct net_local *lp;
lp499drivers/net/atp.clp = (struct net_local *)dev->priv;
lp522drivers/net/atp.clp->stats.rx_over_errors++;
lp528drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
lp542drivers/net/atp.clp->stats.collisions++;
lp543drivers/net/atp.cif (++lp->re_tx > 15) {
lp544drivers/net/atp.clp->stats.tx_aborted_errors++;
lp553drivers/net/atp.clp->stats.tx_packets++;
lp554drivers/net/atp.clp->pac_cnt_in_tx_buf--;
lp555drivers/net/atp.cif ( lp->saved_tx_size) {
lp556drivers/net/atp.ctrigger_send(ioaddr, lp->saved_tx_size);
lp557drivers/net/atp.clp->saved_tx_size = 0;
lp558drivers/net/atp.clp->re_tx = 0;
lp560drivers/net/atp.clp->tx_unit_busy = 0;
lp572drivers/net/atp.clp->stats.rx_missed_errors++;
lp622drivers/net/atp.cstruct net_local *lp = (struct net_local *)atp_timed_dev->priv;
lp625drivers/net/atp.clp->stats.tx_errors++;
lp627drivers/net/atp.clp->stats.tx_dropped++;
lp629drivers/net/atp.clp->stats.collisions++;
lp631drivers/net/atp.clp->stats.rx_errors++;
lp646drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp661drivers/net/atp.clp->stats.rx_errors++;
lp676drivers/net/atp.clp->stats.rx_dropped++;
lp694drivers/net/atp.clp->stats.rx_packets++;
lp725drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp732drivers/net/atp.clp->addr_mode = CMR2h_OFF;
lp751drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp752drivers/net/atp.creturn &lp->stats;
lp764drivers/net/atp.cstruct net_local *lp = (struct net_local *)dev->priv;
lp766drivers/net/atp.clp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
lp767drivers/net/atp.cwrite_reg_high(ioaddr, CMR2, lp->addr_mode);
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;
lp595drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp597drivers/net/de4x5.clp->bus = tmpbus;
lp598drivers/net/de4x5.clp->chipset = tmpchs;
lp604drivers/net/de4x5.clp->autosense = AUTO;
lp606drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp607drivers/net/de4x5.cif ((lp->chipset == DC21040) && (de4x5_autosense & TP_NW)) {
lp610drivers/net/de4x5.cif ((lp->chipset == DC21041) && (de4x5_autosense & BNC_AUI)) {
lp613drivers/net/de4x5.clp->autosense = de4x5_autosense & 0x001f;
lp615drivers/net/de4x5.clp->autosense = de4x5_autosense & 0x00c0;
lp619drivers/net/de4x5.csprintf(lp->adapter_name,"%s (%s)", name, dev->name);
lp620drivers/net/de4x5.crequest_region(iobase, (lp->bus == PCI ? DE4X5_PCI_TOTAL_SIZE :
lp622drivers/net/de4x5.clp->adapter_name);
lp634drivers/net/de4x5.clp->rx_ring[i].status = 0;
lp635drivers/net/de4x5.clp->rx_ring[i].des1 = RX_BUFF_SZ;
lp636drivers/net/de4x5.clp->rx_ring[i].buf = virt_to_bus(tmp + i * RX_BUFF_SZ);
lp637drivers/net/de4x5.clp->rx_ring[i].next = (u32)NULL;
lp644drivers/net/de4x5.clp->rxRingSize = NUM_RX_DESC;
lp645drivers/net/de4x5.clp->txRingSize = NUM_TX_DESC;
lp648drivers/net/de4x5.clp->rx_ring[lp->rxRingSize - 1].des1 |= RD_RER;
lp649drivers/net/de4x5.clp->tx_ring[lp->txRingSize - 1].des1 |= TD_TER;
lp652drivers/net/de4x5.coutl(virt_to_bus(lp->rx_ring), DE4X5_RRBA);
lp653drivers/net/de4x5.coutl(virt_to_bus(lp->tx_ring), DE4X5_TRBA);
lp656drivers/net/de4x5.clp->irq_mask = IMR_RIM | IMR_TIM | IMR_TUM ;
lp657drivers/net/de4x5.clp->irq_en   = IMR_NIM | IMR_AIM;
lp659drivers/net/de4x5.clp->tx_enable = TRUE;
lp700drivers/net/de4x5.cif (status) release_region(iobase, (lp->bus == PCI ? 
lp735drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp740drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp741drivers/net/de4x5.cif (lp) {
lp742drivers/net/de4x5.ckfree_s(bus_to_virt(lp->rx_ring[0].buf),
lp758drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp766drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp771drivers/net/de4x5.cif (request_irq(dev->irq, (void *)de4x5_interrupt, 0, lp->adapter_name)) {
lp790drivers/net/de4x5.cprintk("\t0x%8.8lx  0x%8.8lx\n",(u_long)lp->rx_ring,(u_long)lp->tx_ring);
lp792drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp794drivers/net/de4x5.cprintk("0x%8.8lx  ",(u_long)&lp->rx_ring[i].status);
lp797drivers/net/de4x5.cprintk("...0x%8.8lx\n",(u_long)&lp->rx_ring[i].status);
lp799drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp801drivers/net/de4x5.cprintk("0x%8.8lx  ", (u_long)&lp->tx_ring[i].status);
lp804drivers/net/de4x5.cprintk("...0x%8.8lx\n", (u_long)&lp->tx_ring[i].status);
lp806drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp808drivers/net/de4x5.cprintk("0x%8.8x  ",lp->rx_ring[i].buf);
lp811drivers/net/de4x5.cprintk("...0x%8.8x\n",lp->rx_ring[i].buf);
lp813drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp815drivers/net/de4x5.cprintk("0x%8.8x  ", lp->tx_ring[i].buf);
lp818drivers/net/de4x5.cprintk("...0x%8.8x\n", lp->tx_ring[i].buf);
lp820drivers/net/de4x5.c(short)lp->rxRingSize, 
lp821drivers/net/de4x5.c(short)lp->txRingSize); 
lp871drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp885drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp887drivers/net/de4x5.clp->setup_f = HASH_PERF;
lp890drivers/net/de4x5.clp->setup_f = PERFECT;
lp892drivers/net/de4x5.coutl(virt_to_bus(lp->rx_ring), DE4X5_RRBA);
lp893drivers/net/de4x5.coutl(virt_to_bus(lp->tx_ring), DE4X5_TRBA);
lp895drivers/net/de4x5.clp->rx_new = lp->rx_old = 0;
lp896drivers/net/de4x5.clp->tx_new = lp->tx_old = 0;
lp898drivers/net/de4x5.cfor (i = 0; i < lp->rxRingSize; i++) {
lp899drivers/net/de4x5.clp->rx_ring[i].status = R_OWN;
lp902drivers/net/de4x5.cfor (i = 0; i < lp->txRingSize; i++) {
lp903drivers/net/de4x5.clp->tx_ring[i].status = 0;
lp911drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp912drivers/net/de4x5.cload_packet(dev, lp->setup_frame, HASH_F|TD_SET|SETUP_FRAME_LEN, NULL);
lp914drivers/net/de4x5.cload_packet(dev, lp->setup_frame, PERFECT_F|TD_SET|SETUP_FRAME_LEN, NULL);
lp920drivers/net/de4x5.cif (lp->tx_ring[lp->tx_new].status >= 0) j=1;
lp930drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp931drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp947drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp969drivers/net/de4x5.cif (dev->tbusy || (lp->lostMedia > LOST_MEDIA_THRESHOLD)) {
lp972drivers/net/de4x5.c(lp->lostMedia <= LOST_MEDIA_THRESHOLD)) {
lp976drivers/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);
lp983drivers/net/de4x5.cfor (i=lp->tx_old; i!=lp->tx_new; i=(++i)%lp->txRingSize) {
lp984drivers/net/de4x5.cif (lp->skb[i] != NULL) {
lp985drivers/net/de4x5.cif (lp->skb[i]->len != FAKE_FRAME_LEN) {
lp986drivers/net/de4x5.cif (lp->tx_ring[i].status == T_OWN) {
lp987drivers/net/de4x5.cdev_queue_xmit(lp->skb[i], dev, SOPRI_NORMAL);
lp989drivers/net/de4x5.cdev_kfree_skb(lp->skb[i], FREE_WRITE);
lp992drivers/net/de4x5.cdev_kfree_skb(lp->skb[i], FREE_WRITE);
lp994drivers/net/de4x5.clp->skb[i] = NULL;
lp1043drivers/net/de4x5.cif (lp->tx_enable) {
lp1047drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize; /* Ensure a wrap */
lp1078drivers/net/de4x5.cstruct de4x5_private *lp;
lp1085drivers/net/de4x5.clp = (struct de4x5_private *)dev->priv;
lp1094drivers/net/de4x5.cwhile ((sts = inl(DE4X5_STS)) & lp->irq_mask) { /* Read IRQ status */
lp1107drivers/net/de4x5.clp->lostMedia = LOST_MEDIA_THRESHOLD + 1;
lp1108drivers/net/de4x5.clp->irq_mask &= ~IMR_LFM;
lp1134drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1139drivers/net/de4x5.cfor (entry = lp->rx_new; lp->rx_ring[entry].status >= 0;entry = lp->rx_new) {
lp1140drivers/net/de4x5.cstatus = lp->rx_ring[entry].status;
lp1143drivers/net/de4x5.clp->rx_old = entry;
lp1148drivers/net/de4x5.clp->stats.rx_errors++;              /* Update the error stats. */
lp1149drivers/net/de4x5.cif (status & (RD_RF | RD_TL)) lp->stats.rx_frame_errors++;
lp1150drivers/net/de4x5.cif (status & RD_CE)           lp->stats.rx_crc_errors++;
lp1151drivers/net/de4x5.cif (status & RD_OF)           lp->stats.rx_fifo_errors++;
lp1154drivers/net/de4x5.cshort pkt_len = (short)(lp->rx_ring[entry].status >> 16) - 4;
lp1160drivers/net/de4x5.cif (entry < lp->rx_old) {         /* Wrapped buffer */
lp1161drivers/net/de4x5.cshort len = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
lp1162drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
lp1163drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
lp1165drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), pkt_len);
lp1173drivers/net/de4x5.clp->stats.rx_packets++;
lp1176drivers/net/de4x5.clp->pktStats.bins[i]++;
lp1183drivers/net/de4x5.clp->pktStats.broadcast++;
lp1185drivers/net/de4x5.clp->pktStats.multicast++;
lp1189drivers/net/de4x5.clp->pktStats.unicast++;
lp1192drivers/net/de4x5.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1193drivers/net/de4x5.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1194drivers/net/de4x5.cmemset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
lp1198drivers/net/de4x5.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1204drivers/net/de4x5.cfor (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)%lp->rxRingSize) {
lp1205drivers/net/de4x5.clp->rx_ring[lp->rx_old].status = R_OWN;
lp1208drivers/net/de4x5.clp->rx_ring[entry].status = R_OWN;
lp1215drivers/net/de4x5.clp->rx_new = (++lp->rx_new) % lp->rxRingSize;
lp1227drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1232drivers/net/de4x5.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
lp1233drivers/net/de4x5.cstatus = lp->tx_ring[entry].status;
lp1237drivers/net/de4x5.clp->stats.tx_errors++; 
lp1238drivers/net/de4x5.cif (status & TD_NC)  lp->stats.tx_carrier_errors++;
lp1239drivers/net/de4x5.cif (status & TD_LC)  lp->stats.tx_window_errors++;
lp1240drivers/net/de4x5.cif (status & TD_UF)  lp->stats.tx_fifo_errors++;
lp1241drivers/net/de4x5.cif (status & TD_LC)  lp->stats.collisions++;
lp1242drivers/net/de4x5.cif (status & TD_EC)  lp->pktStats.excessive_collisions++;
lp1243drivers/net/de4x5.cif (status & TD_DE)  lp->stats.tx_aborted_errors++;
lp1247drivers/net/de4x5.clp->lostMedia++;
lp1248drivers/net/de4x5.cif (lp->lostMedia > LOST_MEDIA_THRESHOLD) { /* Trip autosense */
lp1255drivers/net/de4x5.clp->stats.tx_packets++;
lp1256drivers/net/de4x5.clp->lostMedia = 0;                         /* Remove transient problem */
lp1259drivers/net/de4x5.cif (lp->skb[entry] != NULL) {
lp1260drivers/net/de4x5.cdev_kfree_skb(lp->skb[entry], FREE_WRITE);
lp1261drivers/net/de4x5.clp->skb[entry] = NULL;
lp1265drivers/net/de4x5.clp->tx_old = (++lp->tx_old) % lp->txRingSize;
lp1274drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1280drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp1282drivers/net/de4x5.cif (((lp->media == _100Mb) &&  (gep & GEP_SLNK)) ||
lp1283drivers/net/de4x5.c((lp->media == _10Mb)  &&  (gep & GEP_LNP))  ||
lp1284drivers/net/de4x5.c((lp->media == _10Mb)  && !(gep & GEP_SLNK)) ||
lp1285drivers/net/de4x5.c(lp->media == NC)) {
lp1286drivers/net/de4x5.cif (lp->linkProb || ((lp->media == NC) && (!(gep & GEP_LNP)))) {
lp1287drivers/net/de4x5.clp->lostMedia = LOST_MEDIA_THRESHOLD + 1;
lp1288drivers/net/de4x5.clp->linkProb = 0;
lp1291drivers/net/de4x5.cswitch(lp->media) {
lp1293drivers/net/de4x5.clp->linkProb = 0;
lp1298drivers/net/de4x5.clp->linkProb = 1;                    /* Flag a potential problem */
lp1303drivers/net/de4x5.clp->linkProb = 1;                    /* Flag a potential problem */
lp1309drivers/net/de4x5.clp->linkProb = 0;                        /* Link OK */
lp1320drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1348drivers/net/de4x5.cif (lp->chipset == DC21041) {
lp1359drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1362drivers/net/de4x5.clp->stats.rx_missed_errors = (int) (inl(DE4X5_MFC) & (MFC_OVFL | MFC_CNTR));
lp1364drivers/net/de4x5.creturn &lp->stats;
lp1369drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1371drivers/net/de4x5.clp->tx_ring[lp->tx_new].buf = virt_to_bus(buf);
lp1372drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 &= TD_TER;
lp1373drivers/net/de4x5.clp->tx_ring[lp->tx_new].des1 |= flags;
lp1374drivers/net/de4x5.clp->skb[lp->tx_new] = skb;
lp1376drivers/net/de4x5.clp->tx_ring[lp->tx_new].status = T_OWN;
lp1394drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1401drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp1402drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp1405drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET | 
lp1409drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp1425drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1435drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp1459drivers/net/de4x5.clp->setup_frame[byte] |= bit;
lp1490drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1496drivers/net/de4x5.clp->bus = EISA;
lp1514drivers/net/de4x5.clp->bus = EISA;
lp1515drivers/net/de4x5.clp->chipset = device;
lp1561drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp1566drivers/net/de4x5.clp->bus = PCI;
lp1586drivers/net/de4x5.clp->device = dev_num;
lp1587drivers/net/de4x5.clp->bus_num = pb;
lp1590drivers/net/de4x5.clp->chipset = device;
lp1749drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1752drivers/net/de4x5.clp->tx_enable = YES;
lp1754drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp1761drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp1762drivers/net/de4x5.clp->media = (lp->autosense == AUTO ? TP : lp->autosense);
lp1764drivers/net/de4x5.c} else if (lp->chipset == DC21041) {
lp1765drivers/net/de4x5.clp->media = (lp->autosense == AUTO ? TP_NW : lp->autosense);
lp1767drivers/net/de4x5.c} else if (lp->chipset == DC21140) {
lp1769drivers/net/de4x5.clp->media = (lp->autosense == AUTO ? _10Mb : lp->autosense);
lp1774drivers/net/de4x5.cif (lp->chipset != DC21140) {
lp1775drivers/net/de4x5.cprintk("media is %s\n", (lp->media == NC  ? "unconnected!" :
lp1776drivers/net/de4x5.c(lp->media == TP  ? "TP." :
lp1777drivers/net/de4x5.c(lp->media == ANS ? "TP/Nway." :
lp1778drivers/net/de4x5.c(lp->media == BNC ? "BNC." : 
lp1779drivers/net/de4x5.c(lp->media == AUI ? "AUI." : 
lp1783drivers/net/de4x5.cprintk("mode is %s\n",(lp->media == NC      ? "link down.":
lp1784drivers/net/de4x5.c(lp->media == _100Mb  ? "100Mb/s." :
lp1785drivers/net/de4x5.c(lp->media == _10Mb   ? "10Mb/s." :
lp1791drivers/net/de4x5.cif (lp->media) {
lp1792drivers/net/de4x5.clp->lostMedia = 0;
lp1794drivers/net/de4x5.cif ((lp->media == TP) || (lp->media == ANS)) {
lp1795drivers/net/de4x5.clp->irq_mask |= IMR_LFM;
lp1800drivers/net/de4x5.creturn (lp->media);
lp1805drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1810drivers/net/de4x5.cswitch (lp->media) {
lp1817drivers/net/de4x5.cif (linkBad && (lp->autosense == AUTO)) {
lp1818drivers/net/de4x5.clp->media = BNC_AUI;
lp1829drivers/net/de4x5.cif (linkBad && (lp->autosense == AUTO)) {
lp1830drivers/net/de4x5.clp->media = NC;
lp1856drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1860drivers/net/de4x5.cswitch (lp->media) {
lp1868drivers/net/de4x5.clp->media = ANS;
lp1870drivers/net/de4x5.clp->media = AUI;
lp1879drivers/net/de4x5.cif (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
lp1880drivers/net/de4x5.clp->media = TP;
lp1891drivers/net/de4x5.cif (!(sts & STS_LNP) && (lp->autosense == AUTO)) {
lp1893drivers/net/de4x5.clp->media = AUI;
lp1895drivers/net/de4x5.clp->media = BNC;
lp1907drivers/net/de4x5.cif (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
lp1908drivers/net/de4x5.clp->media = BNC;
lp1919drivers/net/de4x5.cif (!(inl(DE4X5_SISR) & SISR_SRA) && (lp->autosense == AUTO)) {
lp1920drivers/net/de4x5.clp->media = NC;
lp1922drivers/net/de4x5.cif (ping_media(dev)) lp->media = NC;
lp1941drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp1945drivers/net/de4x5.cswitch(lp->media) {
lp1967drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2019drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2027drivers/net/de4x5.centry = lp->tx_new;                        /* Remember the ring position */
lp2033drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp2034drivers/net/de4x5.clp->tx_old = lp->tx_new;
lp2039drivers/net/de4x5.cif (lp->tx_ring[entry].status >= 0) linkBad=0;
lp2044drivers/net/de4x5.creturn ((linkBad || (lp->tx_ring[entry].status & TD_ES)) ? 1 : 0);
lp2053drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2080drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2096drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2100drivers/net/de4x5.cif (lp->chipset == DC21140) {
lp2218drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp2224drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2226drivers/net/de4x5.cif (lp->bus == PCI) {
lp2248drivers/net/de4x5.cshort *p = (short *)&lp->srom;
lp2262drivers/net/de4x5.cstruct bus_type *lp = &bus;
lp2268drivers/net/de4x5.cif (lp->bus == PCI) {
lp2269drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2277drivers/net/de4x5.cdev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
lp2278drivers/net/de4x5.cdev->dev_addr[i] = (u_char) lp->srom.ieee_addr[i]; i++;
lp2291drivers/net/de4x5.cif (lp->bus == PCI) {
lp2292drivers/net/de4x5.cif (lp->chipset == DC21040) {
lp2415drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2417drivers/net/de4x5.cchar *pa = lp->setup_frame;
lp2421drivers/net/de4x5.cmemset(lp->setup_frame, 0, SETUP_FRAME_LEN);
lp2424drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp2425drivers/net/de4x5.cfor (pa=lp->setup_frame+IMPERF_PA_OFFSET, i=0; i<ETH_ALEN; i++) {
lp2429drivers/net/de4x5.c*(lp->setup_frame + (HASH_TABLE_LEN >> 3) - 3) = 0x80; /* B'cast address */
lp2446drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2449drivers/net/de4x5.clp->irq_mask |= IMR_TMM;
lp2450drivers/net/de4x5.coutl(lp->irq_mask, DE4X5_IMR);
lp2458drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2461drivers/net/de4x5.clp->irq_mask &= ~IMR_TMM;
lp2462drivers/net/de4x5.coutl(lp->irq_mask, DE4X5_IMR);
lp2488drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *)dev->priv;
lp2526drivers/net/de4x5.cif (lp->setup_f == HASH_PERF) {
lp2527drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | HASH_F | TD_SET | 
lp2530drivers/net/de4x5.cload_packet(dev, lp->setup_frame, TD_IC | PERFECT_F | TD_SET | 
lp2533drivers/net/de4x5.clp->tx_new = (++lp->tx_new) % lp->txRingSize;
lp2567drivers/net/de4x5.cmemcpy_tofs(ioc->data, lp->setup_frame, ioc->len); 
lp2604drivers/net/de4x5.cioc->len = sizeof(lp->pktStats);
lp2610drivers/net/de4x5.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
lp2617drivers/net/de4x5.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp2666drivers/net/de4x5.ctmp.addr[j++] = lp->rxRingSize;
lp2667drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->rx_ring; j+=4;
lp2668drivers/net/de4x5.ctmp.lval[j>>2] = (long)lp->tx_ring; j+=4;
lp2670drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp2672drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp2675drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->rx_ring[i].status; j+=4;
lp2676drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp2678drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp2681drivers/net/de4x5.ctmp.lval[j>>2] = (long)&lp->tx_ring[i].status; j+=4;
lp2683drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize-1;i++){
lp2685drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->rx_ring[i].buf; j+=4;
lp2688drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->rx_ring[i].buf; j+=4;
lp2689drivers/net/de4x5.cfor (i=0;i<lp->txRingSize-1;i++){
lp2691drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->tx_ring[i].buf; j+=4;
lp2694drivers/net/de4x5.ctmp.lval[j>>2] = (s32)lp->tx_ring[i].buf; j+=4;
lp2696drivers/net/de4x5.cfor (i=0;i<lp->rxRingSize;i++){
lp2697drivers/net/de4x5.ctmp.lval[j>>2] = lp->rx_ring[i].status; j+=4;
lp2699drivers/net/de4x5.cfor (i=0;i<lp->txRingSize;i++){
lp2700drivers/net/de4x5.ctmp.lval[j>>2] = lp->tx_ring[i].status; j+=4;
lp2712drivers/net/de4x5.ctmp.addr[j++] = lp->txRingSize;
lp2752drivers/net/de4x5.cstruct de4x5_private *lp = (struct de4x5_private *) thisDE4X5.priv;
lp2757drivers/net/de4x5.cif (lp) {
lp2758drivers/net/de4x5.ckfree_s(bus_to_virt(lp->rx_ring[0].buf), RX_BUFF_SZ * NUM_RX_DESC + ALIGN);
lp2763drivers/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;
lp514drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp516drivers/net/depca.clp->adapter = adapter;
lp517drivers/net/depca.csprintf(lp->adapter_name,"%s (%s)", name, dev->name);
lp518drivers/net/depca.crequest_region(ioaddr, DEPCA_TOTAL_SIZE, lp->adapter_name);
lp521drivers/net/depca.clp->sh_mem = mem_start;
lp526drivers/net/depca.clp->rx_ring = (struct depca_rx_desc *)mem_start;
lp529drivers/net/depca.clp->tx_ring = (struct depca_tx_desc *)mem_start;
lp532drivers/net/depca.clp->bus_offset = mem_start & 0x00ff0000;
lp535drivers/net/depca.clp->dma_buffs = mem_start;
lp538drivers/net/depca.clp->rxRingMask = NUM_RX_DESC - 1;
lp539drivers/net/depca.clp->txRingMask = NUM_TX_DESC - 1;
lp542drivers/net/depca.cfor (i=0, j = lp->rxRingMask; j>0; i++) {
lp545drivers/net/depca.clp->rx_rlen = (s32)(i << 29);
lp546drivers/net/depca.cfor (i=0, j = lp->txRingMask; j>0; i++) {
lp549drivers/net/depca.clp->tx_rlen = (s32)(i << 29);
lp569drivers/net/depca.cswitch (lp->adapter) {
lp655drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp659drivers/net/depca.cstruct depca_init *p = (struct depca_init *)lp->sh_mem;
lp661drivers/net/depca.cif (request_irq(dev->irq, &depca_interrupt, 0, lp->adapter_name)) {
lp682drivers/net/depca.cmemcpy_toio((char *)lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
lp686drivers/net/depca.cprintk("\t0x%lx  0x%lx\n",(u_long)lp->rx_ring, (u_long)lp->tx_ring);
lp688drivers/net/depca.cfor (i=0;i<lp->rxRingMask;i++){
lp690drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
lp693drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
lp695drivers/net/depca.cfor (i=0;i<lp->txRingMask;i++){
lp697drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
lp700drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
lp702drivers/net/depca.cfor (i=0;i<lp->rxRingMask;i++){
lp704drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->rx_ring[i].base));
lp707drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
lp709drivers/net/depca.cfor (i=0;i<lp->txRingMask;i++){
lp711drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->tx_ring[i].base));
lp714drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
lp716drivers/net/depca.cprintk("Initialisation block at 0x%8.8lx\n",lp->sh_mem);
lp730drivers/net/depca.cprintk("dma_buffs: 0x%8.8lx\n",lp->dma_buffs);
lp732drivers/net/depca.c(int)lp->rxRingMask + 1, 
lp733drivers/net/depca.clp->rx_rlen);
lp735drivers/net/depca.c(int)lp->txRingMask + 1, 
lp736drivers/net/depca.clp->tx_rlen);
lp770drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp777drivers/net/depca.clp->rx_new = lp->tx_new = 0;
lp778drivers/net/depca.clp->rx_old = lp->tx_old = 0;
lp781drivers/net/depca.cfor (i = 0; i <= lp->rxRingMask; i++) {
lp782drivers/net/depca.cwritel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
lp783drivers/net/depca.cwritew(-RX_BUFF_SZ, &lp->rx_ring[i].buf_length);
lp784drivers/net/depca.clp->rx_memcpy[i]=(char *)(p+lp->bus_offset);
lp786drivers/net/depca.cfor (i = 0; i <= lp->txRingMask; i++) {
lp787drivers/net/depca.cwritel((p=lp->dma_buffs+(i+lp->txRingMask+1)*TX_BUFF_SZ) & 0x00ffffff,
lp788drivers/net/depca.c&lp->tx_ring[i].base);
lp789drivers/net/depca.clp->tx_memcpy[i]=(char *)(p+lp->bus_offset);
lp793drivers/net/depca.clp->init_block.rx_ring = ((u32)((u_long)lp->rx_ring)&LA_MASK) | lp->rx_rlen;
lp794drivers/net/depca.clp->init_block.tx_ring = ((u32)((u_long)lp->tx_ring)&LA_MASK) | lp->tx_rlen;
lp799drivers/net/depca.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp802drivers/net/depca.clp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */
lp813drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp874drivers/net/depca.cstruct depca_private *lp;
lp881drivers/net/depca.clp = (struct depca_private *)dev->priv;
lp924drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp928drivers/net/depca.cfor (entry=lp->rx_new; 
lp929drivers/net/depca.c!(readl(&lp->rx_ring[entry].base) & R_OWN);
lp930drivers/net/depca.centry=lp->rx_new){
lp931drivers/net/depca.cstatus = readl(&lp->rx_ring[entry].base) >> 16 ;
lp933drivers/net/depca.clp->rx_old = entry;
lp937drivers/net/depca.clp->stats.rx_errors++;                 /* Update the error stats. */
lp938drivers/net/depca.cif (status & R_FRAM) lp->stats.rx_frame_errors++;
lp939drivers/net/depca.cif (status & R_OFLO) lp->stats.rx_over_errors++;
lp940drivers/net/depca.cif (status & R_CRC)  lp->stats.rx_crc_errors++;
lp941drivers/net/depca.cif (status & R_BUFF) lp->stats.rx_fifo_errors++;
lp943drivers/net/depca.cshort len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
lp952drivers/net/depca.cif (entry < lp->rx_old) {         /* Wrapped buffer */
lp953drivers/net/depca.clen = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
lp954drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], len);
lp955drivers/net/depca.cmemcpy_fromio(buf + len, lp->rx_memcpy[0], pkt_len-len);
lp957drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], pkt_len);
lp970drivers/net/depca.clp->stats.rx_packets++;
lp973drivers/net/depca.clp->pktStats.bins[i]++;
lp979drivers/net/depca.clp->pktStats.broadcast++;
lp981drivers/net/depca.clp->pktStats.multicast++;
lp985drivers/net/depca.clp->pktStats.unicast++;
lp988drivers/net/depca.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp989drivers/net/depca.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp990drivers/net/depca.cmemset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
lp994drivers/net/depca.clp->stats.rx_dropped++;  /* Really, deferred. */
lp999drivers/net/depca.cfor (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)&lp->rxRingMask) {
lp1000drivers/net/depca.cwritel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, 
lp1001drivers/net/depca.c&lp->rx_ring[lp->rx_old].base);
lp1003drivers/net/depca.cwritel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
lp1009drivers/net/depca.clp->rx_new = (++lp->rx_new) & lp->rxRingMask;
lp1021drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1026drivers/net/depca.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
lp1027drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].base) >> 16 ;
lp1032drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].misc);
lp1033drivers/net/depca.clp->stats.tx_errors++;
lp1034drivers/net/depca.cif (status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
lp1035drivers/net/depca.cif (status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
lp1036drivers/net/depca.cif (status & TMD3_LCOL) lp->stats.tx_window_errors++;
lp1037drivers/net/depca.cif (status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
lp1044drivers/net/depca.clp->stats.collisions++;
lp1046drivers/net/depca.clp->stats.tx_packets++;
lp1050drivers/net/depca.clp->tx_old = (++lp->tx_old) & lp->txRingMask;
lp1059drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1082drivers/net/depca.cif (lp->adapter != DEPCA) {
lp1101drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1105drivers/net/depca.coutw((u16)(lp->sh_mem & LA_MASK), DEPCA_DATA);
lp1107drivers/net/depca.coutw((u16)((lp->sh_mem & LA_MASK) >> 16), DEPCA_DATA);
lp1118drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1123drivers/net/depca.cmemcpy_toio((char *)lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
lp1136drivers/net/depca.cdev->name, i, lp->sh_mem, inw(DEPCA_DATA));
lp1140drivers/net/depca.cdev->name, i, lp->sh_mem, inw(DEPCA_DATA));
lp1150drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1154drivers/net/depca.creturn &lp->stats;
lp1167drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1173drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1180drivers/net/depca.clp->init_block.mode &= ~PROM;   /* Unset promiscuous mode */
lp1182drivers/net/depca.clp->init_block.mode |= PROM;    /* Set promiscuous mode */
lp1199drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1206drivers/net/depca.clp->init_block.mcast_table[i] = (char)0xff;
lp1211drivers/net/depca.clp->init_block.mcast_table[i]=0;
lp1232drivers/net/depca.clp->init_block.mcast_table[byte] |= bit;
lp1567drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1570drivers/net/depca.centry = lp->tx_new;                     /* Ring around buffer number. */
lp1571drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
lp1572drivers/net/depca.cif (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
lp1578drivers/net/depca.clen = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
lp1579drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
lp1580drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
lp1582drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
lp1587drivers/net/depca.cfor (i = entry; i != end; i = (++i) & lp->txRingMask) {
lp1589drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
lp1590drivers/net/depca.cwritew(0x0000, &lp->tx_ring[i].misc);       /* clears other error flags */
lp1591drivers/net/depca.cwritew(-TX_BUFF_SZ, &lp->tx_ring[i].length);/* packet length in buffer */
lp1595drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
lp1596drivers/net/depca.cwritew(0x0000, &lp->tx_ring[end].misc);       /* clears other error flags */
lp1597drivers/net/depca.cwritew(-len, &lp->tx_ring[end].length);       /* packet length in last buff */
lp1600drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
lp1602drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
lp1606drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
lp1607drivers/net/depca.cif (i == 0) i=lp->txRingMask+1;
lp1609drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
lp1611drivers/net/depca.clp->tx_new = (++end) & lp->txRingMask;     /* update current pointers */
lp1659drivers/net/depca.cstruct depca_private *lp = (struct depca_private *)dev->priv;
lp1689drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);/* Wait for the ring to empty */
lp1706drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1710drivers/net/depca.clp->init_block.mode |= PROM;      /* Set promiscuous mode */
lp1724drivers/net/depca.cwhile(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
lp1728drivers/net/depca.clp->init_block.mode &= ~PROM;     /* Clear promiscuous mode */
lp1745drivers/net/depca.cmemcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len); 
lp1782drivers/net/depca.cioc->len = sizeof(lp->pktStats);
lp1784drivers/net/depca.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
lp1792drivers/net/depca.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1804drivers/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;  
lp780drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp782drivers/net/eepro.creturn &lp->stats;
lp794drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp830drivers/net/eepro.coutw(lp->tx_end, ioaddr + HOST_ADDRESS_REG);
lp844drivers/net/eepro.coutw(lp->tx_end, ioaddr + XMT_BAR);
lp848drivers/net/eepro.ci = lp->tx_end + XMT_HEADER + 6*(num_addrs + 1);
lp849drivers/net/eepro.cif (lp->tx_start != lp->tx_end) { 
lp852drivers/net/eepro.coutw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
lp854drivers/net/eepro.coutw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
lp857drivers/net/eepro.clp->tx_end = i ;
lp858drivers/net/eepro.c} else lp->tx_start = lp->tx_end = i ;
lp936drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp946drivers/net/eepro.cif (lp->tx_end > lp->tx_start)
lp947drivers/net/eepro.ctx_available = XMT_RAM - (lp->tx_end - lp->tx_start);
lp948drivers/net/eepro.celse if (lp->tx_end < lp->tx_start)
lp949drivers/net/eepro.ctx_available = lp->tx_start - lp->tx_end;
lp961drivers/net/eepro.clast = lp->tx_end;
lp981drivers/net/eepro.cif (lp->tx_start != lp->tx_end) { 
lp984drivers/net/eepro.cif (lp->tx_end != last) {
lp985drivers/net/eepro.coutw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
lp988drivers/net/eepro.coutw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
lp999drivers/net/eepro.cif (lp->tx_start == lp->tx_end) {
lp1002drivers/net/eepro.clp->tx_start = last;   /* I don't like to change tx_start here */
lp1006drivers/net/eepro.clp->tx_last = last;
lp1007drivers/net/eepro.clp->tx_end = end;
lp1026drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp1029drivers/net/eepro.cshort rcv_car = lp->rx_start;
lp1052drivers/net/eepro.clp->stats.rx_dropped++;
lp1062drivers/net/eepro.clp->stats.rx_packets++;
lp1066drivers/net/eepro.clp->stats.rx_errors++;
lp1068drivers/net/eepro.clp->stats.rx_over_errors++;
lp1070drivers/net/eepro.clp->stats.rx_frame_errors++;
lp1072drivers/net/eepro.clp->stats.rx_crc_errors++;
lp1077drivers/net/eepro.clp->stats.rx_length_errors++;
lp1081drivers/net/eepro.crcv_car = lp->rx_start + RCV_HEADER + rcv_size;
lp1082drivers/net/eepro.clp->rx_start = rcv_next_frame;
lp1098drivers/net/eepro.cstruct eepro_local *lp = (struct eepro_local *)dev->priv;
lp1103drivers/net/eepro.cwhile (lp->tx_start != lp->tx_end) { 
lp1105drivers/net/eepro.coutw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
lp1109drivers/net/eepro.clp->tx_start = inw(ioaddr+IO_PORT);
lp1117drivers/net/eepro.clp->stats.tx_packets++;
lp1119drivers/net/eepro.clp->stats.tx_errors++;
lp1121drivers/net/eepro.clp->stats.tx_carrier_errors++;
lp1126drivers/net/eepro.clp->stats.collisions += (xmt_status & 0x000f);
lp1128drivers/net/eepro.clp->stats.tx_heartbeat_errors++;
lp454drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp467drivers/net/eexpress.clp->stats.tx_errors++;
lp469drivers/net/eexpress.cif (lp->last_restart == lp->stats.tx_packets) {
lp478drivers/net/eexpress.clp->last_restart = lp->stats.tx_packets;
lp510drivers/net/eexpress.clp->stats.tx_aborted_errors++;
lp521drivers/net/eexpress.cstruct net_local *lp;
lp532drivers/net/eexpress.clp = (struct net_local *)dev->priv;
lp544drivers/net/eexpress.cwhile (lp->tx_reap != lp->tx_head) {   /* if (status & 0x8000) */
lp546drivers/net/eexpress.coutw(lp->tx_reap, ioaddr + READ_PTR);
lp549drivers/net/eexpress.cif (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
lp553drivers/net/eexpress.clp->stats.tx_packets++;
lp554drivers/net/eexpress.clp->stats.collisions += tx_status & 0xf;
lp558drivers/net/eexpress.clp->stats.tx_errors++;
lp559drivers/net/eexpress.cif (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
lp560drivers/net/eexpress.cif (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
lp561drivers/net/eexpress.cif (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
lp562drivers/net/eexpress.cif (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
lp565drivers/net/eexpress.cprintk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
lp566drivers/net/eexpress.clp->tx_reap += TX_BUF_SIZE;
lp567drivers/net/eexpress.cif (lp->tx_reap > TX_BUF_END - TX_BUF_SIZE)
lp568drivers/net/eexpress.clp->tx_reap = TX_BUF_START;
lp575drivers/net/eexpress.cprintk("Received packet, rx_head %04x.\n", lp->rx_head);
lp594drivers/net/eexpress.clp->tx_cmd_link = IDLELOOP + 4;
lp595drivers/net/eexpress.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp605drivers/net/eexpress.clp->stats.rx_errors++;
lp609drivers/net/eexpress.cdev->name, status, lp->rx_head, lp->rx_tail);
lp673drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp677drivers/net/eexpress.creturn &lp->stats;
lp757drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp777drivers/net/eexpress.clp->tx_cmd_link = DUMP_DATA + 4;
lp779drivers/net/eexpress.clp->tx_cmd_link = IDLELOOP + 4;
lp781drivers/net/eexpress.clp->tx_head = lp->tx_reap = TX_BUF_START;
lp815drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp818drivers/net/eexpress.cint cur_rxbuf = lp->rx_head = RX_BUF_START;
lp842drivers/net/eexpress.clp->rx_tail = cur_rxbuf;
lp848drivers/net/eexpress.coutw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
lp850drivers/net/eexpress.coutw(lp->rx_head, ioaddr);        /* Link */
lp856drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp858drivers/net/eexpress.cshort tx_block = lp->tx_head;
lp883drivers/net/eexpress.coutw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
lp885drivers/net/eexpress.clp->tx_cmd_link = tx_block + 20;
lp888drivers/net/eexpress.clp->tx_head = tx_block + TX_BUF_SIZE;
lp889drivers/net/eexpress.cif (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
lp890drivers/net/eexpress.clp->tx_head = TX_BUF_START;
lp895drivers/net/eexpress.ctx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
lp898drivers/net/eexpress.cif (lp->tx_head != lp->tx_reap)
lp905drivers/net/eexpress.cstruct net_local *lp = (struct net_local *)dev->priv;
lp908drivers/net/eexpress.cshort rx_head = lp->rx_head;
lp909drivers/net/eexpress.cshort rx_tail = lp->rx_tail;
lp933drivers/net/eexpress.clp->stats.rx_errors++;
lp934drivers/net/eexpress.cif (frame_status & 0x0800) lp->stats.rx_crc_errors++;
lp935drivers/net/eexpress.cif (frame_status & 0x0400) lp->stats.rx_frame_errors++;
lp936drivers/net/eexpress.cif (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
lp937drivers/net/eexpress.cif (frame_status & 0x0100) lp->stats.rx_over_errors++;
lp938drivers/net/eexpress.cif (frame_status & 0x0080) lp->stats.rx_length_errors++;
lp947drivers/net/eexpress.clp->stats.rx_dropped++;
lp959drivers/net/eexpress.clp->stats.rx_packets++;
lp996drivers/net/eexpress.clp->rx_head = rx_head;
lp997drivers/net/eexpress.clp->rx_tail = rx_tail;
lp399drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp551drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp553drivers/net/ewrk3.clp->shmem_base = mem_start;
lp554drivers/net/ewrk3.clp->shmem_length = shmem_length;
lp555drivers/net/ewrk3.clp->lemac = lemac;
lp556drivers/net/ewrk3.clp->hard_strapped = hard_strapped;
lp558drivers/net/ewrk3.clp->mPage = 64;
lp559drivers/net/ewrk3.cif (cmr & DRAM) lp->mPage <<= 1 ;     /* 2 DRAMS on module */ 
lp650drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp660drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp681drivers/net/ewrk3.cif (lp->shmem_length == 0) {
lp684drivers/net/ewrk3.cprintk("\tstart of shared memory: 0x%08lx\n",lp->shmem_base);
lp685drivers/net/ewrk3.cprintk("\twindow length: 0x%04lx\n",lp->shmem_length);
lp727drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp747drivers/net/ewrk3.cfor (page=1;page<lp->mPage;page++) {      /* Write the free page numbers */
lp751drivers/net/ewrk3.clp->lock = 0;                             /* Ensure there are no locks */
lp762drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp768drivers/net/ewrk3.cif (dev->tbusy || lp->lock) {
lp772drivers/net/ewrk3.c} else if (!lp->hard_strapped) {
lp816drivers/net/ewrk3.cif ((page = inb(EWRK3_FMQ)) < lp->mPage) {
lp822drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp823drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp825drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp826drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp828drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp829drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp831drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp832drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp846drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp861drivers/net/ewrk3.cif (lp->txc) {
lp884drivers/net/ewrk3.clp->lock = 0;         /* unlock the page register */
lp912drivers/net/ewrk3.cstruct ewrk3_private *lp;
lp919drivers/net/ewrk3.clp = (struct ewrk3_private *)dev->priv;
lp976drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp982drivers/net/ewrk3.cif ((page = inb(EWRK3_RQ)) < lp->mPage) {/* Get next entry's buffer page */
lp989drivers/net/ewrk3.cif ((tmpLock = set_bit(0, (void *)&lp->lock)) == 1) {   /* Assert lock */
lp990drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {              /* Get existing page */
lp1000drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1002drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_2K) {
lp1003drivers/net/ewrk3.cbuf = (char *) lp->shmem_base;
lp1005drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_32K) {
lp1006drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
lp1008drivers/net/ewrk3.c} else if (lp->shmem_length == SHMEM_64K) {
lp1009drivers/net/ewrk3.cbuf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
lp1020drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1031drivers/net/ewrk3.clp->stats.rx_errors++;            /* Update the error stats. */
lp1032drivers/net/ewrk3.cif (rx_status & DBE) lp->stats.rx_frame_errors++;
lp1033drivers/net/ewrk3.cif (rx_status & CRC) lp->stats.rx_crc_errors++;
lp1034drivers/net/ewrk3.cif (rx_status & PLL) lp->stats.rx_fifo_errors++;
lp1044drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1064drivers/net/ewrk3.clp->stats.rx_packets++;
lp1067drivers/net/ewrk3.clp->pktStats.bins[i]++;
lp1074drivers/net/ewrk3.clp->pktStats.broadcast++;
lp1076drivers/net/ewrk3.clp->pktStats.multicast++;
lp1080drivers/net/ewrk3.clp->pktStats.unicast++;
lp1083drivers/net/ewrk3.clp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
lp1084drivers/net/ewrk3.cif (lp->pktStats.bins[0] == 0) {  /* Reset counters */
lp1085drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1089drivers/net/ewrk3.clp->stats.rx_dropped++;        /* Really, deferred. */
lp1100drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {    /* Replace old page */
lp1106drivers/net/ewrk3.clp->lock = 0;                           /* Unlock the page register */
lp1121drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1128drivers/net/ewrk3.clp->stats.tx_errors++;
lp1129drivers/net/ewrk3.cif (tx_status & MAC_NCL)    lp->stats.tx_carrier_errors++;
lp1130drivers/net/ewrk3.cif (tx_status & MAC_LCL)    lp->stats.tx_window_errors++;
lp1133drivers/net/ewrk3.clp->pktStats.tx_underruns++;
lp1135drivers/net/ewrk3.clp->pktStats.excessive_underruns++;
lp1139drivers/net/ewrk3.clp->stats.collisions++;
lp1141drivers/net/ewrk3.clp->pktStats.excessive_collisions++;
lp1145drivers/net/ewrk3.clp->stats.tx_packets++;
lp1156drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1185drivers/net/ewrk3.cif (!lp->hard_strapped) {
lp1201drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1205drivers/net/ewrk3.creturn &lp->stats;
lp1218drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1225drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1228drivers/net/ewrk3.cmulticast_table = (char *)(lp->shmem_base + PAGE0_HTE);
lp1253drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1260drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1262drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1271drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1280drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1308drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1325drivers/net/ewrk3.clp->lock = 0;                              /* Unlock the page register */
lp1613drivers/net/ewrk3.cstruct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
lp1685drivers/net/ewrk3.cwhile (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
lp1686drivers/net/ewrk3.cif (lp->shmem_length == IO_ONLY) {
lp1694drivers/net/ewrk3.cmemcpy(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
lp1698drivers/net/ewrk3.clp->lock = 0;                               /* Unlock the page register */
lp1735drivers/net/ewrk3.cerr = verify_area(VERIFY_WRITE, (void *)ioc->data, sizeof(lp->pktStats));
lp1739drivers/net/ewrk3.cmemcpy_tofs(ioc->data, &lp->pktStats, sizeof(lp->pktStats)); 
lp1747drivers/net/ewrk3.cmemset(&lp->pktStats, 0, sizeof(lp->pktStats));
lp1818drivers/net/ewrk3.clp->txc = 1;
lp1826drivers/net/ewrk3.clp->txc = 0;
lp214drivers/net/hp100.cstruct hp100_private *lp;
lp293drivers/net/hp100.clp = (struct hp100_private *)dev -> priv;
lp294drivers/net/hp100.clp -> id = eid;
lp296drivers/net/hp100.clp -> soft_model = hp100_inb( SOFT_MODEL );
lp297drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;
lp298drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;
lp304drivers/net/hp100.clp -> memory_size = 0x200 << ( ( hp100_inb( SRAM ) & 0xe0 ) >> 5 );
lp306drivers/net/hp100.clp -> rx_ratio = HP100_RX_RATIO;
lp308drivers/net/hp100.clp -> rx_ratio = hp100_default_rx_ratio;
lp329drivers/net/hp100.clp -> lan_type = hp100_sense_lan( dev );
lp332drivers/net/hp100.cdev -> name, lp -> id -> name, ioaddr, dev -> irq, 
lp333drivers/net/hp100.clp -> memory_size >> ( 10 - 4 ), lp -> rx_ratio );
lp334drivers/net/hp100.cswitch ( lp -> lan_type ) {
lp352drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp354drivers/net/hp100.cif ( request_irq( dev -> irq, hp100_interrupt, SA_INTERRUPT, lp -> id -> name ) )
lp370drivers/net/hp100.clp -> lan_type = hp100_sense_lan( dev );
lp371drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;
lp372drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;
lp405drivers/net/hp100.chp100_outw( ( lp -> memory_size * lp -> rx_ratio ) / 100, RX_MEM_STOP );
lp406drivers/net/hp100.chp100_outw( lp -> memory_size - 1, TX_MEM_STOP );
lp409drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp410drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp420drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp427drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )  /* relogin */
lp450drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp452drivers/net/hp100.cif ( lp -> lan_type < 0 )
lp455drivers/net/hp100.cif ( ( lp -> lan_type = hp100_sense_lan( dev ) ) < 0 )
lp461drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp462drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp472drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 && lp -> hub_status < 0 )
lp477drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp489drivers/net/hp100.cif ( lp -> lan_type != i )
lp493drivers/net/hp100.clp -> lan_type = i;
lp495drivers/net/hp100.cif ( lp -> lan_type == HP100_LAN_100 )
lp496drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp548drivers/net/hp100.clp -> stats.tx_packets++;
lp569drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp574drivers/net/hp100.cif ( lp -> lan_type < 0 )
lp576drivers/net/hp100.cif ( ( lp -> lan_type = hp100_sense_lan( dev ) ) == HP100_LAN_100 )
lp577drivers/net/hp100.clp -> hub_status = hp100_login_to_vg_hub( dev );
lp612drivers/net/hp100.clp -> stats.rx_dropped++;
lp620drivers/net/hp100.clp -> stats.rx_packets++;
lp626drivers/net/hp100.clp -> stats.multicast++; break;
lp652drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp656drivers/net/hp100.clp -> stats.rx_errors += val;
lp657drivers/net/hp100.clp -> stats.rx_over_errors += val;
lp659drivers/net/hp100.clp -> stats.rx_errors += val;
lp660drivers/net/hp100.clp -> stats.rx_crc_errors += val;
lp662drivers/net/hp100.clp -> stats.tx_errors += val;
lp663drivers/net/hp100.clp -> stats.tx_aborted_errors += val;
lp685drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp697drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE6;  /* promiscuous mode, all good */
lp698drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE6;  /* packets on the net */
lp703drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE5;  /* multicast mode, packets for me */
lp704drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE5;  /* broadcasts and all multicasts */
lp708drivers/net/hp100.clp -> mac2_mode = HP100_MAC2MODE3;  /* normal mode, packets for me */
lp709drivers/net/hp100.clp -> mac1_mode = HP100_MAC1MODE3;  /* and broadcasts */
lp712drivers/net/hp100.chp100_outb( lp -> mac2_mode, MAC_CFG_2 );
lp714drivers/net/hp100.chp100_orb( lp -> mac1_mode, MAC_CFG_1 );
lp736drivers/net/hp100.cstruct hp100_private *lp;
lp762drivers/net/hp100.clp = (struct hp100_private *)dev -> priv;
lp780drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp785drivers/net/hp100.chp100_outb( lp -> mac2_mode, MAC_CFG_2 );
lp787drivers/net/hp100.chp100_orb( lp -> mac1_mode, MAC_CFG_1 );
lp836drivers/net/hp100.cstruct hp100_private *lp = (struct hp100_private *)dev -> priv;
lp846drivers/net/hp100.cif ( lp -> id -> id == 0x02019F022 ) /* HP J27248B doesn't have 100Mb/s interface */
lp337drivers/net/lance.cstruct lance_private *lp;
lp415drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp416drivers/net/lance.clp->name = chipname;
lp417drivers/net/lance.clp->rx_buffs = (long)lp + ((sizeof(struct lance_private) + 7) & ~7);
lp418drivers/net/lance.clp->tx_bounce_buffs = (char (*)[PKT_BUF_SZ])
lp419drivers/net/lance.c(lp->rx_buffs + PKT_BUF_SZ*RX_RING_SIZE);
lp421drivers/net/lance.clp->chip_version = lance_version;
lp423drivers/net/lance.clp->init_block.mode = 0x0003;    /* Disable Rx and Tx. */
lp425drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp426drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp427drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp428drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp429drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp433drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp436drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp544drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
lp568drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp573drivers/net/lance.crequest_irq(dev->irq, &lance_interrupt, 0, lp->name)) {
lp592drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_MUST_UNRESET)
lp595drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
lp603drivers/net/lance.cdev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
lp604drivers/net/lance.c(int) &lp->init_block);
lp609drivers/net/lance.coutw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
lp611drivers/net/lance.coutw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
lp634drivers/net/lance.cdev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
lp654drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp658drivers/net/lance.cif (lp->tx_skbuff[i]) {
lp659drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[i],FREE_WRITE);
lp660drivers/net/lance.clp->tx_skbuff[i] = NULL;
lp670drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp673drivers/net/lance.clp->lock = 0, lp->tx_full = 0;
lp674drivers/net/lance.clp->cur_rx = lp->cur_tx = 0;
lp675drivers/net/lance.clp->dirty_rx = lp->dirty_tx = 0;
lp678drivers/net/lance.clp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
lp679drivers/net/lance.clp->rx_ring[i].buf_length = -PKT_BUF_SZ;
lp684drivers/net/lance.clp->tx_ring[i].base = 0;
lp687drivers/net/lance.clp->init_block.mode = 0x0000;
lp689drivers/net/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
lp690drivers/net/lance.clp->init_block.filter[0] = 0x00000000;
lp691drivers/net/lance.clp->init_block.filter[1] = 0x00000000;
lp692drivers/net/lance.clp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
lp693drivers/net/lance.clp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
lp699drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp702drivers/net/lance.c(chip_table[lp->chip_version].flags & LANCE_MUST_REINIT_RING)) {
lp713drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp727drivers/net/lance.clp->stats.tx_errors++;
lp732drivers/net/lance.clp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
lp733drivers/net/lance.clp->cur_rx);
lp736drivers/net/lance.clp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
lp737drivers/net/lance.clp->rx_ring[i].msg_length);
lp740drivers/net/lance.clp->tx_ring[i].base, -lp->tx_ring[i].length,
lp741drivers/net/lance.clp->tx_ring[i].misc);
lp775drivers/net/lance.cif (set_bit(0, (void*)&lp->lock) != 0) {
lp785drivers/net/lance.centry = lp->cur_tx & TX_RING_MOD_MASK;
lp791drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_MUST_PAD) {
lp792drivers/net/lance.clp->tx_ring[entry].length =
lp795drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
lp797drivers/net/lance.clp->tx_ring[entry].misc = 0x0000;
lp805drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
lp806drivers/net/lance.clp->tx_ring[entry].base =
lp807drivers/net/lance.c(int)(lp->tx_bounce_buffs + entry) | 0x83000000;
lp810drivers/net/lance.clp->tx_skbuff[entry] = skb;
lp811drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
lp813drivers/net/lance.clp->cur_tx++;
lp823drivers/net/lance.clp->lock = 0;
lp824drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
lp827drivers/net/lance.clp->tx_full = 1;
lp838drivers/net/lance.cstruct lance_private *lp;
lp848drivers/net/lance.clp = (struct lance_private *)dev->priv;
lp870drivers/net/lance.cint dirty_tx = lp->dirty_tx;
lp872drivers/net/lance.cwhile (dirty_tx < lp->cur_tx) {
lp874drivers/net/lance.cint status = lp->tx_ring[entry].base;
lp879drivers/net/lance.clp->tx_ring[entry].base = 0;
lp883drivers/net/lance.cint err_status = lp->tx_ring[entry].misc;
lp884drivers/net/lance.clp->stats.tx_errors++;
lp885drivers/net/lance.cif (err_status & 0x0400) lp->stats.tx_aborted_errors++;
lp886drivers/net/lance.cif (err_status & 0x0800) lp->stats.tx_carrier_errors++;
lp887drivers/net/lance.cif (err_status & 0x1000) lp->stats.tx_window_errors++;
lp890drivers/net/lance.clp->stats.tx_fifo_errors++;
lp899drivers/net/lance.clp->stats.collisions++;
lp900drivers/net/lance.clp->stats.tx_packets++;
lp905drivers/net/lance.cif (lp->tx_skbuff[entry]) {
lp906drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
lp907drivers/net/lance.clp->tx_skbuff[entry] = 0;
lp913drivers/net/lance.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp915drivers/net/lance.cdirty_tx, lp->cur_tx, lp->tx_full);
lp920drivers/net/lance.cif (lp->tx_full && dev->tbusy
lp921drivers/net/lance.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp923drivers/net/lance.clp->tx_full = 0;
lp928drivers/net/lance.clp->dirty_tx = dirty_tx;
lp932drivers/net/lance.cif (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
lp933drivers/net/lance.cif (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
lp965drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp966drivers/net/lance.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
lp970drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
lp971drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
lp979drivers/net/lance.clp->stats.rx_errors++; /* end of a packet.*/
lp980drivers/net/lance.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp981drivers/net/lance.cif (status & 0x10) lp->stats.rx_over_errors++;
lp982drivers/net/lance.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp983drivers/net/lance.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp984drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
lp987drivers/net/lance.cshort pkt_len = (lp->rx_ring[entry].msg_length & 0xfff)-4;
lp994drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
lp998drivers/net/lance.clp->stats.rx_dropped++;
lp999drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp1000drivers/net/lance.clp->cur_rx++;
lp1008drivers/net/lance.c(unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
lp1012drivers/net/lance.clp->stats.rx_packets++;
lp1017drivers/net/lance.clp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
lp1018drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
lp1019drivers/net/lance.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
lp1032drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp1037drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
lp1039drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp1064drivers/net/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
lp1069drivers/net/lance.cif (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
lp1074drivers/net/lance.clp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
lp1079drivers/net/lance.creturn &lp->stats;
lp157drivers/net/pi2.cstatic void rts(struct pi_local *lp, int x);
lp158drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp);
lp159drivers/net/pi2.cstatic void b_txint(struct pi_local *lp);
lp160drivers/net/pi2.cstatic void b_exint(struct pi_local *lp);
lp161drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp);
lp162drivers/net/pi2.cstatic void a_txint(struct pi_local *lp);
lp163drivers/net/pi2.cstatic void a_exint(struct pi_local *lp);
lp201drivers/net/pi2.cstatic void switchbuffers(struct pi_local *lp)
lp203drivers/net/pi2.cif (lp->rcvbuf == lp->rxdmabuf1)
lp204drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf2;
lp206drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf1;
lp209drivers/net/pi2.cstatic void hardware_send_packet(struct pi_local *lp, struct sk_buff *skb)
lp214drivers/net/pi2.clp->stats.tx_packets++;
lp218drivers/net/pi2.ckickflag = (skb_peek(&lp->sndq) == NULL) && (lp->sndbuf == NULL);
lp221drivers/net/pi2.cskb_queue_tail(&lp->sndq, skb);
lp224drivers/net/pi2.cswitch (lp->base & 2) {
lp226drivers/net/pi2.ca_txint(lp);  /* process interrupt */
lp231drivers/net/pi2.cif (lp->tstate == IDLE)
lp232drivers/net/pi2.cb_txint(lp);
lp239drivers/net/pi2.cstatic void setup_rx_dma(struct pi_local *lp)
lp249drivers/net/pi2.cdma_abs = (unsigned long) (lp->rcvbuf->data);
lp250drivers/net/pi2.cdmachan = lp->dmachan;
lp251drivers/net/pi2.ccmd = lp->base + CTL;
lp257drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | WT_RDY_RT | INT_ERR_Rx | EXT_INT_ENAB);
lp267drivers/net/pi2.cset_dma_count(dmachan, lp->bufsiz);
lp273drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Rx_CRC);
lp276drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1,
lp282drivers/net/pi2.cstatic void setup_tx_dma(struct pi_local *lp, int length)
lp291drivers/net/pi2.cdmachan = lp->dmachan;
lp292drivers/net/pi2.cdma_abs = (unsigned long) (lp->txdmabuf);
lp310drivers/net/pi2.cstatic void tdelay(struct pi_local *lp, int time)
lp316drivers/net/pi2.cif (lp->base & 2) {    /* If A channel */
lp319drivers/net/pi2.cport = lp->cardbase + TMR1;
lp323drivers/net/pi2.cport = lp->cardbase + TMR2;
lp324drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R1, INT_ALL_Rx | EXT_INT_ENAB);
lp328drivers/net/pi2.coutb_p(sc | LSB_MSB | MODE0, lp->cardbase + TMRCMD);
lp335drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R15, CTSIE);
lp336drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_EXT_INT);
lp344drivers/net/pi2.cstatic void a_txint(struct pi_local *lp)
lp352drivers/net/pi2.ccmd = CTL + lp->base;
lp354drivers/net/pi2.cswitch (lp->tstate) {
lp357drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp358drivers/net/pi2.crts(lp, OFF);
lp368drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp369drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp370drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp371drivers/net/pi2.clp->tstate = DEFER;
lp372drivers/net/pi2.ctdelay(lp, 100);
lp374drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp378drivers/net/pi2.cif (random() > lp->persist) {
lp379drivers/net/pi2.clp->tstate = DEFER;
lp380drivers/net/pi2.ctdelay(lp, lp->slotime);
lp385drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp386drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp387drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp388drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp398drivers/net/pi2.cstatic void a_exint(struct pi_local *lp)
lp408drivers/net/pi2.cst = rdscc(lp->cardbase, lp->base + CTL, R0);  /* Fetch status */
lp411drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R0, RES_EXT_INT);
lp412drivers/net/pi2.ccmd = lp->base + CTL;
lp414drivers/net/pi2.cif ((lp->rstate >= ACTIVE) && (st & BRK_ABRT)) {
lp415drivers/net/pi2.csetup_rx_dma(lp);
lp416drivers/net/pi2.clp->rstate = ACTIVE;
lp418drivers/net/pi2.cswitch (lp->tstate) {
lp420drivers/net/pi2.cfree_p(lp->sndbuf);
lp421drivers/net/pi2.clp->sndbuf = NULL;
lp422drivers/net/pi2.clp->tstate = FLAGOUT;
lp423drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp426drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp428drivers/net/pi2.clp->tstate = IDLE;
lp429drivers/net/pi2.crts(lp, OFF);
lp436drivers/net/pi2.cdisable_dma(lp->dmachan);
lp439drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp444drivers/net/pi2.clength = lp->sndbuf->len - 1;
lp445drivers/net/pi2.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
lp449drivers/net/pi2.csetup_tx_dma(lp, length);
lp453drivers/net/pi2.cenable_dma(lp->dmachan);
lp456drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC | RES_Tx_P);
lp459drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);
lp462drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_RDY_ENAB | WT_FN_RDYFN | EXT_INT_ENAB);
lp465drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);
lp469drivers/net/pi2.clp->tstate = ACTIVE;
lp475drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp476drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp477drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp478drivers/net/pi2.clp->tstate = DEFER;
lp479drivers/net/pi2.ctdelay(lp, 100);
lp481drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R15, CTSIE | DCDIE);
lp485drivers/net/pi2.cif (random() > lp->persist) {
lp486drivers/net/pi2.clp->tstate = DEFER;
lp487drivers/net/pi2.ctdelay(lp, lp->slotime);
lp492drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | Tx8);
lp493drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp494drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp495drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp505drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp)
lp518drivers/net/pi2.ccmd = lp->base + CTL;
lp520drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* Get special condition bits from R1 */
lp522drivers/net/pi2.clp->rstate = RXERROR;
lp527drivers/net/pi2.cclear_dma_ff(lp->dmachan);
lp528drivers/net/pi2.cbytecount = lp->bufsiz - get_dma_residue(lp->dmachan);
lp530drivers/net/pi2.cif ((rse & CRC_ERR) || (lp->rstate > ACTIVE) || (bytecount < 10)) {
lp532drivers/net/pi2.clp->stats.rx_crc_errors++;
lp534drivers/net/pi2.cif (lp->rstate == RXERROR) {
lp535drivers/net/pi2.clp->stats.rx_errors++;
lp536drivers/net/pi2.clp->stats.rx_over_errors++;
lp539drivers/net/pi2.clp->rstate = ACTIVE;
lp540drivers/net/pi2.csetup_rx_dma(lp);
lp544drivers/net/pi2.cpkt_len = lp->rcvbuf->cnt = bytecount - 2 + 1;
lp547drivers/net/pi2.ccur_buf = lp->rcvbuf;
lp548drivers/net/pi2.cswitchbuffers(lp);
lp549drivers/net/pi2.csetup_rx_dma(lp);
lp558drivers/net/pi2.clp->stats.rx_dropped++;
lp574drivers/net/pi2.clp->stats.rx_packets++;
lp577drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, ERR_RES);  /* error reset */
lp581drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp)
lp593drivers/net/pi2.ccmd = CTL + lp->base;
lp595drivers/net/pi2.crse = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
lp597drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0)) & Rx_CH_AV) {
lp604drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp605drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp607drivers/net/pi2.clp->rstate = RXERROR;  /* set error flag */
lp608drivers/net/pi2.clp->stats.rx_errors++;
lp609drivers/net/pi2.clp->stats.rx_over_errors++;
lp610drivers/net/pi2.c} else if (lp->rcvbuf->cnt >= lp->bufsiz) {
lp613drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp614drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp615drivers/net/pi2.clp->rstate = TOOBIG;/* when set, chars are not stored */
lp618drivers/net/pi2.cif (lp->rstate == ACTIVE) {  /* If no errors... */
lp619drivers/net/pi2.c*lp->rcp++ = rdscc(lp->cardbase, cmd, R8);  /* char to rcv buff */
lp620drivers/net/pi2.clp->rcvbuf->cnt++;  /* bump count */
lp623drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp624drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
lp625drivers/net/pi2.clp->rstate = ACTIVE;
lp630drivers/net/pi2.cif (lp->rcvbuf->cnt > 0) {
lp631drivers/net/pi2.cif ((rse & CRC_ERR) || (lp->rstate > ACTIVE) || (lp->rcvbuf->cnt < 10)) {
lp632drivers/net/pi2.cif ((lp->rcvbuf->cnt >= 10) && (rse & CRC_ERR)) {
lp633drivers/net/pi2.clp->stats.rx_crc_errors++;
lp635drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp636drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp639drivers/net/pi2.cpkt_len = lp->rcvbuf->cnt -= 2;  /* Toss 2 crc bytes */
lp647drivers/net/pi2.clp->stats.rx_dropped++;
lp657drivers/net/pi2.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
lp661drivers/net/pi2.clp->stats.rx_packets++;
lp663drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp664drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp668drivers/net/pi2.clp->rstate = ACTIVE;  /* and clear error status */
lp674drivers/net/pi2.cstatic void b_txint(struct pi_local *lp)
lp682drivers/net/pi2.ccmd = CTL + lp->base;
lp684drivers/net/pi2.cswitch (lp->tstate) {
lp686drivers/net/pi2.clp->tstate = FLAGOUT;
lp687drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp692drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp696drivers/net/pi2.crts(lp, OFF);
lp701drivers/net/pi2.clp->txptr = lp->sndbuf->data;
lp702drivers/net/pi2.clp->txptr++;    /* Ignore KISS control byte */
lp703drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
lp708drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp709drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp710drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp711drivers/net/pi2.clp->tstate = DEFER;
lp712drivers/net/pi2.ctdelay(lp, 100);
lp714drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp718drivers/net/pi2.cif (random() > lp->persist) {
lp719drivers/net/pi2.clp->tstate = DEFER;
lp720drivers/net/pi2.ctdelay(lp, lp->slotime);
lp724drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp725drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp726drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp732drivers/net/pi2.cif (lp->txcnt--) {
lp733drivers/net/pi2.cc = *lp->txptr++;
lp735drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp739drivers/net/pi2.cfree_p(lp->sndbuf);
lp740drivers/net/pi2.clp->sndbuf = NULL;
lp741drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & 0x40)) {
lp744drivers/net/pi2.clp->stats.tx_errors++;
lp745drivers/net/pi2.clp->stats.tx_fifo_errors++;
lp746drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp747drivers/net/pi2.clp->tstate = FLAGOUT;
lp748drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp752drivers/net/pi2.clp->tstate = UNDERRUN;  /* Now we expect to underrun */
lp754drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp755drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
lp757drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
lp759drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_P);  /* reset Tx Int Pend */
lp774drivers/net/pi2.cstatic void b_exint(struct pi_local *lp)
lp781drivers/net/pi2.ccmd = CTL + lp->base;
lp784drivers/net/pi2.cst = rdscc(lp->cardbase, cmd, R0);  /* Fetch status */
lp786drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp789drivers/net/pi2.cswitch (lp->tstate) {
lp791drivers/net/pi2.cfree_p(lp->sndbuf);
lp792drivers/net/pi2.clp->sndbuf = NULL;
lp793drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, SEND_ABORT);
lp794drivers/net/pi2.clp->tstate = FLAGOUT;
lp795drivers/net/pi2.clp->stats.tx_errors++;
lp796drivers/net/pi2.clp->stats.tx_fifo_errors++;
lp797drivers/net/pi2.ctdelay(lp, lp->squeldelay);
lp801drivers/net/pi2.clp->tstate = CRCOUT;
lp806drivers/net/pi2.cif ((lp->sndbuf = skb_dequeue(&lp->sndq)) == NULL) {
lp810drivers/net/pi2.crts(lp, OFF);
lp811drivers/net/pi2.clp->tstate = IDLE;
lp815drivers/net/pi2.clp->txptr = lp->sndbuf->data;
lp816drivers/net/pi2.clp->txptr++;    /* Ignore KISS control byte */
lp817drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
lp819drivers/net/pi2.clp->txcnt--;
lp820drivers/net/pi2.cc = *lp->txptr++;
lp821drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
lp824drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp825drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
lp827drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
lp830drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
lp831drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
lp835drivers/net/pi2.cif (lp->txcnt) {
lp836drivers/net/pi2.clp->txcnt--;
lp837drivers/net/pi2.cc = *lp->txptr++;
lp839drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
lp841drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp847drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
lp848drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp849drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);  /* Tx/Ext ints */
lp851drivers/net/pi2.clp->tstate = ACTIVE;  /* char going out now */
lp859drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp860drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp861drivers/net/pi2.cif ((rdscc(lp->cardbase, cmd, R0) & DCD) != 0) {
lp862drivers/net/pi2.clp->tstate = DEFER;
lp863drivers/net/pi2.ctdelay(lp, 100);
lp865drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, CTSIE | DCDIE);
lp869drivers/net/pi2.cif (random() > lp->persist) {
lp870drivers/net/pi2.clp->tstate = DEFER;
lp871drivers/net/pi2.ctdelay(lp, lp->slotime);
lp875drivers/net/pi2.crts(lp, ON);    /* Transmitter on */
lp876drivers/net/pi2.clp->tstate = ST_TXDELAY;
lp877drivers/net/pi2.ctdelay(lp, lp->txdelay);
lp884drivers/net/pi2.clp->txcnt--;
lp885drivers/net/pi2.cc = *lp->txptr++;
lp886drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_Tx_CRC);  /* reset for next frame */
lp889drivers/net/pi2.cif (lp->speed) {  /* If internally clocked */
lp890drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI | ABUNDER);
lp892drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | ABUNDER);
lp895drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);  /* First char out now */
lp896drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EOM_L);  /* Reset end of message latch */
lp900drivers/net/pi2.cif (lp->txcnt) {
lp901drivers/net/pi2.clp->txcnt--;
lp902drivers/net/pi2.cc = *lp->txptr++;
lp904drivers/net/pi2.cwhile((rdscc(lp->cardbase, cmd, R0) & 0x04) == 0)
lp906drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R8, c);
lp912drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, TxUIE);  /* allow Underrun int only */
lp913drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, RES_EXT_INT);
lp915drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, TxINT_ENAB | EXT_INT_ENAB);
lp917drivers/net/pi2.clp->tstate = ACTIVE;  /* char going out now */
lp927drivers/net/pi2.cif ((lp->rstate == ACTIVE) && (st & BRK_ABRT)) {
lp928drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp929drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp930drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp931drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp932drivers/net/pi2.clp->rcvbuf->cnt = 0;  /* rewind on DCD transition */
lp998drivers/net/pi2.cstatic void rts(struct pi_local *lp, int x)
lp1006drivers/net/pi2.ccmd = CTL + lp->base;
lp1011drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
lp1012drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Rx off */
lp1013drivers/net/pi2.clp->rstate = IDLE;
lp1016drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, WT_FN_RDYFN | EXT_INT_ENAB);
lp1018drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);  /* No interrupts */
lp1021drivers/net/pi2.cif (!lp->clockmode) {
lp1022drivers/net/pi2.cif (lp->speed) {  /* if internally clocked */
lp1023drivers/net/pi2.cbr = lp->speed;  /* get desired speed */
lp1024drivers/net/pi2.ctc = (lp->xtal / br) - 2;  /* calc 1X BRG divisor */
lp1025drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1026drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1029drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, TxCRC_ENAB | RTS | TxENAB | Tx8 | DTR);
lp1032drivers/net/pi2.clp->tstate = IDLE;
lp1033drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);  /*  TX off */
lp1035drivers/net/pi2.cif (!lp->clockmode) {
lp1036drivers/net/pi2.cif (lp->speed) {  /* if internally clocked */
lp1039drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);
lp1040drivers/net/pi2.cbr = lp->speed;  /* get desired speed */
lp1042drivers/net/pi2.ctc = ((lp->xtal / 32) / br) - 2;
lp1043drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1044drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1046drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);
lp1048drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);
lp1052drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* Make sure rx is off */
lp1053drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R0, ERR_RES);  /* reset err latch */
lp1054drivers/net/pi2.cdummy = rdscc(lp->cardbase, cmd, R1);  /* get status byte from R1 */
lp1055drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1056drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1058drivers/net/pi2.c(void) rdscc(lp->cardbase, cmd, R8);
lp1061drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | Rx8);
lp1062drivers/net/pi2.clp->rstate = ACTIVE;  /* Normal state */
lp1065drivers/net/pi2.csetup_rx_dma(lp);
lp1068drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp1069drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp1070drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
lp1072drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* allow ABORT int */
lp1093drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1101drivers/net/pi2.ccmd = CTL + lp->base;
lp1107drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRA);  /* Reset channel A */
lp1108drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R2, 0xff);  /* Initialize interrupt vector */
lp1111drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R9, CHRB);  /* Reset channel B */
lp1116drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, 0);
lp1119drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, 0);
lp1122drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R4, SDLC | X1CLK);
lp1125drivers/net/pi2.cif (lp->speed) {    /* Use internal clocking */
lp1126drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS | NRZI);
lp1127drivers/net/pi2.cif (!lp->clockmode)
lp1129drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCBR | RCDPLL | TRxCDP | TRxCOI);
lp1132drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCDPLL | RCDPLL | TRxCBR | TRxCOI);
lp1134drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R10, CRCPS);
lp1136drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R11, TCTRxCP);
lp1140drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R6, 0);
lp1143drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R7, FLAG);
lp1148drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R5, Tx8 | DTR);
lp1151drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, Rx8);  /* 8 bits/char */
lp1154drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC);  /* BRG off, keep Pclk source */
lp1158drivers/net/pi2.cif (lp->speed) {
lp1159drivers/net/pi2.cbr = lp->speed;    /* get desired speed */
lp1160drivers/net/pi2.ctc = ((lp->xtal / 32) / br) - 2;  /* calc 32X BRG divisor */
lp1165drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R12, tc & 0xFF);  /* lower byte */
lp1166drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R13, (tc >> 8) & 0xFF);  /* upper byte */
lp1169drivers/net/pi2.crts(lp, OFF);    /* TX OFF and RX ON */
lp1171drivers/net/pi2.cif (lp->speed) {
lp1173drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSBR);
lp1176drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SSRTxC);
lp1178drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | SEARCH);  /* SEARCH mode, keep BRG src */
lp1179drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R14, BRSRC | BRENABL);  /* Enable the BRG */
lp1182drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R1, (INT_ALL_Rx | EXT_INT_ENAB));
lp1184drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R15, BRKIE);  /* ABORT int */
lp1187drivers/net/pi2.cwrtscc(lp->cardbase, cmd, R3, RxENABLE | RxCRC_ENAB | Rx8);
lp1307drivers/net/pi2.cstruct pi_local *lp;
lp1318drivers/net/pi2.clp = (struct pi_local *) dev->priv;
lp1324drivers/net/pi2.clp->txdmabuf = get_dma_buffer(&mem_ptr);
lp1325drivers/net/pi2.clp->rxdmabuf1 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp1326drivers/net/pi2.clp->rxdmabuf2 = (struct mbuf *) get_dma_buffer(&mem_ptr);
lp1329drivers/net/pi2.clp->rcvbuf = lp->rxdmabuf1;
lp1330drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
lp1331drivers/net/pi2.clp->rcvbuf->cnt = 0;
lp1334drivers/net/pi2.cskb_queue_head_init(&lp->sndq);
lp1338drivers/net/pi2.clp->xtal = (unsigned long) SINGLE / 2;
lp1340drivers/net/pi2.clp->xtal = (unsigned long) DOUBLE / 2;
lp1341drivers/net/pi2.clp->base = dev->base_addr;
lp1342drivers/net/pi2.clp->cardbase = dev->base_addr & 0x3f0;
lp1344drivers/net/pi2.clp->speed = DEF_A_SPEED;
lp1346drivers/net/pi2.clp->txdelay = DEF_A_TXDELAY;
lp1347drivers/net/pi2.clp->persist = DEF_A_PERSIST;
lp1348drivers/net/pi2.clp->slotime = DEF_A_SLOTIME;
lp1349drivers/net/pi2.clp->squeldelay = DEF_A_SQUELDELAY;
lp1350drivers/net/pi2.clp->clockmode = DEF_A_CLOCKMODE;
lp1353drivers/net/pi2.clp->speed = DEF_B_SPEED;
lp1355drivers/net/pi2.clp->txdelay = DEF_B_TXDELAY;
lp1356drivers/net/pi2.clp->persist = DEF_B_PERSIST;
lp1357drivers/net/pi2.clp->slotime = DEF_B_SLOTIME;
lp1358drivers/net/pi2.clp->squeldelay = DEF_B_SQUELDELAY;
lp1359drivers/net/pi2.clp->clockmode = DEF_B_CLOCKMODE;
lp1361drivers/net/pi2.clp->bufsiz = DMA_BUFF_SIZE;
lp1362drivers/net/pi2.clp->tstate = IDLE;
lp1369drivers/net/pi2.clp->dmachan = dev->dma;
lp1370drivers/net/pi2.cif (lp->dmachan < 1 || lp->dmachan > 3)
lp1371drivers/net/pi2.cprintk("PI: DMA channel %d out of range\n", lp->dmachan);
lp1379drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R1, EXT_INT_ENAB);
lp1381drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
lp1384drivers/net/pi2.ctdelay(lp, 1);
lp1392drivers/net/pi2.cwrtscc(lp->cardbase, dev->base_addr + CTL, R9, FHWRES);  /* Hardware reset */
lp1394drivers/net/pi2.cwrtscc(lp->cardbase, dev->base_addr + CTL, R9, 0);
lp1463drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1476drivers/net/pi2.clp->tstate = IDLE;
lp1485drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
lp1488drivers/net/pi2.clp->open_time = jiffies;
lp1499drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1508drivers/net/pi2.chardware_send_packet(lp, skb);
lp1519drivers/net/pi2.cstruct pi_local *lp;
lp1534drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;  /* Assume channel A */
lp1535drivers/net/pi2.cwhile ((st = rdscc(lp->cardbase, pi0a.base_addr | CHANA | CTL, R3)) != 0) {
lp1538drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1539drivers/net/pi2.cb_txint(lp);
lp1542drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1543drivers/net/pi2.ca_rxint(&pi0a, lp);
lp1546drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1547drivers/net/pi2.ca_txint(lp);
lp1550drivers/net/pi2.clp = (struct pi_local *) pi0a.priv;
lp1551drivers/net/pi2.ca_exint(lp);
lp1554drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1555drivers/net/pi2.cb_rxint(&pi0b, lp);
lp1558drivers/net/pi2.clp = (struct pi_local *) pi0b.priv;
lp1559drivers/net/pi2.cb_exint(lp);
lp1564drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_H_IUS);
lp1574drivers/net/pi2.cstruct pi_local *lp;
lp1580drivers/net/pi2.clp = (struct pi_local *) dev->priv;
lp1584drivers/net/pi2.cdisable_dma(lp->dmachan);
lp1586drivers/net/pi2.clp->open_time = 0;
lp1592drivers/net/pi2.cwhile ((ptr = skb_dequeue(&lp->sndq)) != NULL)
lp1603drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1621drivers/net/pi2.clp->txdelay = rq.txdelay;
lp1622drivers/net/pi2.clp->persist = rq.persist;
lp1623drivers/net/pi2.clp->slotime = rq.slotime;
lp1624drivers/net/pi2.clp->squeldelay = rq.squeldelay;
lp1625drivers/net/pi2.clp->clockmode = rq.clockmode;
lp1626drivers/net/pi2.clp->speed = rq.speed;
lp1643drivers/net/pi2.cfree_dma(lp->dmachan);
lp1644drivers/net/pi2.cdev->dma = lp->dmachan = rq.dmachan;
lp1645drivers/net/pi2.cif (request_dma(lp->dmachan,"pi2")) 
lp1660drivers/net/pi2.crq.speed = lp->speed;
lp1661drivers/net/pi2.crq.txdelay = lp->txdelay;
lp1662drivers/net/pi2.crq.persist = lp->persist;
lp1663drivers/net/pi2.crq.slotime = lp->slotime;
lp1664drivers/net/pi2.crq.squeldelay = lp->squeldelay;
lp1665drivers/net/pi2.crq.clockmode = lp->clockmode;
lp1666drivers/net/pi2.crq.dmachan = lp->dmachan;
lp1683drivers/net/pi2.cstruct pi_local *lp = (struct pi_local *) dev->priv;
lp1685drivers/net/pi2.creturn &lp->stats;
lp353drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp368drivers/net/seeq8005.clp->open_time = jiffies;
lp427drivers/net/seeq8005.cstruct net_local *lp;
lp440drivers/net/seeq8005.clp = (struct net_local *)dev->priv;
lp456drivers/net/seeq8005.clp->stats.tx_packets++;
lp478drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp490drivers/net/seeq8005.coutw( lp->receive_ptr, SEEQ_DMAAR);
lp497drivers/net/seeq8005.cprintk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
lp507drivers/net/seeq8005.cif (next_packet < lp->receive_ptr) {
lp508drivers/net/seeq8005.cpkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
lp510drivers/net/seeq8005.cpkt_len = next_packet - lp->receive_ptr - 4;
lp519drivers/net/seeq8005.clp->receive_ptr = next_packet;
lp526drivers/net/seeq8005.clp->stats.rx_errors++;
lp527drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_SHORT) lp->stats.rx_frame_errors++;
lp528drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_DRIB) lp->stats.rx_frame_errors++;
lp529drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_OVERSIZE) lp->stats.rx_over_errors++;
lp530drivers/net/seeq8005.cif (pkt_hdr & SEEQPKTS_CRC_ERR) lp->stats.rx_crc_errors++;
lp533drivers/net/seeq8005.coutw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
lp542drivers/net/seeq8005.clp->stats.rx_dropped++;
lp562drivers/net/seeq8005.clp->stats.rx_packets++;
lp576drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp579drivers/net/seeq8005.clp->open_time = 0;
lp602drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp604drivers/net/seeq8005.creturn &lp->stats;
lp637drivers/net/seeq8005.cstruct net_local *lp = (struct net_local *)dev->priv;
lp660drivers/net/seeq8005.clp->receive_ptr = (DEFAULT_TEA+1)<<8;  /* so we can find our packet_header */
lp661drivers/net/seeq8005.coutw( lp->receive_ptr, SEEQ_RPR);  /* Receive Pointer Register is set to recv buffer memory */
lp280drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp299drivers/net/skeleton.clp->open_time = jiffies;
lp310drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp350drivers/net/skeleton.clp->stats.tx_aborted_errors++;
lp361drivers/net/skeleton.cstruct net_local *lp;
lp371drivers/net/skeleton.clp = (struct net_local *)dev->priv;
lp380drivers/net/skeleton.clp->stats.tx_packets++;
lp386drivers/net/skeleton.clp->stats.tx_window_errors++;
lp398drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp410drivers/net/skeleton.clp->stats.rx_errors++;
lp411drivers/net/skeleton.cif (status & 0x20) lp->stats.rx_frame_errors++;
lp412drivers/net/skeleton.cif (status & 0x10) lp->stats.rx_over_errors++;
lp413drivers/net/skeleton.cif (status & 0x08) lp->stats.rx_crc_errors++;
lp414drivers/net/skeleton.cif (status & 0x04) lp->stats.rx_fifo_errors++;
lp422drivers/net/skeleton.clp->stats.rx_dropped++;
lp434drivers/net/skeleton.clp->stats.rx_packets++;
lp448drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp451drivers/net/skeleton.clp->open_time = 0;
lp479drivers/net/skeleton.cstruct net_local *lp = (struct net_local *)dev->priv;
lp484drivers/net/skeleton.clp->stats.rx_missed_errors = inw(ioaddr+1);
lp487drivers/net/skeleton.creturn &lp->stats;
lp450drivers/net/tulip.cstruct tulip_private *lp;
lp459drivers/net/tulip.clp = (struct tulip_private *)dev->priv;
lp481drivers/net/tulip.cint dirty_tx = lp->dirty_tx;
lp483drivers/net/tulip.cwhile (dirty_tx < lp->cur_tx) {
lp485drivers/net/tulip.cint status = lp->tx_ring[entry].status;
lp492drivers/net/tulip.clp->stats.tx_errors++;
lp493drivers/net/tulip.cif (status & 0x4104) lp->stats.tx_aborted_errors++;
lp494drivers/net/tulip.cif (status & 0x0C00) lp->stats.tx_carrier_errors++;
lp495drivers/net/tulip.cif (status & 0x0200) lp->stats.tx_window_errors++;
lp496drivers/net/tulip.cif (status & 0x0002) lp->stats.tx_fifo_errors++;
lp497drivers/net/tulip.cif (status & 0x0080) lp->stats.tx_heartbeat_errors++;
lp499drivers/net/tulip.cif (status & 0x0100) lp->stats.collisions16++;
lp503drivers/net/tulip.cif (status & 0x0001) lp->stats.tx_deferred++;
lp505drivers/net/tulip.clp->stats.collisions += (status >> 3) & 15;
lp506drivers/net/tulip.clp->stats.tx_packets++;
lp510drivers/net/tulip.cdev_kfree_skb(lp->tx_skbuff[entry], FREE_WRITE);
lp515drivers/net/tulip.cif (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
lp517drivers/net/tulip.cdirty_tx, lp->cur_tx, lp->tx_full);
lp522drivers/net/tulip.cif (lp->tx_full && dev->tbusy
lp523drivers/net/tulip.c&& dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
lp525drivers/net/tulip.clp->tx_full = 0;
lp530drivers/net/tulip.clp->dirty_tx = dirty_tx;
lp535drivers/net/tulip.cif (csr5 & 0x0008) lp->stats.tx_errors++; /* Tx babble. */
lp537drivers/net/tulip.clp->stats.rx_errors++;
lp538drivers/net/tulip.clp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;
lp576drivers/net/tulip.cstruct tulip_private *lp = (struct tulip_private *)dev->priv;
lp577drivers/net/tulip.cint entry = lp->cur_rx % RX_RING_SIZE;
lp583drivers/net/tulip.cwhile (lp->rx_ring[entry].status >= 0) {
lp584drivers/net/tulip.cint status = lp->rx_ring[entry].status;
lp593drivers/net/tulip.clp->stats.rx_errors++; /* end of a packet.*/
lp594drivers/net/tulip.cif (status & 0x0890) lp->stats.rx_length_errors++;
lp595drivers/net/tulip.cif (status & 0x0004) lp->stats.rx_frame_errors++;
lp596drivers/net/tulip.cif (status & 0x0002) lp->stats.rx_crc_errors++;
lp597drivers/net/tulip.cif (status & 0x0001) lp->stats.rx_fifo_errors++;
lp600drivers/net/tulip.cshort pkt_len = lp->rx_ring[entry].status >> 16;
lp609drivers/net/tulip.cif (lp->rx_ring[(entry+i) % RX_RING_SIZE].status < 0)
lp613drivers/net/tulip.clp->stats.rx_dropped++;
lp614drivers/net/tulip.clp->rx_ring[entry].status = 0x80000000;
lp615drivers/net/tulip.clp->cur_rx++;
lp621drivers/net/tulip.cmemcpy(skb_put(skb,pkt_len), lp->rx_ring[entry].buffer1, pkt_len);
lp624drivers/net/tulip.clp->stats.rx_packets++;
lp627drivers/net/tulip.clp->rx_ring[entry].status = 0x80000000;
lp628drivers/net/tulip.centry = (++lp->cur_rx) % RX_RING_SIZE;
lp194drivers/net/wavelan.cnet_local  *lp;
lp198drivers/net/wavelan.clp = (net_local *)dev->priv;
lp202drivers/net/wavelan.clp->hacr &= ~HACR_INTRON;
lp203drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp213drivers/net/wavelan.cnet_local  *lp;
lp217drivers/net/wavelan.clp = (net_local *)dev->priv;
lp221drivers/net/wavelan.clp->hacr |= HACR_INTRON;
lp222drivers/net/wavelan.chacr_write(ioaddr, lp->hacr);
lp384drivers/net/wavelan.cnet_local  *lp;
lp389drivers/net/wavelan.clp = (net_local *)dev->priv;
lp433drivers/net/wavelan.cif (lp->promiscuous && lp->full_promiscuous)
lp450drivers/net/wavelan.cm.mmw_netw_id_l = lp->nwid[1];
lp451drivers/net/wavelan.cm.mmw_netw_id_h = lp->nwid[0];
lp461drivers/net/wavelan.cnet_local  *lp;
lp466drivers/net/wavelan.clp = (net_local *)dev->priv;
lp476drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp500drivers/net/wavelan.cnet_local  *lp;
lp506drivers/net/wavelan.clp = (net_local *)dev->priv;
lp511drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp540drivers/net/wavelan.cnet_local  *lp;
lp553drivers/net/wavelan.clp = (net_local *)dev->priv;
lp555drivers/net/wavelan.clp->nresets++;
lp558drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp572drivers/net/wavelan.cpsa_read(ioaddr, lp->hacr, 0, (unsigned char *)&psa, sizeof(psa));
lp596drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp699drivers/net/wavelan.cAC_CFG_PRM(lp->promiscuous);
lp856drivers/net/wavelan.cnet_local  *lp;
lp1009drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1013drivers/net/wavelan.cfirst_wavelan = lp;
lp1014drivers/net/wavelan.clp->prev = lp;
lp1015drivers/net/wavelan.clp->next = lp;
lp1019drivers/net/wavelan.clp->prev = first_wavelan->prev;
lp1020drivers/net/wavelan.clp->next = first_wavelan;
lp1021drivers/net/wavelan.cfirst_wavelan->prev->next = lp;
lp1022drivers/net/wavelan.cfirst_wavelan->prev = lp;
lp1024drivers/net/wavelan.clp->dev = dev;
lp1026drivers/net/wavelan.clp->hacr = HACR_DEFAULT;
lp1028drivers/net/wavelan.clp->full_promiscuous = enable_full_promiscuous;
lp1029drivers/net/wavelan.clp->nwid[0] = psa.psa_nwid[0];
lp1030drivers/net/wavelan.clp->nwid[1] = psa.psa_nwid[1];
lp1032drivers/net/wavelan.clp->watchdog.function = wavelan_watchdog;
lp1033drivers/net/wavelan.clp->watchdog.data = (unsigned long)dev;
lp1064drivers/net/wavelan.cnet_local  *lp;
lp1073drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1079drivers/net/wavelan.clp->rx_head = OFFSET_RU;
lp1081drivers/net/wavelan.cfor (i = 0, rx = lp->rx_head; i < NRXBLOCKS; i++, rx = rx_next)
lp1083drivers/net/wavelan.crx_next = (i == NRXBLOCKS - 1) ? lp->rx_head : rx + RXBLOCKZ;
lp1098drivers/net/wavelan.clp->rx_last = rx;
lp1101drivers/net/wavelan.cobram_write(ioaddr, scboff(OFFSET_SCB, scb_rfa_offset), (unsigned char *)&lp->rx_head, sizeof(lp->rx_head));
lp1106drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1131drivers/net/wavelan.cnet_local  *lp;
lp1138drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1140drivers/net/wavelan.clp->tx_first_free = OFFSET_CU;
lp1141drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1187drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1201drivers/net/wavelan.clp->tx_n_in_use = 0;
lp1210drivers/net/wavelan.cnet_local  *lp;
lp1218drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1275drivers/net/wavelan.cnet_local  *lp;
lp1288drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1292drivers/net/wavelan.ctxblock = lp->tx_first_free;
lp1296drivers/net/wavelan.clp->tx_first_free += TXBLOCKZ;
lp1297drivers/net/wavelan.cif (lp->tx_first_free >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1298drivers/net/wavelan.clp->tx_first_free -= NTXBLOCKS * TXBLOCKZ;
lp1305drivers/net/wavelan.clp->tx_n_in_use++;
lp1350drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1351drivers/net/wavelan.clp->tx_first_in_use = txblock;
lp1353drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1358drivers/net/wavelan.cif (lp->watchdog.next == (timer_list *)0)
lp1477drivers/net/wavelan.cnet_local  *lp;
lp1481drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1492drivers/net/wavelan.cobram_read(ioaddr, lp->rx_head, (unsigned char *)&fd, sizeof(fd));
lp1519drivers/net/wavelan.clp->stats.rx_errors++;
lp1526drivers/net/wavelan.clp->stats.rx_length_errors++;
lp1532drivers/net/wavelan.clp->stats.rx_over_errors++;
lp1538drivers/net/wavelan.clp->stats.rx_fifo_errors++;
lp1544drivers/net/wavelan.clp->stats.rx_frame_errors++;
lp1550drivers/net/wavelan.clp->stats.rx_crc_errors++;
lp1636drivers/net/wavelan.clp->stats.rx_dropped++;
lp1674drivers/net/wavelan.clp->stats.rx_packets++;
lp1679drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_status), (unsigned char *)&fd.fd_status, sizeof(fd.fd_status));
lp1682drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_head, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1685drivers/net/wavelan.cobram_write(ioaddr, fdoff(lp->rx_last, fd_command), (unsigned char *)&fd.fd_command, sizeof(fd.fd_command));
lp1687drivers/net/wavelan.clp->rx_last = lp->rx_head;
lp1688drivers/net/wavelan.clp->rx_head = fd.fd_link_offset;
lp1703drivers/net/wavelan.cwavelan_complete(device *dev, unsigned short ioaddr, net_local *lp)
lp1713drivers/net/wavelan.cif (lp->tx_first_in_use == I82586NULL)
lp1716drivers/net/wavelan.cobram_read(ioaddr, acoff(lp->tx_first_in_use, ac_status), (unsigned char *)&tx_status, sizeof(tx_status));
lp1723drivers/net/wavelan.c--lp->tx_n_in_use;
lp1730drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1731drivers/net/wavelan.clp->tx_first_in_use = I82586NULL;
lp1734drivers/net/wavelan.clp->tx_first_in_use += TXBLOCKZ;
lp1735drivers/net/wavelan.cif (lp->tx_first_in_use >= OFFSET_CU + NTXBLOCKS * TXBLOCKZ)
lp1736drivers/net/wavelan.clp->tx_first_in_use -= NTXBLOCKS * TXBLOCKZ;
lp1743drivers/net/wavelan.clp->stats.tx_packets++;
lp1745drivers/net/wavelan.clp->stats.collisions += ncollisions;
lp1753drivers/net/wavelan.clp->stats.tx_errors++;
lp1756drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1762drivers/net/wavelan.clp->stats.tx_carrier_errors++;
lp1767drivers/net/wavelan.clp->stats.tx_fifo_errors++;
lp1772drivers/net/wavelan.clp->stats.tx_heartbeat_errors++;
lp1778drivers/net/wavelan.clp->stats.tx_aborted_errors++;
lp1796drivers/net/wavelan.cif (lp->tx_n_in_use < NTXBLOCKS - 1)
lp1810drivers/net/wavelan.cnet_local  *lp;
lp1819drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1821drivers/net/wavelan.cif (lp->tx_n_in_use <= 0)
lp1827drivers/net/wavelan.clp->watchdog.expires = WATCHDOG_JIFFIES;
lp1828drivers/net/wavelan.cadd_timer(&lp->watchdog);
lp1836drivers/net/wavelan.cnreaped = wavelan_complete(dev, ioaddr, lp);
lp1838drivers/net/wavelan.cprintk("%s: warning: wavelan_watchdog(): %d reaped, %d remain.\n", dev->name, nreaped, lp->tx_n_in_use);
lp1856drivers/net/wavelan.cnet_local  *lp;
lp1868drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1902drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp1914drivers/net/wavelan.c(void)wavelan_complete(dev, ioaddr, lp);
lp1959drivers/net/wavelan.cnet_local  *lp;
lp1966drivers/net/wavelan.clp = (net_local *)dev->priv;
lp1976drivers/net/wavelan.cset_chan_attn(ioaddr, lp->hacr);
lp2006drivers/net/wavelan.cnet_local  *lp;
lp2008drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2010drivers/net/wavelan.creturn &lp->stats;
lp2017drivers/net/wavelan.cnet_local  *lp;
lp2023drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2031drivers/net/wavelan.clp->promiscuous = 1;
lp2042drivers/net/wavelan.clp->promiscuous = 0;
lp2068drivers/net/wavelan.cnet_local  *lp;
lp2072drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2074drivers/net/wavelan.cif (lp == (net_local *)0)
lp2092drivers/net/wavelan.clp->correct_nwid += (m.mmr_correct_nwid_h << 8) | m.mmr_correct_nwid_l;
lp2093drivers/net/wavelan.clp->wrong_nwid += (m.mmr_wrong_nwid_h << 8) | m.mmr_wrong_nwid_l;
lp2101drivers/net/wavelan.clp->correct_nwid,
lp2102drivers/net/wavelan.clp->wrong_nwid,
lp2106drivers/net/wavelan.clp->tx_n_in_use,
lp2107drivers/net/wavelan.clp->nresets
lp2133drivers/net/wavelan.cnet_local  *lp;
lp2135drivers/net/wavelan.clp = first_wavelan;
lp2138drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
lp2152drivers/net/wavelan.cwhile ((lp = lp->next) != first_wavelan);
lp2197drivers/net/wavelan.cwavelan_cu_show_one(device *dev, net_local *lp, int i, unsigned short p)
lp2410drivers/net/wavelan.cnet_local  *lp;
lp2412drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2425drivers/net/wavelan.cnet_local  *lp;
lp2429drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2434drivers/net/wavelan.cfor (i = 0, p = lp->tx_first_in_use; i < NTXBLOCKS; i++)
lp2436drivers/net/wavelan.cwavelan_cu_show_one(dev, lp, i, p);
lp2461drivers/net/wavelan.cnet_local  *lp;
lp2463drivers/net/wavelan.clp = (net_local *)dev->priv;
lp2466drivers/net/wavelan.cprintk(" tx_n_in_use=%d,", lp->tx_n_in_use);
lp2467drivers/net/wavelan.cprintk(" hacr=0x%x,", lp->hacr);
lp2468drivers/net/wavelan.cprintk(" rx_head=0x%x,", lp->rx_head);
lp2469drivers/net/wavelan.cprintk(" rx_last=0x%x,", lp->rx_last);
lp2470drivers/net/wavelan.cprintk(" tx_first_free=0x%x,", lp->tx_first_free);
lp2471drivers/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;
lp21drivers/scsi/eata_dma_proc.cu32 *lp, h_lp;
lp25drivers/scsi/eata_dma_proc.clp = (u32 *)p;
lp26drivers/scsi/eata_dma_proc.csp = ((short *)lp) + 1;      /* Convert Header */
lp28drivers/scsi/eata_dma_proc.clp++;
lp31drivers/scsi/eata_dma_proc.csp = (u16 *)lp;      /* Convert SubHeader */
lp33drivers/scsi/eata_dma_proc.cbp = (u8 *) lp;
lp35drivers/scsi/eata_dma_proc.clp++;
lp36drivers/scsi/eata_dma_proc.cfor (h_lp = (u32)lp; (u32)lp < h_lp + ((u32)*(bp + 3)); lp++)
lp37drivers/scsi/eata_dma_proc.c*lp = ntohl(*lp);
lp38drivers/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;
lp249fs/xiafs/inode.cdt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
lp255fs/xiafs/inode.cif ((tmp=*lp)) {
lp257fs/xiafs/inode.cif (tmp == *lp)
lp268fs/xiafs/inode.cif (*lp) {
lp273fs/xiafs/inode.c*lp = tmp;
lp283fs/xiafs/inode.cu_long *lp;
lp296fs/xiafs/inode.clp = nr + (u_long *) bh->b_data;
lp298fs/xiafs/inode.cif ((tmp=*lp)) {
lp300fs/xiafs/inode.cif (tmp == *lp) {
lp317fs/xiafs/inode.cif (*lp) {
lp322fs/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;
lp167net/ipv4/protocol.cstruct inet_protocol *lp = NULL;
lp188net/ipv4/protocol.cif (p->copy == 0 && lp != NULL) lp->copy = 0;
lp194net/ipv4/protocol.clp = p;