staging: et131x: Converting et1310_adapter.h variable names from CamelCase
authorMark Einon <mark.einon@gmail.com>
Tue, 23 Aug 2011 22:40:35 +0000 (23:40 +0100)
committerGreg Kroah-Hartman <gregkh@suse.de>
Tue, 23 Aug 2011 23:25:27 +0000 (16:25 -0700)
Tested on an ET-131x device.

Signed-off-by: Mark Einon <mark.einon@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/staging/et131x/et1310_mac.c
drivers/staging/et131x/et1310_phy.c
drivers/staging/et131x/et1310_pm.c
drivers/staging/et131x/et1310_rx.c
drivers/staging/et131x/et1310_tx.c
drivers/staging/et131x/et131x_adapter.h
drivers/staging/et131x/et131x_initpci.c
drivers/staging/et131x/et131x_isr.c
drivers/staging/et131x/et131x_netdev.c

index d1847c1614b4a0731e3db52d6ed392f9714e06cd..8e124fe5b9d1356257c811878fbf310e83c5d676 100644 (file)
@@ -149,10 +149,10 @@ void et1310_config_mac_regs1(struct et131x_adapter *etdev)
         * being truncated.  Allow the MAC to pass 4 more than our max packet
         * size.  This is 4 for the Ethernet CRC.
         *
-        * Packets larger than (RegistryJumboPacket) that do not contain a
+        * Packets larger than (registry_jumbo_packet) that do not contain a
         * VLAN ID will be dropped by the Rx function.
         */
-       writel(etdev->RegistryJumboPacket + 4, &macregs->max_fm_len);
+       writel(etdev->registry_jumbo_packet + 4, &macregs->max_fm_len);
 
        /* clear out MAC config reset */
        writel(0, &macregs->cfg1);
@@ -294,7 +294,7 @@ void et1310_config_rxmac_regs(struct et131x_adapter *etdev)
        writel(0, &rxmac->pf_ctrl);
 
        /* Let's initialize the Unicast Packet filtering address */
-       if (etdev->PacketFilter & ET131X_PACKET_TYPE_DIRECTED) {
+       if (etdev->packet_filter & ET131X_PACKET_TYPE_DIRECTED) {
                et1310_setup_device_for_unicast(etdev);
                pf_ctrl |= 4;   /* Unicast filter */
        } else {
@@ -304,7 +304,7 @@ void et1310_config_rxmac_regs(struct et131x_adapter *etdev)
        }
 
        /* Let's initialize the Multicast hash */
-       if (!(etdev->PacketFilter & ET131X_PACKET_TYPE_ALL_MULTICAST)) {
+       if (!(etdev->packet_filter & ET131X_PACKET_TYPE_ALL_MULTICAST)) {
                pf_ctrl |= 2;   /* Multicast filter */
                et1310_setup_device_for_multicast(etdev);
        }
@@ -313,7 +313,7 @@ void et1310_config_rxmac_regs(struct et131x_adapter *etdev)
        pf_ctrl |= (NIC_MIN_PACKET_SIZE + 4) << 16;
        pf_ctrl |= 8;   /* Fragment filter */
 
-       if (etdev->RegistryJumboPacket > 8192)
+       if (etdev->registry_jumbo_packet > 8192)
                /* In order to transmit jumbo packets greater than 8k, the
                 * FIFO between RxMAC and RxDMA needs to be reduced in size
                 * to (16k - Jumbo packet size).  In order to implement this,
@@ -489,22 +489,22 @@ void et1310_update_macstat_host_counters(struct et131x_adapter *etdev)
        struct macstat_regs __iomem *macstat =
                &etdev->regs->macstat;
 
-       stats->collisions           += readl(&macstat->tx_total_collisions);
-       stats->first_collision      += readl(&macstat->tx_single_collisions);
-       stats->tx_deferred          += readl(&macstat->tx_deferred);
-       stats->excessive_collisions += readl(&macstat->tx_multiple_collisions);
-       stats->late_collisions      += readl(&macstat->tx_late_collisions);
-       stats->tx_uflo              += readl(&macstat->tx_undersize_frames);
-       stats->max_pkt_error        += readl(&macstat->tx_oversize_frames);
-
-       stats->alignment_err        += readl(&macstat->rx_align_errs);
-       stats->crc_err              += readl(&macstat->rx_code_errs);
-       stats->norcvbuf             += readl(&macstat->rx_drops);
-       stats->rx_ov_flow           += readl(&macstat->rx_oversize_packets);
-       stats->code_violations      += readl(&macstat->rx_fcs_errs);
-       stats->length_err           += readl(&macstat->rx_frame_len_errs);
-
-       stats->other_errors         += readl(&macstat->rx_fragment_packets);
+       stats->tx_collisions           += readl(&macstat->tx_total_collisions);
+       stats->tx_first_collisions     += readl(&macstat->tx_single_collisions);
+       stats->tx_deferred             += readl(&macstat->tx_deferred);
+       stats->tx_excessive_collisions +=
+                               readl(&macstat->tx_multiple_collisions);
+       stats->tx_late_collisions      += readl(&macstat->tx_late_collisions);
+       stats->tx_underflows           += readl(&macstat->tx_undersize_frames);
+       stats->tx_max_pkt_errs         += readl(&macstat->tx_oversize_frames);
+
+       stats->rx_align_errs        += readl(&macstat->rx_align_errs);
+       stats->rx_crc_errs          += readl(&macstat->rx_code_errs);
+       stats->rcvd_pkts_dropped    += readl(&macstat->rx_drops);
+       stats->rx_overflows         += readl(&macstat->rx_oversize_packets);
+       stats->rx_code_violations   += readl(&macstat->rx_fcs_errs);
+       stats->rx_length_errs       += readl(&macstat->rx_frame_len_errs);
+       stats->rx_other_errs        += readl(&macstat->rx_fragment_packets);
 }
 
 /**
@@ -536,33 +536,33 @@ void et1310_handle_macstat_interrupt(struct et131x_adapter *etdev)
         * block indicates that one of the counters has wrapped.
         */
        if (carry_reg1 & (1 << 14))
-               etdev->stats.code_violations      += COUNTER_WRAP_16_BIT;
+               etdev->stats.rx_code_violations += COUNTER_WRAP_16_BIT;
        if (carry_reg1 & (1 << 8))
-               etdev->stats.alignment_err        += COUNTER_WRAP_12_BIT;
+               etdev->stats.rx_align_errs      += COUNTER_WRAP_12_BIT;
        if (carry_reg1 & (1 << 7))
-               etdev->stats.length_err           += COUNTER_WRAP_16_BIT;
+               etdev->stats.rx_length_errs     += COUNTER_WRAP_16_BIT;
        if (carry_reg1 & (1 << 2))
-               etdev->stats.other_errors         += COUNTER_WRAP_16_BIT;
+               etdev->stats.rx_other_errs      += COUNTER_WRAP_16_BIT;
        if (carry_reg1 & (1 << 6))
-               etdev->stats.crc_err              += COUNTER_WRAP_16_BIT;
+               etdev->stats.rx_crc_errs        += COUNTER_WRAP_16_BIT;
        if (carry_reg1 & (1 << 3))
-               etdev->stats.rx_ov_flow           += COUNTER_WRAP_16_BIT;
+               etdev->stats.rx_overflows       += COUNTER_WRAP_16_BIT;
        if (carry_reg1 & (1 << 0))
-               etdev->stats.norcvbuf             += COUNTER_WRAP_16_BIT;
+               etdev->stats.rcvd_pkts_dropped  += COUNTER_WRAP_16_BIT;
        if (carry_reg2 & (1 << 16))
-               etdev->stats.max_pkt_error        += COUNTER_WRAP_12_BIT;
+               etdev->stats.tx_max_pkt_errs    += COUNTER_WRAP_12_BIT;
        if (carry_reg2 & (1 << 15))
-               etdev->stats.tx_uflo              += COUNTER_WRAP_12_BIT;
+               etdev->stats.tx_underflows      += COUNTER_WRAP_12_BIT;
        if (carry_reg2 & (1 << 6))
-               etdev->stats.first_collision      += COUNTER_WRAP_12_BIT;
+               etdev->stats.tx_first_collisions += COUNTER_WRAP_12_BIT;
        if (carry_reg2 & (1 << 8))
-               etdev->stats.tx_deferred          += COUNTER_WRAP_12_BIT;
+               etdev->stats.tx_deferred        += COUNTER_WRAP_12_BIT;
        if (carry_reg2 & (1 << 5))
-               etdev->stats.excessive_collisions += COUNTER_WRAP_12_BIT;
+               etdev->stats.tx_excessive_collisions += COUNTER_WRAP_12_BIT;
        if (carry_reg2 & (1 << 4))
-               etdev->stats.late_collisions      += COUNTER_WRAP_12_BIT;
+               etdev->stats.tx_late_collisions += COUNTER_WRAP_12_BIT;
        if (carry_reg2 & (1 << 2))
-               etdev->stats.collisions           += COUNTER_WRAP_12_BIT;
+               etdev->stats.tx_collisions      += COUNTER_WRAP_12_BIT;
 }
 
 void et1310_setup_device_for_multicast(struct et131x_adapter *etdev)
@@ -581,10 +581,11 @@ void et1310_setup_device_for_multicast(struct et131x_adapter *etdev)
         * specified) then we should pass NO multi-cast addresses to the
         * driver.
         */
-       if (etdev->PacketFilter & ET131X_PACKET_TYPE_MULTICAST) {
+       if (etdev->packet_filter & ET131X_PACKET_TYPE_MULTICAST) {
                /* Loop through our multicast array and set up the device */
-               for (nIndex = 0; nIndex < etdev->MCAddressCount; nIndex++) {
-                       result = ether_crc(6, etdev->MCList[nIndex]);
+               for (nIndex = 0; nIndex < etdev->multicast_addr_count;
+                    nIndex++) {
+                       result = ether_crc(6, etdev->multicast_list[nIndex]);
 
                        result = (result & 0x3F800000) >> 23;
 
index 36534260fae1d4f2c377203b363190f4f5e1e5fa..9d2ce08d9ae757508c0efeb2c87847fa89e44b74 100644 (file)
@@ -596,7 +596,7 @@ static void et131x_xcvr_init(struct et131x_adapter *etdev)
        }
 
        /* Determine if we need to go into a force mode and set it */
-       if (etdev->AiForceSpeed == 0 && etdev->AiForceDpx == 0) {
+       if (etdev->ai_force_speed == 0 && etdev->ai_force_duplex == 0) {
                if (etdev->wanted_flow == FLOW_TXONLY ||
                    etdev->wanted_flow == FLOW_BOTH)
                        et1310_phy_access_mii_bit(etdev,
@@ -623,7 +623,7 @@ static void et131x_xcvr_init(struct et131x_adapter *etdev)
        et1310_phy_auto_neg(etdev, false);
 
        /* Set to the correct force mode. */
-       if (etdev->AiForceDpx != 1) {
+       if (etdev->ai_force_duplex != 1) {
                if (etdev->wanted_flow == FLOW_TXONLY ||
                    etdev->wanted_flow == FLOW_BOTH)
                        et1310_phy_access_mii_bit(etdev,
@@ -645,16 +645,16 @@ static void et131x_xcvr_init(struct et131x_adapter *etdev)
                                          4, 11, NULL);
        }
        et1310_phy_power_down(etdev, 1);
-       switch (etdev->AiForceSpeed) {
+       switch (etdev->ai_force_speed) {
        case 10:
                /* First we need to turn off all other advertisement */
                et1310_phy_advertise_1000BaseT(etdev, TRUEPHY_ADV_DUPLEX_NONE);
                et1310_phy_advertise_100BaseT(etdev, TRUEPHY_ADV_DUPLEX_NONE);
-               if (etdev->AiForceDpx == 1) {
+               if (etdev->ai_force_duplex == 1) {
                        /* Set our advertise values accordingly */
                        et1310_phy_advertise_10BaseT(etdev,
                                                TRUEPHY_ADV_DUPLEX_HALF);
-               } else if (etdev->AiForceDpx == 2) {
+               } else if (etdev->ai_force_duplex == 2) {
                        /* Set our advertise values accordingly */
                        et1310_phy_advertise_10BaseT(etdev,
                                                TRUEPHY_ADV_DUPLEX_FULL);
@@ -674,13 +674,13 @@ static void et131x_xcvr_init(struct et131x_adapter *etdev)
                /* first we need to turn off all other advertisement */
                et1310_phy_advertise_1000BaseT(etdev, TRUEPHY_ADV_DUPLEX_NONE);
                et1310_phy_advertise_10BaseT(etdev, TRUEPHY_ADV_DUPLEX_NONE);
-               if (etdev->AiForceDpx == 1) {
+               if (etdev->ai_force_duplex == 1) {
                        /* Set our advertise values accordingly */
                        et1310_phy_advertise_100BaseT(etdev,
                                                TRUEPHY_ADV_DUPLEX_HALF);
                        /* Set speed */
                        et1310_phy_speed_select(etdev, TRUEPHY_SPEED_100MBPS);
-               } else if (etdev->AiForceDpx == 2) {
+               } else if (etdev->ai_force_duplex == 2) {
                        /* Set our advertise values accordingly */
                        et1310_phy_advertise_100BaseT(etdev,
                                                TRUEPHY_ADV_DUPLEX_FULL);
@@ -741,11 +741,11 @@ void et131x_mii_check(struct et131x_adapter *etdev,
                        /* Update our state variables and indicate the
                         * connected state
                         */
-                       spin_lock_irqsave(&etdev->Lock, flags);
+                       spin_lock_irqsave(&etdev->lock, flags);
 
-                       etdev->MediaState = NETIF_STATUS_MEDIA_CONNECT;
+                       etdev->media_state = NETIF_STATUS_MEDIA_CONNECT;
 
-                       spin_unlock_irqrestore(&etdev->Lock, flags);
+                       spin_unlock_irqrestore(&etdev->lock, flags);
 
                        netif_carrier_on(etdev->netdev);
                } else {
@@ -774,11 +774,11 @@ void et131x_mii_check(struct et131x_adapter *etdev,
                         * Timer expires, we can report disconnected (handled
                         * in the LinkDetectionDPC).
                         */
-                       if ((etdev->MediaState == NETIF_STATUS_MEDIA_DISCONNECT)) {
-                               spin_lock_irqsave(&etdev->Lock, flags);
-                               etdev->MediaState =
+                       if (etdev->media_state == NETIF_STATUS_MEDIA_DISCONNECT) {
+                               spin_lock_irqsave(&etdev->lock, flags);
+                               etdev->media_state =
                                    NETIF_STATUS_MEDIA_DISCONNECT;
-                               spin_unlock_irqrestore(&etdev->Lock,
+                               spin_unlock_irqrestore(&etdev->lock,
                                                       flags);
 
                                netif_carrier_off(etdev->netdev);
@@ -810,15 +810,15 @@ void et131x_mii_check(struct et131x_adapter *etdev,
                        /* Setup the PHY into coma mode until the cable is
                         * plugged back in
                         */
-                       if (etdev->RegistryPhyComa == 1)
+                       if (etdev->registry_phy_coma == 1)
                                et1310_enable_phy_coma(etdev);
                }
        }
 
        if ((bmsr_ints & MI_BMSR_AUTO_NEG_COMPLETE) ||
-           (etdev->AiForceDpx == 3 && (bmsr_ints & MI_BMSR_LINK_STATUS))) {
+          (etdev->ai_force_duplex == 3 && (bmsr_ints & MI_BMSR_LINK_STATUS))) {
                if ((bmsr & MI_BMSR_AUTO_NEG_COMPLETE) ||
-                   etdev->AiForceDpx == 3) {
+                   etdev->ai_force_duplex == 3) {
                        et1310_phy_link_status(etdev,
                                             &link_status, &autoneg_status,
                                             &speed, &duplex, &mdi_mdix,
@@ -849,7 +849,7 @@ void et131x_mii_check(struct et131x_adapter *etdev,
                        et1310_config_flow_control(etdev);
 
                        if (etdev->linkspeed == TRUEPHY_SPEED_1000MBPS &&
-                                       etdev->RegistryJumboPacket > 2048)
+                                       etdev->registry_jumbo_packet > 2048)
                                et1310_phy_and_or_reg(etdev, 0x16, 0xcfff,
                                                                   0x2000);
 
index 1bfcc6705017111b099501ee2369b3be1d72a954..914aff65d69ebf6a1f309dd3862ba8d869df145b 100644 (file)
@@ -116,8 +116,8 @@ void et1310_enable_phy_coma(struct et131x_adapter *etdev)
        /* Save the GbE PHY speed and duplex modes. Need to restore this
         * when cable is plugged back in
         */
-       etdev->pdown_speed = etdev->AiForceSpeed;
-       etdev->pdown_duplex = etdev->AiForceDpx;
+       etdev->pdown_speed = etdev->ai_force_speed;
+       etdev->pdown_duplex = etdev->ai_force_duplex;
 
        /* Stop sending packets. */
        spin_lock_irqsave(&etdev->send_hw_lock, flags);
@@ -153,8 +153,8 @@ void et1310_disable_phy_coma(struct et131x_adapter *etdev)
        /* Restore the GbE PHY speed and duplex modes;
         * Reset JAGCore; re-configure and initialize JAGCore and gigE PHY
         */
-       etdev->AiForceSpeed = etdev->pdown_speed;
-       etdev->AiForceDpx = etdev->pdown_duplex;
+       etdev->ai_force_speed = etdev->pdown_speed;
+       etdev->ai_force_duplex = etdev->pdown_duplex;
 
        /* Re-initialize the send structures */
        et131x_init_send(etdev);
index 694bb0284775881d51d1675fe849a5ff6112baec..09243092cb7ec6987372093dafdeb29589ff4b9b 100644 (file)
@@ -149,14 +149,14 @@ int et131x_rx_dma_memory_alloc(struct et131x_adapter *adapter)
         * the number of entries halves.  FBR0 increases in size, however.
         */
 
-       if (adapter->RegistryJumboPacket < 2048) {
+       if (adapter->registry_jumbo_packet < 2048) {
 #ifdef USE_FBR0
                rx_ring->fbr0_buffsize = 256;
                rx_ring->fbr0_num_entries = 512;
 #endif
                rx_ring->fbr1_buffsize = 2048;
                rx_ring->fbr1_num_entries = 512;
-       } else if (adapter->RegistryJumboPacket < 4096) {
+       } else if (adapter->registry_jumbo_packet < 4096) {
 #ifdef USE_FBR0
                rx_ring->fbr0_buffsize = 512;
                rx_ring->fbr0_num_entries = 1024;
@@ -755,7 +755,7 @@ static void nic_return_rfd(struct et131x_adapter *etdev, struct rfd *rfd)
            (ring_index == 0 && buff_index < rx_local->fbr0_num_entries) ||
 #endif
            (ring_index == 1 && buff_index < rx_local->fbr1_num_entries)) {
-               spin_lock_irqsave(&etdev->FbrLock, flags);
+               spin_lock_irqsave(&etdev->fbr_lock, flags);
 
                if (ring_index == 1) {
                        struct fbr_desc *next =
@@ -793,7 +793,7 @@ static void nic_return_rfd(struct et131x_adapter *etdev, struct rfd *rfd)
                               &rx_dma->fbr0_full_offset);
                }
 #endif
-               spin_unlock_irqrestore(&etdev->FbrLock, flags);
+               spin_unlock_irqrestore(&etdev->fbr_lock, flags);
        } else {
                dev_err(&etdev->pdev->dev,
                          "%s illegal Buffer Index returned\n", __func__);
@@ -983,18 +983,18 @@ static struct rfd *nic_rx_pkts(struct et131x_adapter *etdev)
         * also counted here.
         */
        if (len < (NIC_MIN_PACKET_SIZE + 4)) {
-               etdev->stats.other_errors++;
+               etdev->stats.rx_other_errs++;
                len = 0;
        }
 
        if (len) {
-               if (etdev->ReplicaPhyLoopbk == 1) {
+               if (etdev->replica_phy_loopbk == 1) {
                        buf = rx_local->fbr[ring_index]->virt[buff_index];
 
                        if (memcmp(&buf[6], etdev->addr, ETH_ALEN) == 0) {
                                if (memcmp(&buf[42], "Replica packet",
                                           ETH_HLEN)) {
-                                       etdev->ReplicaPhyLoopbkPF = 1;
+                                       etdev->replica_phy_loopbk_passfail = 1;
                                }
                        }
                }
@@ -1009,9 +1009,12 @@ static struct rfd *nic_rx_pkts(struct et131x_adapter *etdev)
                         * filters. Generally filter is 0x2b when in
                         * promiscuous mode.
                         */
-                       if ((etdev->PacketFilter & ET131X_PACKET_TYPE_MULTICAST)
-                           && !(etdev->PacketFilter & ET131X_PACKET_TYPE_PROMISCUOUS)
-                           && !(etdev->PacketFilter & ET131X_PACKET_TYPE_ALL_MULTICAST)) {
+                       if ((etdev->packet_filter &
+                                       ET131X_PACKET_TYPE_MULTICAST)
+                           && !(etdev->packet_filter &
+                                       ET131X_PACKET_TYPE_PROMISCUOUS)
+                           && !(etdev->packet_filter &
+                                       ET131X_PACKET_TYPE_ALL_MULTICAST)) {
                                buf = rx_local->fbr[ring_index]->
                                                virt[buff_index];
 
@@ -1019,13 +1022,20 @@ static struct rfd *nic_rx_pkts(struct et131x_adapter *etdev)
                                 * destination address of this packet
                                 * matches one in our list.
                                 */
-                               for (i = 0; i < etdev->MCAddressCount; i++) {
-                                       if (buf[0] == etdev->MCList[i][0]
-                                           && buf[1] == etdev->MCList[i][1]
-                                           && buf[2] == etdev->MCList[i][2]
-                                           && buf[3] == etdev->MCList[i][3]
-                                           && buf[4] == etdev->MCList[i][4]
-                                           && buf[5] == etdev->MCList[i][5]) {
+                               for (i = 0; i < etdev->multicast_addr_count;
+                                    i++) {
+                                       if (buf[0] ==
+                                               etdev->multicast_list[i][0]
+                                           && buf[1] ==
+                                               etdev->multicast_list[i][1]
+                                           && buf[2] ==
+                                               etdev->multicast_list[i][2]
+                                           && buf[3] ==
+                                               etdev->multicast_list[i][3]
+                                           && buf[4] ==
+                                               etdev->multicast_list[i][4]
+                                           && buf[5] ==
+                                               etdev->multicast_list[i][5]) {
                                                break;
                                        }
                                }
@@ -1038,21 +1048,21 @@ static struct rfd *nic_rx_pkts(struct et131x_adapter *etdev)
                                 * so we free our RFD when we return
                                 * from this function.
                                 */
-                               if (i == etdev->MCAddressCount)
+                               if (i == etdev->multicast_addr_count)
                                        len = 0;
                        }
 
                        if (len > 0)
-                               etdev->stats.multircv++;
+                               etdev->stats.multicast_pkts_rcvd++;
                } else if (word0 & ALCATEL_BROADCAST_PKT)
-                       etdev->stats.brdcstrcv++;
+                       etdev->stats.broadcast_pkts_rcvd++;
                else
                        /* Not sure what this counter measures in
                         * promiscuous mode. Perhaps we should check
                         * the MAC address to see if it is directed
                         * to us in promiscuous mode.
                         */
-                       etdev->stats.unircv++;
+                       etdev->stats.unicast_pkts_rcvd++;
        }
 
        if (len > 0) {
@@ -1128,7 +1138,7 @@ void et131x_handle_recv_interrupt(struct et131x_adapter *etdev)
                 * If length is zero, return the RFD in order to advance the
                 * Free buffer ring.
                 */
-               if (!etdev->PacketFilter ||
+               if (!etdev->packet_filter ||
                    !netif_carrier_ok(etdev->netdev) ||
                    rfd->len == 0)
                        continue;
index da9b4af5cec35e6f8632212bfc29ff245181107d..eb8552b251da32a9769f34667b3de93c6acaeb1b 100644 (file)
@@ -456,7 +456,7 @@ static int nic_send_packet(struct et131x_adapter *etdev, struct tcb *tcb)
        } else
                tcb->index = etdev->tx_ring.send_idx - 1;
 
-       spin_lock(&etdev->TCBSendQLock);
+       spin_lock(&etdev->tcb_send_qlock);
 
        if (etdev->tx_ring.send_tail)
                etdev->tx_ring.send_tail->next = tcb;
@@ -469,7 +469,7 @@ static int nic_send_packet(struct et131x_adapter *etdev, struct tcb *tcb)
 
        etdev->tx_ring.used++;
 
-       spin_unlock(&etdev->TCBSendQLock);
+       spin_unlock(&etdev->tcb_send_qlock);
 
        /* Write the new write pointer back to the device. */
        writel(etdev->tx_ring.send_idx,
@@ -508,12 +508,12 @@ static int send_packet(struct sk_buff *skb, struct et131x_adapter *etdev)
                return -EIO;
 
        /* Get a TCB for this packet */
-       spin_lock_irqsave(&etdev->TCBReadyQLock, flags);
+       spin_lock_irqsave(&etdev->tcb_ready_qlock, flags);
 
        tcb = etdev->tx_ring.tcb_qhead;
 
        if (tcb == NULL) {
-               spin_unlock_irqrestore(&etdev->TCBReadyQLock, flags);
+               spin_unlock_irqrestore(&etdev->tcb_ready_qlock, flags);
                return -ENOMEM;
        }
 
@@ -522,7 +522,7 @@ static int send_packet(struct sk_buff *skb, struct et131x_adapter *etdev)
        if (etdev->tx_ring.tcb_qhead == NULL)
                etdev->tx_ring.tcb_qtail = NULL;
 
-       spin_unlock_irqrestore(&etdev->TCBReadyQLock, flags);
+       spin_unlock_irqrestore(&etdev->tcb_ready_qlock, flags);
 
        tcb->skb = skb;
 
@@ -543,7 +543,7 @@ static int send_packet(struct sk_buff *skb, struct et131x_adapter *etdev)
        status = nic_send_packet(etdev, tcb);
 
        if (status != 0) {
-               spin_lock_irqsave(&etdev->TCBReadyQLock, flags);
+               spin_lock_irqsave(&etdev->tcb_ready_qlock, flags);
 
                if (etdev->tx_ring.tcb_qtail)
                        etdev->tx_ring.tcb_qtail->next = tcb;
@@ -552,7 +552,7 @@ static int send_packet(struct sk_buff *skb, struct et131x_adapter *etdev)
                        etdev->tx_ring.tcb_qhead = tcb;
 
                etdev->tx_ring.tcb_qtail = tcb;
-               spin_unlock_irqrestore(&etdev->TCBReadyQLock, flags);
+               spin_unlock_irqrestore(&etdev->tcb_ready_qlock, flags);
                return status;
        }
        WARN_ON(etdev->tx_ring.used > NUM_TCB);
@@ -627,11 +627,11 @@ static inline void free_send_packet(struct et131x_adapter *etdev,
        struct net_device_stats *stats = &etdev->net_stats;
 
        if (tcb->flags & fMP_DEST_BROAD)
-               atomic_inc(&etdev->stats.brdcstxmt);
+               atomic_inc(&etdev->stats.broadcast_pkts_xmtd);
        else if (tcb->flags & fMP_DEST_MULTI)
-               atomic_inc(&etdev->stats.multixmt);
+               atomic_inc(&etdev->stats.multicast_pkts_xmtd);
        else
-               atomic_inc(&etdev->stats.unixmt);
+               atomic_inc(&etdev->stats.unicast_pkts_xmtd);
 
        if (tcb->skb) {
                stats->tx_bytes += tcb->skb->len;
@@ -663,7 +663,7 @@ static inline void free_send_packet(struct et131x_adapter *etdev,
        memset(tcb, 0, sizeof(struct tcb));
 
        /* Add the TCB to the Ready Q */
-       spin_lock_irqsave(&etdev->TCBReadyQLock, flags);
+       spin_lock_irqsave(&etdev->tcb_ready_qlock, flags);
 
        etdev->net_stats.tx_packets++;
 
@@ -675,7 +675,7 @@ static inline void free_send_packet(struct et131x_adapter *etdev,
 
        etdev->tx_ring.tcb_qtail = tcb;
 
-       spin_unlock_irqrestore(&etdev->TCBReadyQLock, flags);
+       spin_unlock_irqrestore(&etdev->tcb_ready_qlock, flags);
        WARN_ON(etdev->tx_ring.used < 0);
 }
 
@@ -692,7 +692,7 @@ void et131x_free_busy_send_packets(struct et131x_adapter *etdev)
        u32 freed = 0;
 
        /* Any packets being sent? Check the first TCB on the send list */
-       spin_lock_irqsave(&etdev->TCBSendQLock, flags);
+       spin_lock_irqsave(&etdev->tcb_send_qlock, flags);
 
        tcb = etdev->tx_ring.send_head;
 
@@ -706,19 +706,19 @@ void et131x_free_busy_send_packets(struct et131x_adapter *etdev)
 
                etdev->tx_ring.used--;
 
-               spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
+               spin_unlock_irqrestore(&etdev->tcb_send_qlock, flags);
 
                freed++;
                free_send_packet(etdev, tcb);
 
-               spin_lock_irqsave(&etdev->TCBSendQLock, flags);
+               spin_lock_irqsave(&etdev->tcb_send_qlock, flags);
 
                tcb = etdev->tx_ring.send_head;
        }
 
        WARN_ON(freed == NUM_TCB);
 
-       spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
+       spin_unlock_irqrestore(&etdev->tcb_send_qlock, flags);
 
        etdev->tx_ring.used = 0;
 }
@@ -745,7 +745,7 @@ void et131x_handle_send_interrupt(struct et131x_adapter *etdev)
        /* Has the ring wrapped?  Process any descriptors that do not have
         * the same "wrap" indicator as the current completion indicator
         */
-       spin_lock_irqsave(&etdev->TCBSendQLock, flags);
+       spin_lock_irqsave(&etdev->tcb_send_qlock, flags);
 
        tcb = etdev->tx_ring.send_head;
 
@@ -757,9 +757,9 @@ void et131x_handle_send_interrupt(struct et131x_adapter *etdev)
                if (tcb->next == NULL)
                        etdev->tx_ring.send_tail = NULL;
 
-               spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
+               spin_unlock_irqrestore(&etdev->tcb_send_qlock, flags);
                free_send_packet(etdev, tcb);
-               spin_lock_irqsave(&etdev->TCBSendQLock, flags);
+               spin_lock_irqsave(&etdev->tcb_send_qlock, flags);
 
                /* Goto the next packet */
                tcb = etdev->tx_ring.send_head;
@@ -772,9 +772,9 @@ void et131x_handle_send_interrupt(struct et131x_adapter *etdev)
                if (tcb->next == NULL)
                        etdev->tx_ring.send_tail = NULL;
 
-               spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
+               spin_unlock_irqrestore(&etdev->tcb_send_qlock, flags);
                free_send_packet(etdev, tcb);
-               spin_lock_irqsave(&etdev->TCBSendQLock, flags);
+               spin_lock_irqsave(&etdev->tcb_send_qlock, flags);
 
                /* Goto the next packet */
                tcb = etdev->tx_ring.send_head;
@@ -784,6 +784,6 @@ void et131x_handle_send_interrupt(struct et131x_adapter *etdev)
        if (etdev->tx_ring.used <= NUM_TCB / 3)
                netif_wake_queue(etdev->netdev);
 
-       spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
+       spin_unlock_irqrestore(&etdev->tcb_send_qlock, flags);
 }
 
index 408c50ba4f2bdeb4cbb13c07569efc1d9a330930..5dfa1534959839487b521d9ddc79af627c6b752d 100644 (file)
@@ -105,40 +105,39 @@ struct ce_stats {
         * MUST have 32, then we'll need another way to perform atomic
         * operations
         */
-       u32 unircv;     /* # multicast packets received */
-       atomic_t unixmt;        /* # multicast packets for Tx */
-       u32 multircv;   /* # multicast packets received */
-       atomic_t multixmt;      /* # multicast packets for Tx */
-       u32 brdcstrcv;  /* # broadcast packets received */
-       atomic_t brdcstxmt;     /* # broadcast packets for Tx */
-       u32 norcvbuf;   /* # Rx packets discarded */
-       u32 noxmtbuf;   /* # Tx packets discarded */
+       u32             unicast_pkts_rcvd;
+       atomic_t        unicast_pkts_xmtd;
+       u32             multicast_pkts_rcvd;
+       atomic_t        multicast_pkts_xmtd;
+       u32             broadcast_pkts_rcvd;
+       atomic_t        broadcast_pkts_xmtd;
+       u32             rcvd_pkts_dropped;
 
        /* Transceiver state informations. */
-       u8 xcvr_addr;
-       u32 xcvr_id;
+       u8              xcvr_addr;
+       u32             xcvr_id;
 
        /* Tx Statistics. */
-       u32 tx_uflo;            /* Tx Underruns */
+       u32             tx_underflows;
 
-       u32 collisions;
-       u32 excessive_collisions;
-       u32 first_collision;
-       u32 late_collisions;
-       u32 max_pkt_error;
-       u32 tx_deferred;
+       u32             tx_collisions;
+       u32             tx_excessive_collisions;
+       u32             tx_first_collisions;
+       u32             tx_late_collisions;
+       u32             tx_max_pkt_errs;
+       u32             tx_deferred;
 
        /* Rx Statistics. */
-       u32 rx_ov_flow; /* Rx Overflow */
+       u32             rx_overflows;
 
-       u32 length_err;
-       u32 alignment_err;
-       u32 crc_err;
-       u32 code_violations;
-       u32 other_errors;
+       u32             rx_length_errs;
+       u32             rx_align_errs;
+       u32             rx_crc_errs;
+       u32             rx_code_violations;
+       u32             rx_other_errs;
 
-       u32 SynchrounousIterations;
-       u32 InterruptStatus;
+       u32             synchronous_iterations;
+       u32             interrupt_status;
 };
 
 
@@ -151,7 +150,7 @@ struct et131x_adapter {
 
        /* Flags that indicate current state of the adapter */
        u32 flags;
-       u32 HwErrCount;
+       u32 hw_errs;
 
        /* Configuration  */
        u8 rom_addr[ETH_ALEN];
@@ -160,52 +159,52 @@ struct et131x_adapter {
        u8 eeprom_data[2];
 
        /* Spinlocks */
-       spinlock_t Lock;
+       spinlock_t lock;
 
-       spinlock_t TCBSendQLock;
-       spinlock_t TCBReadyQLock;
+       spinlock_t tcb_send_qlock;
+       spinlock_t tcb_ready_qlock;
        spinlock_t send_hw_lock;
 
        spinlock_t rcv_lock;
-       spinlock_t RcvPendLock;
-       spinlock_t FbrLock;
+       spinlock_t rcv_pend_lock;
+       spinlock_t fbr_lock;
 
-       spinlock_t PHYLock;
+       spinlock_t phy_lock;
 
        /* Packet Filter and look ahead size */
-       u32 PacketFilter;
+       u32 packet_filter;
        u32 linkspeed;
        u32 duplex_mode;
 
        /* multicast list */
-       u32 MCAddressCount;
-       u8 MCList[NIC_MAX_MCAST_LIST][ETH_ALEN];
+       u32 multicast_addr_count;
+       u8 multicast_list[NIC_MAX_MCAST_LIST][ETH_ALEN];
 
        /* Pointer to the device's PCI register space */
        struct address_map __iomem *regs;
 
        /* Registry parameters */
-       u8 SpeedDuplex;         /* speed/duplex */
+       u8 speed_duplex;        /* speed/duplex */
        u8 wanted_flow;         /* Flow we want for 802.3x flow control */
-       u8 RegistryPhyComa;     /* Phy Coma mode enable/disable */
+       u8 registry_phy_coma;   /* Phy Coma mode enable/disable */
 
-       u32 RegistryRxMemEnd;   /* Size of internal rx memory */
-       u32 RegistryJumboPacket;        /* Max supported ethernet packet size */
+       u32 registry_rx_mem_end;        /* Size of internal rx memory */
+       u32 registry_jumbo_packet;      /* Max supported ethernet packet size */
 
 
        /* Derived from the registry: */
-       u8 AiForceDpx;          /* duplex setting */
-       u16 AiForceSpeed;       /* 'Speed', user over-ride of line speed */
+       u8 ai_force_duplex;     /* duplex setting */
+       u16 ai_force_speed;     /* 'Speed', user over-ride of line speed */
        u8 flowcontrol;         /* flow control validated by the far-end */
        enum {
                NETIF_STATUS_INVALID = 0,
                NETIF_STATUS_MEDIA_CONNECT,
                NETIF_STATUS_MEDIA_DISCONNECT,
                NETIF_STATUS_MAX
-       } MediaState;
+       } media_state;
 
        /* Minimize init-time */
-       struct timer_list ErrorTimer;
+       struct timer_list error_timer;
 
        /* variable putting the phy into coma mode when boot up with no cable
         * plugged in after 5 seconds
@@ -219,7 +218,7 @@ struct et131x_adapter {
        u16 pdown_speed;
        u8 pdown_duplex;
 
-       u32 CachedMaskValue;
+       u32 cached_mask_value;
 
        /* Xcvr status at last poll */
        u16 bmsr;
@@ -231,8 +230,8 @@ struct et131x_adapter {
        struct rx_ring rx_ring;
 
        /* Loopback specifics */
-       u8 ReplicaPhyLoopbk;    /* Replica Enable */
-       u8 ReplicaPhyLoopbkPF;  /* Replica Enable Pass/Fail */
+       u8 replica_phy_loopbk;          /* Replica Enable */
+       u8 replica_phy_loopbk_passfail; /* Replica Enable Pass/Fail */
 
        /* Stats */
        struct ce_stats stats;
index c217a05fa6d013fef791c940a3a4cc743301980f..32a20ddaac52f713327f05262c97a412214be20e 100644 (file)
@@ -275,14 +275,14 @@ void et131x_error_timer_handler(unsigned long data)
                    "No interrupts, in PHY coma, pm_csr = 0x%x\n", pm_csr);
 
        if (!(etdev->bmsr & MI_BMSR_LINK_STATUS) &&
-           etdev->RegistryPhyComa &&
+           etdev->registry_phy_coma &&
            etdev->boot_coma < 11) {
                etdev->boot_coma++;
        }
 
        if (etdev->boot_coma == 10) {
                if (!(etdev->bmsr & MI_BMSR_LINK_STATUS)
-                   && etdev->RegistryPhyComa) {
+                   && etdev->registry_phy_coma) {
                        if ((pm_csr & ET_PM_PHY_SW_COMA) == 0) {
                                /* NOTE - This was originally a 'sync with
                                 *  interrupt'. How to do that under Linux?
@@ -294,7 +294,7 @@ void et131x_error_timer_handler(unsigned long data)
        }
 
        /* This is a periodic timer, so reschedule */
-       mod_timer(&etdev->ErrorTimer, jiffies +
+       mod_timer(&etdev->error_timer, jiffies +
                                          TX_ERROR_PERIOD * HZ / 1000);
 }
 
@@ -308,12 +308,12 @@ void et131x_link_detection_handler(unsigned long data)
        struct et131x_adapter *etdev = (struct et131x_adapter *) data;
        unsigned long flags;
 
-       if (etdev->MediaState == 0) {
-               spin_lock_irqsave(&etdev->Lock, flags);
+       if (etdev->media_state == 0) {
+               spin_lock_irqsave(&etdev->lock, flags);
 
-               etdev->MediaState = NETIF_STATUS_MEDIA_DISCONNECT;
+               etdev->media_state = NETIF_STATUS_MEDIA_DISCONNECT;
 
-               spin_unlock_irqrestore(&etdev->Lock, flags);
+               spin_unlock_irqrestore(&etdev->lock, flags);
 
                netif_carrier_off(etdev->netdev);
        }
@@ -332,7 +332,7 @@ void et131x_configure_global_regs(struct et131x_adapter *etdev)
        writel(0, &regs->rxq_start_addr);
        writel(INTERNAL_MEM_SIZE - 1, &regs->txq_end_addr);
 
-       if (etdev->RegistryJumboPacket < 2048) {
+       if (etdev->registry_jumbo_packet < 2048) {
                /* Tx / RxDMA and Tx/Rx MAC interfaces have a 1k word
                 * block of RAM that the driver can split between Tx
                 * and Rx as it desires.  Our default is to split it
@@ -340,7 +340,7 @@ void et131x_configure_global_regs(struct et131x_adapter *etdev)
                 */
                writel(PARM_RX_MEM_END_DEF, &regs->rxq_end_addr);
                writel(PARM_RX_MEM_END_DEF + 1, &regs->txq_start_addr);
-       } else if (etdev->RegistryJumboPacket < 8192) {
+       } else if (etdev->registry_jumbo_packet < 8192) {
                /* For jumbo packets > 2k but < 8k, split 50-50. */
                writel(INTERNAL_MEM_RX_OFFSET, &regs->rxq_end_addr);
                writel(INTERNAL_MEM_RX_OFFSET + 1, &regs->txq_start_addr);
@@ -547,27 +547,27 @@ static struct et131x_adapter *et131x_adapter_init(struct net_device *netdev,
        netdev->base_addr = pci_resource_start(pdev, 0);
 
        /* Initialize spinlocks here */
-       spin_lock_init(&etdev->Lock);
-       spin_lock_init(&etdev->TCBSendQLock);
-       spin_lock_init(&etdev->TCBReadyQLock);
+       spin_lock_init(&etdev->lock);
+       spin_lock_init(&etdev->tcb_send_qlock);
+       spin_lock_init(&etdev->tcb_ready_qlock);
        spin_lock_init(&etdev->send_hw_lock);
        spin_lock_init(&etdev->rcv_lock);
-       spin_lock_init(&etdev->RcvPendLock);
-       spin_lock_init(&etdev->FbrLock);
-       spin_lock_init(&etdev->PHYLock);
+       spin_lock_init(&etdev->rcv_pend_lock);
+       spin_lock_init(&etdev->fbr_lock);
+       spin_lock_init(&etdev->phy_lock);
 
        /* Parse configuration parameters into the private adapter struct */
        if (et131x_speed_set)
                dev_info(&etdev->pdev->dev,
                        "Speed set manually to : %d\n", et131x_speed_set);
 
-       etdev->SpeedDuplex = et131x_speed_set;
-       etdev->RegistryJumboPacket = 1514;      /* 1514-9216 */
+       etdev->speed_duplex = et131x_speed_set;
+       etdev->registry_jumbo_packet = 1514;    /* 1514-9216 */
 
        /* Set the MAC address to a default */
        memcpy(etdev->addr, default_mac, ETH_ALEN);
 
-       /* Decode SpeedDuplex
+       /* Decode speed_duplex
         *
         * Set up as if we are auto negotiating always and then change if we
         * go into force mode
@@ -576,11 +576,11 @@ static struct et131x_adapter *et131x_adapter_init(struct net_device *netdev,
         * knock it down to 100 full.
         */
        if (etdev->pdev->device == ET131X_PCI_DEVICE_ID_FAST &&
-           etdev->SpeedDuplex == 5)
-               etdev->SpeedDuplex = 4;
+           etdev->speed_duplex == 5)
+               etdev->speed_duplex = 4;
 
-       etdev->AiForceSpeed = speed[etdev->SpeedDuplex];
-       etdev->AiForceDpx = duplex[etdev->SpeedDuplex]; /* Auto FDX */
+       etdev->ai_force_speed = speed[etdev->speed_duplex];
+       etdev->ai_force_duplex = duplex[etdev->speed_duplex];   /* Auto FDX */
 
        return etdev;
 }
@@ -711,11 +711,11 @@ static int __devinit et131x_pci_setup(struct pci_dev *pdev,
        et131x_adapter_setup(adapter);
 
        /* Create a timer to count errors received by the NIC */
-       init_timer(&adapter->ErrorTimer);
+       init_timer(&adapter->error_timer);
 
-       adapter->ErrorTimer.expires = jiffies + TX_ERROR_PERIOD * HZ / 1000;
-       adapter->ErrorTimer.function = et131x_error_timer_handler;
-       adapter->ErrorTimer.data = (unsigned long)adapter;
+       adapter->error_timer.expires = jiffies + TX_ERROR_PERIOD * HZ / 1000;
+       adapter->error_timer.function = et131x_error_timer_handler;
+       adapter->error_timer.data = (unsigned long)adapter;
 
        /* Initialize link state */
        et131x_link_detection_handler((unsigned long)adapter);
index 9b316bed07425b08a7c3e71ea4e1191ea795bb61..1584ab217616ad8c70e81b06007851c98d1477aa 100644 (file)
@@ -124,7 +124,7 @@ void et131x_enable_interrupts(struct et131x_adapter *adapter)
        else
                mask = INT_MASK_ENABLE_NO_FLOW;
 
-       adapter->CachedMaskValue = mask;
+       adapter->cached_mask_value = mask;
        writel(mask, &adapter->regs->global.int_mask);
 }
 
@@ -138,7 +138,7 @@ void et131x_enable_interrupts(struct et131x_adapter *adapter)
 void et131x_disable_interrupts(struct et131x_adapter *adapter)
 {
        /* Disable all global interrupts */
-       adapter->CachedMaskValue = INT_MASK_DISABLE;
+       adapter->cached_mask_value = INT_MASK_DISABLE;
        writel(INT_MASK_DISABLE, &adapter->regs->global.int_mask);
 }
 
@@ -222,7 +222,7 @@ irqreturn_t et131x_isr(int irq, void *dev_id)
         * DPC. We will clear the software copy of that in that
         * routine.
         */
-       adapter->stats.InterruptStatus = status;
+       adapter->stats.interrupt_status = status;
 
        /* Schedule the ISR handler as a bottom-half task in the
         * kernel's tq_immediate queue, and mark the queue for
@@ -244,7 +244,7 @@ void et131x_isr_handler(struct work_struct *work)
 {
        struct et131x_adapter *etdev =
                container_of(work, struct et131x_adapter, task);
-       u32 status = etdev->stats.InterruptStatus;
+       u32 status = etdev->stats.interrupt_status;
        struct address_map __iomem *iomem = etdev->regs;
 
        /*
@@ -389,7 +389,7 @@ void et131x_isr_handler(struct work_struct *work)
                                        (uint8_t) offsetof(struct mi_regs, isr),
                                        &myisr);
 
-                       if (!etdev->ReplicaPhyLoopbk) {
+                       if (!etdev->replica_phy_loopbk) {
                                et131x_mii_read(etdev,
                                       (uint8_t) offsetof(struct mi_regs, bmsr),
                                       &bmsr_data);
index 6eef4be69e26e61cc1bb91bae1a0fd8cb894b5f9..5fe3ec4f8693e395edeb1f4ae9c33e4cab198af9 100644 (file)
@@ -100,15 +100,18 @@ static struct net_device_stats *et131x_stats(struct net_device *netdev)
        struct net_device_stats *stats = &adapter->net_stats;
        struct ce_stats *devstat = &adapter->stats;
 
-       stats->rx_errors = devstat->length_err + devstat->alignment_err +
-           devstat->crc_err + devstat->code_violations + devstat->other_errors;
-       stats->tx_errors = devstat->max_pkt_error;
-       stats->multicast = devstat->multircv;
-       stats->collisions = devstat->collisions;
-
-       stats->rx_length_errors = devstat->length_err;
-       stats->rx_over_errors = devstat->rx_ov_flow;
-       stats->rx_crc_errors = devstat->crc_err;
+       stats->rx_errors = devstat->rx_length_errs +
+                          devstat->rx_align_errs +
+                          devstat->rx_crc_errs +
+                          devstat->rx_code_violations +
+                          devstat->rx_other_errs;
+       stats->tx_errors = devstat->tx_max_pkt_errs;
+       stats->multicast = devstat->multicast_pkts_rcvd;
+       stats->collisions = devstat->tx_collisions;
+
+       stats->rx_length_errors = devstat->rx_length_errs;
+       stats->rx_over_errors = devstat->rx_overflows;
+       stats->rx_crc_errors = devstat->rx_crc_errs;
 
        /* NOTE: These stats don't have corresponding values in CE_STATS,
         * so we're going to have to update these directly from within the
@@ -144,7 +147,7 @@ int et131x_open(struct net_device *netdev)
        struct et131x_adapter *adapter = netdev_priv(netdev);
 
        /* Start the timer to track NIC errors */
-       add_timer(&adapter->ErrorTimer);
+       add_timer(&adapter->error_timer);
 
        /* Register our IRQ */
        result = request_irq(netdev->irq, et131x_isr, IRQF_SHARED,
@@ -194,7 +197,7 @@ int et131x_close(struct net_device *netdev)
        free_irq(netdev->irq, netdev);
 
        /* Stop the error timer */
-       del_timer_sync(&adapter->ErrorTimer);
+       del_timer_sync(&adapter->error_timer);
        return 0;
 }
 
@@ -275,7 +278,7 @@ int et131x_ioctl(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
 int et131x_set_packet_filter(struct et131x_adapter *adapter)
 {
        int status = 0;
-       uint32_t filter = adapter->PacketFilter;
+       uint32_t filter = adapter->packet_filter;
        u32 ctrl;
        u32 pf_ctrl;
 
@@ -337,67 +340,67 @@ int et131x_set_packet_filter(struct et131x_adapter *adapter)
 void et131x_multicast(struct net_device *netdev)
 {
        struct et131x_adapter *adapter = netdev_priv(netdev);
-       uint32_t PacketFilter = 0;
+       uint32_t packet_filter = 0;
        unsigned long flags;
        struct netdev_hw_addr *ha;
        int i;
 
-       spin_lock_irqsave(&adapter->Lock, flags);
+       spin_lock_irqsave(&adapter->lock, flags);
 
        /* Before we modify the platform-independent filter flags, store them
         * locally. This allows us to determine if anything's changed and if
         * we even need to bother the hardware
         */
-       PacketFilter = adapter->PacketFilter;
+       packet_filter = adapter->packet_filter;
 
        /* Clear the 'multicast' flag locally; because we only have a single
         * flag to check multicast, and multiple multicast addresses can be
         * set, this is the easiest way to determine if more than one
         * multicast address is being set.
         */
-       PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
+       packet_filter &= ~ET131X_PACKET_TYPE_MULTICAST;
 
        /* Check the net_device flags and set the device independent flags
         * accordingly
         */
 
        if (netdev->flags & IFF_PROMISC)
-               adapter->PacketFilter |= ET131X_PACKET_TYPE_PROMISCUOUS;
+               adapter->packet_filter |= ET131X_PACKET_TYPE_PROMISCUOUS;
        else
-               adapter->PacketFilter &= ~ET131X_PACKET_TYPE_PROMISCUOUS;
+               adapter->packet_filter &= ~ET131X_PACKET_TYPE_PROMISCUOUS;
 
        if (netdev->flags & IFF_ALLMULTI)
-               adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
+               adapter->packet_filter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 
        if (netdev_mc_count(netdev) > NIC_MAX_MCAST_LIST)
-               adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
+               adapter->packet_filter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 
        if (netdev_mc_count(netdev) < 1) {
-               adapter->PacketFilter &= ~ET131X_PACKET_TYPE_ALL_MULTICAST;
-               adapter->PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
+               adapter->packet_filter &= ~ET131X_PACKET_TYPE_ALL_MULTICAST;
+               adapter->packet_filter &= ~ET131X_PACKET_TYPE_MULTICAST;
        } else
-               adapter->PacketFilter |= ET131X_PACKET_TYPE_MULTICAST;
+               adapter->packet_filter |= ET131X_PACKET_TYPE_MULTICAST;
 
        /* Set values in the private adapter struct */
        i = 0;
        netdev_for_each_mc_addr(ha, netdev) {
                if (i == NIC_MAX_MCAST_LIST)
                        break;
-               memcpy(adapter->MCList[i++], ha->addr, ETH_ALEN);
+               memcpy(adapter->multicast_list[i++], ha->addr, ETH_ALEN);
        }
-       adapter->MCAddressCount = i;
+       adapter->multicast_addr_count = i;
 
        /* Are the new flags different from the previous ones? If not, then no
         * action is required
         *
-        * NOTE - This block will always update the MCList with the hardware,
-        *        even if the addresses aren't the same.
+        * NOTE - This block will always update the multicast_list with the
+        *        hardware, even if the addresses aren't the same.
         */
-       if (PacketFilter != adapter->PacketFilter) {
+       if (packet_filter != adapter->packet_filter) {
                /* Call the device's filter function */
                et131x_set_packet_filter(adapter);
        }
-       spin_unlock_irqrestore(&adapter->Lock, flags);
+       spin_unlock_irqrestore(&adapter->lock, flags);
 }
 
 /**
@@ -459,7 +462,7 @@ void et131x_tx_timeout(struct net_device *netdev)
        }
 
        /* Is send stuck? */
-       spin_lock_irqsave(&etdev->TCBSendQLock, flags);
+       spin_lock_irqsave(&etdev->tcb_send_qlock, flags);
 
        tcb = etdev->tx_ring.send_head;
 
@@ -467,7 +470,7 @@ void et131x_tx_timeout(struct net_device *netdev)
                tcb->count++;
 
                if (tcb->count > NIC_SEND_HANG_THRESHOLD) {
-                       spin_unlock_irqrestore(&etdev->TCBSendQLock,
+                       spin_unlock_irqrestore(&etdev->tcb_send_qlock,
                                               flags);
 
                        dev_warn(&etdev->pdev->dev,
@@ -482,7 +485,7 @@ void et131x_tx_timeout(struct net_device *netdev)
                }
        }
 
-       spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
+       spin_unlock_irqrestore(&etdev->tcb_send_qlock, flags);
 }
 
 /**
@@ -520,7 +523,7 @@ int et131x_change_mtu(struct net_device *netdev, int new_mtu)
        et131x_adapter_memory_free(adapter);
 
        /* Set the config parameter for Jumbo Packet support */
-       adapter->RegistryJumboPacket = new_mtu + 14;
+       adapter->registry_jumbo_packet = new_mtu + 14;
        et131x_soft_reset(adapter);
 
        /* Alloc and init Rx DMA memory */
@@ -601,7 +604,7 @@ int et131x_set_mac_addr(struct net_device *netdev, void *new_mac)
        et131x_adapter_memory_free(adapter);
 
        /* Set the config parameter for Jumbo Packet support */
-       /* adapter->RegistryJumboPacket = new_mtu + 14; */
+       /* adapter->registry_jumbo_packet = new_mtu + 14; */
        /* blux: not needet here, we'll change the MAC */
 
        et131x_soft_reset(adapter);