volatile struct lance_init_block *ib = lp->init_block;
         volatile u16 *mcast_table = (u16 *)&ib->filter;
        struct netdev_hw_addr *ha;
-        char *addrs;
         u32 crc;
 
         /* set all multicast bits */
 
         /* Add addresses */
        netdev_for_each_mc_addr(ha, dev) {
-               addrs = ha->addr;
-
-                /* multicast address? */
-                if (!(*addrs & 1))
-                        continue;
-
-               crc = ether_crc_le(6, addrs);
+               crc = ether_crc_le(6, ha->addr);
                 crc = crc >> 26;
                 mcast_table [crc >> 4] |= 1 << (crc & 0xf);
         }
 
        volatile struct lance_init_block *ib = lp->init_block;
        volatile u16 *mcast_table = (u16 *)&ib->filter;
        struct netdev_hw_addr *ha;
-       char *addrs;
        u32 crc;
 
        /* set all multicast bits */
 
        /* Add addresses */
        netdev_for_each_mc_addr(ha, dev) {
-               addrs = ha->addr;
-
-               /* multicast address? */
-               if (!(*addrs & 1))
-                       continue;
-
-               crc = ether_crc_le(6, addrs);
+               crc = ether_crc_le(6, ha->addr);
                crc = crc >> 26;
                mcast_table[crc >> 4] |= 1 << (crc & 0xf);
        }
 
 static void bmac_set_multicast(struct net_device *dev)
 {
        struct netdev_hw_addr *ha;
-       char *addrs;
        int i;
        unsigned short rx_cfg;
        u32 crc;
                for(i = 0; i < 4; i++) hash_table[i] = 0;
 
                netdev_for_each_mc_addr(ha, dev) {
-                       addrs = ha->addr;
-
-                       if(!(*addrs & 1))
-                               continue;
-
-                       crc = ether_crc_le(6, addrs);
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
                        hash_table[crc >> 4] |= 1 << (crc & 0xf);
                }
 
        struct lance_private *lp = netdev_priv(dev);
        volatile u16 *ib = (volatile u16 *)dev->mem_start;
        struct netdev_hw_addr *ha;
-       char *addrs;
        u32 crc;
 
        /* set all multicast bits */
 
        /* Add addresses */
        netdev_for_each_mc_addr(ha, dev) {
-               addrs = ha->addr;
-
-               /* multicast address? */
-               if (!(*addrs & 1))
-                       continue;
-
-               crc = ether_crc_le(ETH_ALEN, addrs);
+               crc = ether_crc_le(ETH_ALEN, ha->addr);
                crc = crc >> 26;
                *lib_ptr(ib, filter[crc >> 4], lp->type) |= 1 << (crc & 0xf);
        }
 
        struct netdev_hw_addr *ha;
        u_long iobase = dev->base_addr;
        int i;
-       char *addrs, bit, byte;
+       char bit, byte;
        short __iomem *p = lp->mctbl;
        u16 hashcode;
        u32 crc;
 
                /* Update table */
                netdev_for_each_mc_addr(ha, dev) {
-                       addrs = ha->addr;
-                       if ((*addrs & 0x01) == 1) {     /* multicast address? */
-                               crc = ether_crc_le(ETH_ALEN, addrs);
-                               hashcode = crc & ((1 << 9) - 1);        /* hashcode is 9 LSb of CRC */
+                       crc = ether_crc_le(ETH_ALEN, ha->addr);
+                       hashcode = crc & ((1 << 9) - 1);        /* hashcode is 9 LSb of CRC */
 
-                               byte = hashcode >> 3;   /* bit[3-8] -> byte in filter */
-                               bit = 1 << (hashcode & 0x07);   /* bit[0-2] -> bit in byte */
+                       byte = hashcode >> 3;   /* bit[3-8] -> byte in filter */
+                       bit = 1 << (hashcode & 0x07);   /* bit[0-2] -> bit in byte */
 
-                               if (lp->shmem_length == IO_ONLY) {
-                                       u_char tmp;
+                       if (lp->shmem_length == IO_ONLY) {
+                               u_char tmp;
 
-                                       outw(PAGE0_HTE + byte, EWRK3_PIR1);
-                                       tmp = inb(EWRK3_DATA);
-                                       tmp |= bit;
-                                       outw(PAGE0_HTE + byte, EWRK3_PIR1);
-                                       outb(tmp, EWRK3_DATA);
-                               } else {
-                                       writeb(readb(lp->mctbl + byte) | bit, lp->mctbl + byte);
-                               }
+                               outw(PAGE0_HTE + byte, EWRK3_PIR1);
+                               tmp = inb(EWRK3_DATA);
+                               tmp |= bit;
+                               outw(PAGE0_HTE + byte, EWRK3_PIR1);
+                               outb(tmp, EWRK3_DATA);
+                       } else {
+                               writeb(readb(lp->mctbl + byte) | bit, lp->mctbl + byte);
                        }
                }
        }
 
        writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
 
        netdev_for_each_mc_addr(ha, ndev) {
-               /* Only support group multicast for now */
-               if (!(ha->addr[0] & 1))
-                       continue;
-
                /* calculate crc32 value of mac address */
                crc = 0xffffffff;
 
 
 #endif
                        netdev_for_each_mc_addr(ha, dev) {
                                addrs = ha->addr;
-                               if ((*addrs & 0x01) == 0x01) {  /* multicast address? */
 #ifdef HP100_DEBUG
-                                       printk("hp100: %s: multicast = %pM, ",
-                                                    dev->name, addrs);
+                               printk("hp100: %s: multicast = %pM, ",
+                                            dev->name, addrs);
 #endif
-                                       for (i = idx = 0; i < 6; i++) {
-                                               idx ^= *addrs++ & 0x3f;
-                                               printk(":%02x:", idx);
-                                       }
+                               for (i = idx = 0; i < 6; i++) {
+                                       idx ^= *addrs++ & 0x3f;
+                                       printk(":%02x:", idx);
+                               }
 #ifdef HP100_DEBUG
-                                       printk("idx = %i\n", idx);
+                               printk("idx = %i\n", idx);
 #endif
-                                       lp->hash_bytes[idx >> 3] |= (1 << (idx & 7));
-                               }
+                               lp->hash_bytes[idx >> 3] |= (1 << (idx & 7));
                        }
                }
 #else
 
                        ip->ehar_l = 0xffffffff;
                } else {
                        netdev_for_each_mc_addr(ha, dev) {
-                               char *addr = ha->addr;
-
-                               if (!(*addr & 1))
-                                       continue;
-
-                               ehar |= (1UL << ioc3_hash(addr));
+                               ehar |= (1UL << ioc3_hash(ha->addr));
                        }
                        ip->ehar_h = ehar >> 32;
                        ip->ehar_l = ehar & 0xffffffff;
 
                        hash_table[i] = 0;
 
                netdev_for_each_mc_addr(ha, dev) {
-                       char *addrs = ha->addr;
-
-                       if (!(*addrs & 1))
-                               continue;
-
-                       crc = ether_crc_le(6, addrs);
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
                        hash_table[crc >> 4] |= 1 << (15 - (crc & 0xf));
                }
 
                        int i = 0;
 
                        netdev_for_each_mc_addr(ha, netdev) {
-                               if (!(*ha->addr & 1))
-                                       continue;
                                if (i >= MAX_MCAST_LST)
                                        break;
                                memcpy(ks->mcast_lst[i++], ha->addr, ETH_ALEN);
 
                }
 
                netdev_for_each_mc_addr(ha, dev) {
-                       if (!(*ha->addr & 1))
-                               continue;
                        if (i >= MAX_MULTICAST_LIST)
                                break;
                        memcpy(hw->multi_list[i++], ha->addr, MAC_ADDR_LEN);
 
        volatile __le16 *mcast_table = (__le16 *)ib->filter;
        struct netdev_hw_addr *ha;
        unsigned long ioaddr = dev->base_addr;
-       char *addrs;
        int i;
        u32 crc;
 
 
        /* Add addresses */
        netdev_for_each_mc_addr(ha, dev) {
-               addrs = ha->addr;
-
-               /* multicast address? */
-               if (!(*addrs & 1))
-                       continue;
-
-               crc = ether_crc_le(6, addrs);
+               crc = ether_crc_le(6, ha->addr);
                crc = crc >> 26;
                mcast_table[crc >> 4] |= cpu_to_le16(1 << (crc & 0xf));
        }
 
                netdev_for_each_mc_addr(ha, dev) {
                        u32 position;
 
-                       /* make sure this is a multicast address -
-                               shouldn't this be a given if we have it here ? */
-                       if (!(*ha->addr & 1))
-                               continue;
-
                        /* upper 6 bits are used as hash index */
                        position = ether_crc(ETH_ALEN, ha->addr)>>26;
 
 
        netdev_for_each_mc_addr(ha, dev) {
                int position;
 
-               /* make sure this is a multicast address - shouldn't this
-                  be a given if we have it here ? */
-               if (!(*ha->addr & 1))
-                       continue;
-
                /* only use the low order bits */
                position = ether_crc_le(6, ha->addr) & 0x3f;
 
 
                netdev_for_each_mc_addr(ha, dev) {
                        int position;
 
-                       /* make sure this is a multicast address -
-                          shouldn't this be a given if we have it here ? */
-                       if (!(*ha->addr & 1))
-                               continue;
-
                        /* only use the low order bits */
                        position = crc32_le(~0, ha->addr, 6) & 0x3f;
 
 
        struct bigmac *bp = netdev_priv(dev);
        void __iomem *bregs = bp->bregs;
        struct netdev_hw_addr *ha;
-       char *addrs;
        int i;
        u32 tmp, crc;
 
                        hash_table[i] = 0;
 
                netdev_for_each_mc_addr(ha, dev) {
-                       addrs = ha->addr;
-
-                       if (!(*addrs & 1))
-                               continue;
-
-                       crc = ether_crc_le(6, addrs);
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
                        hash_table[crc >> 4] |= 1 << (crc & 0xf);
                }
 
 
                memset(hash_table, 0, sizeof(hash_table));
                netdev_for_each_mc_addr(ha, gp->dev) {
-                       char *addrs = ha->addr;
-
-                       if (!(*addrs & 1))
-                               continue;
-
-                       crc = ether_crc_le(6, addrs);
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 24;
                        hash_table[crc >> 4] |= 1 << (15 - (crc & 0xf));
                }
 
        } else if ((hp->dev->flags & IFF_PROMISC) == 0) {
                u16 hash_table[4];
                struct netdev_hw_addr *ha;
-               char *addrs;
                u32 crc;
 
                memset(hash_table, 0, sizeof(hash_table));
                netdev_for_each_mc_addr(ha, hp->dev) {
-                       addrs = ha->addr;
-
-                       if (!(*addrs & 1))
-                               continue;
-
-                       crc = ether_crc_le(6, addrs);
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
                        hash_table[crc >> 4] |= 1 << (crc & 0xf);
                }
        struct happy_meal *hp = netdev_priv(dev);
        void __iomem *bregs = hp->bigmacregs;
        struct netdev_hw_addr *ha;
-       char *addrs;
        u32 crc;
 
        spin_lock_irq(&hp->happy_lock);
 
                memset(hash_table, 0, sizeof(hash_table));
                netdev_for_each_mc_addr(ha, dev) {
-                       addrs = ha->addr;
-
-                       if (!(*addrs & 1))
-                               continue;
-
-                       crc = ether_crc_le(6, addrs);
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
                        hash_table[crc >> 4] |= 1 << (crc & 0xf);
                }
 
 {
        struct lance_private *lp = netdev_priv(dev);
        struct netdev_hw_addr *ha;
-       char *addrs;
        u32 crc;
        u32 val;
 
 
        /* Add addresses */
        netdev_for_each_mc_addr(ha, dev) {
-               addrs = ha->addr;
-
-               /* multicast address? */
-               if (!(*addrs & 1))
-                       continue;
-               crc = ether_crc_le(6, addrs);
+               crc = ether_crc_le(6, ha->addr);
                crc = crc >> 26;
                if (lp->pio_buffer) {
                        struct lance_init_block __iomem *ib = lp->init_block_iomem;
 
        struct sunqe *qep = netdev_priv(dev);
        struct netdev_hw_addr *ha;
        u8 new_mconfig = qep->mconfig;
-       char *addrs;
        int i;
        u32 crc;
 
 
                memset(hash_table, 0, sizeof(hash_table));
                netdev_for_each_mc_addr(ha, dev) {
-                       addrs = ha->addr;
-
-                       if (!(*addrs & 1))
-                               continue;
-                       crc = ether_crc_le(6, addrs);
+                       crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
                        hash_table[crc >> 4] |= 1 << (crc & 0xf);
                }