17 files changed, 140 insertions, 57 deletions

diff --git a/drivers/net/wireless/hostap/hostap_ap.c b/drivers/net/wireless/hostap/hostap_ap.c
index 08bc57a4b895..974a8e5bec8b 100644
--- a/drivers/net/wireless/hostap/hostap_ap.c
+++ b/drivers/net/wireless/hostap/hostap_ap.c
@@ -1100,15 +1100,13 @@ static struct sta_info * ap_add_sta(struct ap_data *ap, u8 *addr)
 {
         struct sta_info *sta;
 
-        sta = (struct sta_info *)
-                kmalloc(sizeof(struct sta_info), GFP_ATOMIC);
+        sta = kzalloc(sizeof(struct sta_info), GFP_ATOMIC);
         if (sta == NULL) {
                 PDEBUG(DEBUG_AP, "AP: kmalloc failed\n");
                 return NULL;
         }
 
         /* initialize STA info data */
-        memset(sta, 0, sizeof(struct sta_info));
         sta->local = ap->local;
         skb_queue_head_init(&sta->tx_buf);
         memcpy(sta->addr, addr, ETH_ALEN);
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index ee542ec6d6a8..8d8f4b9b8b07 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -563,12 +563,11 @@ static int prism2_config(struct pcmcia_device *link)
         PDEBUG(DEBUG_FLOW, "prism2_config()\n");
 
         parse = kmalloc(sizeof(cisparse_t), GFP_KERNEL);
-        hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
+        hw_priv = kzalloc(sizeof(*hw_priv), GFP_KERNEL);
         if (parse == NULL || hw_priv == NULL) {
                 ret = -ENOMEM;
                 goto failed;
         }
-        memset(hw_priv, 0, sizeof(*hw_priv));
 
         tuple.Attributes = 0;
         tuple.TupleData = buf;
diff --git a/drivers/net/wireless/hostap/hostap_download.c b/drivers/net/wireless/hostap/hostap_download.c
index ab26b52b3e76..24fc387bba67 100644
--- a/drivers/net/wireless/hostap/hostap_download.c
+++ b/drivers/net/wireless/hostap/hostap_download.c
@@ -685,14 +685,12 @@ static int prism2_download(local_info_t *local,
                 goto out;
         }
 
-        dl = kmalloc(sizeof(*dl) + param->num_areas *
+        dl = kzalloc(sizeof(*dl) + param->num_areas *
                      sizeof(struct prism2_download_data_area), GFP_KERNEL);
         if (dl == NULL) {
                 ret = -ENOMEM;
                 goto out;
         }
-        memset(dl, 0, sizeof(*dl) + param->num_areas *
-               sizeof(struct prism2_download_data_area));
         dl->dl_cmd = param->dl_cmd;
         dl->start_addr = param->start_addr;
         dl->num_areas = param->num_areas;
diff --git a/drivers/net/wireless/hostap/hostap_hw.c b/drivers/net/wireless/hostap/hostap_hw.c
index c19e68636a1c..a394a23b9a20 100644
--- a/drivers/net/wireless/hostap/hostap_hw.c
+++ b/drivers/net/wireless/hostap/hostap_hw.c
@@ -347,14 +347,12 @@ static int hfa384x_cmd(struct net_device *dev, u16 cmd, u16 param0,
         if (signal_pending(current))
                 return -EINTR;
 
-        entry = (struct hostap_cmd_queue *)
-                kmalloc(sizeof(*entry), GFP_ATOMIC);
+        entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
         if (entry == NULL) {
                 printk(KERN_DEBUG "%s: hfa384x_cmd - kmalloc failed\n",
                        dev->name);
                 return -ENOMEM;
         }
-        memset(entry, 0, sizeof(*entry));
         atomic_set(&entry->usecnt, 1);
         entry->type = CMD_SLEEP;
         entry->cmd = cmd;
@@ -517,14 +515,12 @@ static int hfa384x_cmd_callback(struct net_device *dev, u16 cmd, u16 param0,
                 return -1;
         }
 
-        entry = (struct hostap_cmd_queue *)
-                kmalloc(sizeof(*entry), GFP_ATOMIC);
+        entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
         if (entry == NULL) {
                 printk(KERN_DEBUG "%s: hfa384x_cmd_callback - kmalloc "
                        "failed\n", dev->name);
                 return -ENOMEM;
         }
-        memset(entry, 0, sizeof(*entry));
         atomic_set(&entry->usecnt, 1);
         entry->type = CMD_CALLBACK;
         entry->cmd = cmd;
@@ -3016,14 +3012,12 @@ static int prism2_set_tim(struct net_device *dev, int aid, int set)
         iface = netdev_priv(dev);
         local = iface->local;
 
-        new_entry = (struct set_tim_data *)
-                kmalloc(sizeof(*new_entry), GFP_ATOMIC);
+        new_entry = kzalloc(sizeof(*new_entry), GFP_ATOMIC);
         if (new_entry == NULL) {
                 printk(KERN_DEBUG "%s: prism2_set_tim: kmalloc failed\n",
                        local->dev->name);
                 return -ENOMEM;
         }
-        memset(new_entry, 0, sizeof(*new_entry));
         new_entry->aid = aid;
         new_entry->set = set;
 
diff --git a/drivers/net/wireless/hostap/hostap_info.c b/drivers/net/wireless/hostap/hostap_info.c
index 5fd2b1ad7f5e..b6a02a02da74 100644
--- a/drivers/net/wireless/hostap/hostap_info.c
+++ b/drivers/net/wireless/hostap/hostap_info.c
@@ -327,11 +327,10 @@ static void prism2_info_hostscanresults(local_info_t *local,
         ptr = (u8 *) pos;
 
         new_count = left / result_size;
-        results = kmalloc(new_count * sizeof(struct hfa384x_hostscan_result),
+        results = kcalloc(new_count, sizeof(struct hfa384x_hostscan_result),
                           GFP_ATOMIC);
         if (results == NULL)
                 return;
-        memset(results, 0, new_count * sizeof(struct hfa384x_hostscan_result));
 
         for (i = 0; i < new_count; i++) {
                 memcpy(&results[i], ptr, copy_len);
diff --git a/drivers/net/wireless/hostap/hostap_ioctl.c b/drivers/net/wireless/hostap/hostap_ioctl.c
index d061fb3443ff..3b7b8063ff1c 100644
--- a/drivers/net/wireless/hostap/hostap_ioctl.c
+++ b/drivers/net/wireless/hostap/hostap_ioctl.c
@@ -181,12 +181,10 @@ static int prism2_ioctl_siwencode(struct net_device *dev,
                 struct ieee80211_crypt_data *new_crypt;
 
                 /* take WEP into use */
-                new_crypt = (struct ieee80211_crypt_data *)
-                        kmalloc(sizeof(struct ieee80211_crypt_data),
+                new_crypt = kzalloc(sizeof(struct ieee80211_crypt_data),
                                 GFP_KERNEL);
                 if (new_crypt == NULL)
                         return -ENOMEM;
-                memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
                 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
                 if (!new_crypt->ops) {
                         request_module("ieee80211_crypt_wep");
@@ -3320,14 +3318,12 @@ static int prism2_ioctl_siwencodeext(struct net_device *dev,
 
                 prism2_crypt_delayed_deinit(local, crypt);
 
-                new_crypt = (struct ieee80211_crypt_data *)
-                        kmalloc(sizeof(struct ieee80211_crypt_data),
+                new_crypt = kzalloc(sizeof(struct ieee80211_crypt_data),
                                 GFP_KERNEL);
                 if (new_crypt == NULL) {
                         ret = -ENOMEM;
                         goto done;
                 }
-                memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
                 new_crypt->ops = ops;
                 new_crypt->priv = new_crypt->ops->init(i);
                 if (new_crypt->priv == NULL) {
@@ -3538,14 +3534,12 @@ static int prism2_ioctl_set_encryption(local_info_t *local,
 
                 prism2_crypt_delayed_deinit(local, crypt);
 
-                new_crypt = (struct ieee80211_crypt_data *)
-                        kmalloc(sizeof(struct ieee80211_crypt_data),
+                new_crypt = kzalloc(sizeof(struct ieee80211_crypt_data),
                                 GFP_KERNEL);
                 if (new_crypt == NULL) {
                         ret = -ENOMEM;
                         goto done;
                 }
-                memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
                 new_crypt->ops = ops;
                 new_crypt->priv = new_crypt->ops->init(param->u.crypt.idx);
                 if (new_crypt->priv == NULL) {
diff --git a/drivers/net/wireless/hostap/hostap_pci.c b/drivers/net/wireless/hostap/hostap_pci.c
index d1de9766c831..c4f6020baa9e 100644
--- a/drivers/net/wireless/hostap/hostap_pci.c
+++ b/drivers/net/wireless/hostap/hostap_pci.c
@@ -300,10 +300,9 @@ static int prism2_pci_probe(struct pci_dev *pdev,
         struct hostap_interface *iface;
         struct hostap_pci_priv *hw_priv;
 
-        hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
+        hw_priv = kzalloc(sizeof(*hw_priv), GFP_KERNEL);
         if (hw_priv == NULL)
                 return -ENOMEM;
-        memset(hw_priv, 0, sizeof(*hw_priv));
 
         if (pci_enable_device(pdev))
                 goto err_out_free;
diff --git a/drivers/net/wireless/hostap/hostap_plx.c b/drivers/net/wireless/hostap/hostap_plx.c
index bc81b13a5a2a..e235e0647897 100644
--- a/drivers/net/wireless/hostap/hostap_plx.c
+++ b/drivers/net/wireless/hostap/hostap_plx.c
@@ -447,10 +447,9 @@ static int prism2_plx_probe(struct pci_dev *pdev,
         int tmd7160;
         struct hostap_plx_priv *hw_priv;
 
-        hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
+        hw_priv = kzalloc(sizeof(*hw_priv), GFP_KERNEL);
         if (hw_priv == NULL)
                 return -ENOMEM;
-        memset(hw_priv, 0, sizeof(*hw_priv));
 
         if (pci_enable_device(pdev))
                 goto err_out_free;
diff --git a/drivers/net/wireless/ipw2100.c b/drivers/net/wireless/ipw2100.c
index 1bcd352a813b..dd9ba4aad7bb 100644
--- a/drivers/net/wireless/ipw2100.c
+++ b/drivers/net/wireless/ipw2100.c
@@ -6220,7 +6220,7 @@ static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
         /* Allocate and initialize the Tx/Rx queues and lists */
         if (ipw2100_queues_allocate(priv)) {
                 printk(KERN_WARNING DRV_NAME
-                       "Error calilng ipw2100_queues_allocate.\n");
+                       "Error calling ipw2100_queues_allocate.\n");
                 err = -ENOMEM;
                 goto fail;
         }
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index e82e56bb85e1..22cb3fb7502e 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -70,7 +70,7 @@
 #define VQ
 #endif
 
-#define IPW2200_VERSION "1.1.4" VK VD VM VP VR VQ
+#define IPW2200_VERSION "1.2.0" VK VD VM VP VR VQ
 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
 #define DRV_COPYRIGHT   "Copyright(c) 2003-2006 Intel Corporation"
 #define DRV_VERSION     IPW2200_VERSION
@@ -7677,7 +7677,8 @@ static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
 
         /* Big bitfield of all the fields we provide in radiotap */
         ipw_rt->rt_hdr.it_present =
-            ((1 << IEEE80211_RADIOTAP_FLAGS) |
+            ((1 << IEEE80211_RADIOTAP_TSFT) |
+             (1 << IEEE80211_RADIOTAP_FLAGS) |
              (1 << IEEE80211_RADIOTAP_RATE) |
              (1 << IEEE80211_RADIOTAP_CHANNEL) |
              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
@@ -7686,10 +7687,14 @@ static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
 
         /* Zero the flags, we'll add to them as we go */
         ipw_rt->rt_flags = 0;
-        ipw_rt->rt_tsf = 0ULL;
+        ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
+                               frame->parent_tsf[2] << 16 |
+                               frame->parent_tsf[1] << 8  |
+                               frame->parent_tsf[0]);
 
         /* Convert signal to DBM */
         ipw_rt->rt_dbmsignal = antsignal;
+        ipw_rt->rt_dbmnoise = frame->noise;
 
         /* Convert the channel data and set the flags */
         ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
@@ -7889,7 +7894,8 @@ static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
 
         /* Big bitfield of all the fields we provide in radiotap */
         ipw_rt->rt_hdr.it_present =
-            ((1 << IEEE80211_RADIOTAP_FLAGS) |
+            ((1 << IEEE80211_RADIOTAP_TSFT) |
+             (1 << IEEE80211_RADIOTAP_FLAGS) |
              (1 << IEEE80211_RADIOTAP_RATE) |
              (1 << IEEE80211_RADIOTAP_CHANNEL) |
              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
@@ -7898,7 +7904,10 @@ static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
 
         /* Zero the flags, we'll add to them as we go */
         ipw_rt->rt_flags = 0;
-        ipw_rt->rt_tsf = 0ULL;
+        ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
+                               frame->parent_tsf[2] << 16 |
+                               frame->parent_tsf[1] << 8  |
+                               frame->parent_tsf[0]);
 
         /* Convert to DBM */
         ipw_rt->rt_dbmsignal = signal;
@@ -8297,7 +8306,7 @@ static void ipw_rx(struct ipw_priv *priv)
                                     ("Notification: subtype=%02X flags=%02X size=%d\n",
                                      pkt->u.notification.subtype,
                                      pkt->u.notification.flags,
-                                     pkt->u.notification.size);
+                                     le16_to_cpu(pkt->u.notification.size));
                                 ipw_rx_notification(priv, &pkt->u.notification);
                                 break;
                         }
@@ -11145,14 +11154,13 @@ static int ipw_up(struct ipw_priv *priv)
                 return -EIO;
 
         if (cmdlog && !priv->cmdlog) {
-                priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
+                priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
                                        GFP_KERNEL);
                 if (priv->cmdlog == NULL) {
                         IPW_ERROR("Error allocating %d command log entries.\n",
                                   cmdlog);
                         return -ENOMEM;
                 } else {
-                        memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
                         priv->cmdlog_len = cmdlog;
                 }
         }
diff --git a/drivers/net/wireless/prism54/isl_ioctl.c b/drivers/net/wireless/prism54/isl_ioctl.c
index a87eb51886c8..96606ed10076 100644
--- a/drivers/net/wireless/prism54/isl_ioctl.c
+++ b/drivers/net/wireless/prism54/isl_ioctl.c
@@ -2141,11 +2141,9 @@ prism54_wpa_bss_ie_add(islpci_private *priv, u8 *bssid,
                                          struct islpci_bss_wpa_ie, list);
                         list_del(&bss->list);
                 } else {
-                        bss = kmalloc(sizeof (*bss), GFP_ATOMIC);
-                        if (bss != NULL) {
+                        bss = kzalloc(sizeof (*bss), GFP_ATOMIC);
+                        if (bss != NULL)
                                 priv->num_bss_wpa++;
-                                memset(bss, 0, sizeof (*bss));
-                        }
                 }
                 if (bss != NULL) {
                         memcpy(bss->bssid, bssid, ETH_ALEN);
@@ -2686,11 +2684,10 @@ prism2_ioctl_set_generic_element(struct net_device *ndev,
                return -EINVAL;
 
        alen = sizeof(*attach) + len;
-       attach = kmalloc(alen, GFP_KERNEL);
+       attach = kzalloc(alen, GFP_KERNEL);
        if (attach == NULL)
                return -ENOMEM;
 
-       memset(attach, 0, alen);
 #define WLAN_FC_TYPE_MGMT 0
 #define WLAN_FC_STYPE_ASSOC_REQ 0
 #define WLAN_FC_STYPE_REASSOC_REQ 2
diff --git a/drivers/net/wireless/prism54/oid_mgt.c b/drivers/net/wireless/prism54/oid_mgt.c
index fbc52b6a3024..e6cf9df2c206 100644
--- a/drivers/net/wireless/prism54/oid_mgt.c
+++ b/drivers/net/wireless/prism54/oid_mgt.c
@@ -235,12 +235,10 @@ mgt_init(islpci_private *priv)
 {
         int i;
 
-        priv->mib = kmalloc(OID_NUM_LAST * sizeof (void *), GFP_KERNEL);
+        priv->mib = kcalloc(OID_NUM_LAST, sizeof (void *), GFP_KERNEL);
         if (!priv->mib)
                 return -ENOMEM;
 
-        memset(priv->mib, 0, OID_NUM_LAST * sizeof (void *));
-
         /* Alloc the cache */
         for (i = 0; i < OID_NUM_LAST; i++) {
                 if (isl_oid[i].flags & OID_FLAG_CACHED) {
diff --git a/drivers/net/wireless/zd1211rw/zd_chip.c b/drivers/net/wireless/zd1211rw/zd_chip.c
index 8be99ebbe1cd..77e11ddad836 100644
--- a/drivers/net/wireless/zd1211rw/zd_chip.c
+++ b/drivers/net/wireless/zd1211rw/zd_chip.c
@@ -1673,3 +1673,16 @@ int zd_rfwritev_cr_locked(struct zd_chip *chip,
 
         return 0;
 }
+
+int zd_chip_set_multicast_hash(struct zd_chip *chip,
+                               struct zd_mc_hash *hash)
+{
+        struct zd_ioreq32 ioreqs[] = {
+                { CR_GROUP_HASH_P1, hash->low },
+                { CR_GROUP_HASH_P2, hash->high },
+        };
+
+        dev_dbg_f(zd_chip_dev(chip), "hash l 0x%08x h 0x%08x\n",
+                ioreqs[0].value, ioreqs[1].value);
+        return zd_iowrite32a(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
diff --git a/drivers/net/wireless/zd1211rw/zd_chip.h b/drivers/net/wireless/zd1211rw/zd_chip.h
index ca892b9a6448..a4e3cee9b59d 100644
--- a/drivers/net/wireless/zd1211rw/zd_chip.h
+++ b/drivers/net/wireless/zd1211rw/zd_chip.h
@@ -390,10 +390,19 @@
 #define CR_BSSID_P1                     CTL_REG(0x0618)
 #define CR_BSSID_P2                     CTL_REG(0x061C)
 #define CR_BCN_PLCP_CFG                 CTL_REG(0x0620)
+
+/* Group hash table for filtering incoming packets.
+ *
+ * The group hash table is 64 bit large and split over two parts. The first
+ * part is the lower part. The upper 6 bits of the last byte of the target
+ * address are used as index. Packets are received if the hash table bit is
+ * set. This is used for multicast handling, but for broadcasts (address
+ * ff:ff:ff:ff:ff:ff) the highest bit in the second table must also be set.
+ */
 #define CR_GROUP_HASH_P1                CTL_REG(0x0624)
 #define CR_GROUP_HASH_P2                CTL_REG(0x0628)
-#define CR_RX_TIMEOUT                   CTL_REG(0x062C)
 
+#define CR_RX_TIMEOUT                   CTL_REG(0x062C)
 /* Basic rates supported by the BSS. When producing ACK or CTS messages, the
  * device will use a rate in this table that is less than or equal to the rate
  * of the incoming frame which prompted the response */
@@ -864,4 +873,36 @@ u8 zd_rx_strength_percent(u8 rssi);
 
 u16 zd_rx_rate(const void *rx_frame, const struct rx_status *status);
 
+struct zd_mc_hash {
+        u32 low;
+        u32 high;
+};
+
+static inline void zd_mc_clear(struct zd_mc_hash *hash)
+{
+        hash->low = 0;
+        /* The interfaces must always received broadcasts.
+         * The hash of the broadcast address ff:ff:ff:ff:ff:ff is 63.
+         */
+        hash->high = 0x80000000;
+}
+
+static inline void zd_mc_add_all(struct zd_mc_hash *hash)
+{
+        hash->low = hash->high = 0xffffffff;
+}
+
+static inline void zd_mc_add_addr(struct zd_mc_hash *hash, u8 *addr)
+{
+        unsigned int i = addr[5] >> 2;
+        if (i < 32) {
+                hash->low |= 1 << i;
+        } else {
+                hash->high |= 1 << (i-32);
+        }
+}
+
+int zd_chip_set_multicast_hash(struct zd_chip *chip,
+                               struct zd_mc_hash *hash);
+
 #endif /* _ZD_CHIP_H */
diff --git a/drivers/net/wireless/zd1211rw/zd_mac.c b/drivers/net/wireless/zd1211rw/zd_mac.c
index f1573a9c2336..00ca704ece35 100644
--- a/drivers/net/wireless/zd1211rw/zd_mac.c
+++ b/drivers/net/wireless/zd1211rw/zd_mac.c
@@ -39,6 +39,8 @@ static void housekeeping_init(struct zd_mac *mac);
 static void housekeeping_enable(struct zd_mac *mac);
 static void housekeeping_disable(struct zd_mac *mac);
 
+static void set_multicast_hash_handler(struct work_struct *work);
+
 int zd_mac_init(struct zd_mac *mac,
                 struct net_device *netdev,
                 struct usb_interface *intf)
@@ -55,6 +57,7 @@ int zd_mac_init(struct zd_mac *mac,
         softmac_init(ieee80211_priv(netdev));
         zd_chip_init(&mac->chip, netdev, intf);
         housekeeping_init(mac);
+        INIT_WORK(&mac->set_multicast_hash_work, set_multicast_hash_handler);
         return 0;
 }
 
@@ -136,6 +139,7 @@ out:
 
 void zd_mac_clear(struct zd_mac *mac)
 {
+        flush_workqueue(zd_workqueue);
         zd_chip_clear(&mac->chip);
         ZD_ASSERT(!spin_is_locked(&mac->lock));
         ZD_MEMCLEAR(mac, sizeof(struct zd_mac));
@@ -256,6 +260,43 @@ int zd_mac_set_mac_address(struct net_device *netdev, void *p)
         return 0;
 }
 
+static void set_multicast_hash_handler(struct work_struct *work)
+{
+        struct zd_mac *mac = container_of(work, struct zd_mac,
+                                          set_multicast_hash_work);
+        struct zd_mc_hash hash;
+
+        spin_lock_irq(&mac->lock);
+        hash = mac->multicast_hash;
+        spin_unlock_irq(&mac->lock);
+
+        zd_chip_set_multicast_hash(&mac->chip, &hash);
+}
+
+void zd_mac_set_multicast_list(struct net_device *dev)
+{
+        struct zd_mc_hash hash;
+        struct zd_mac *mac = zd_netdev_mac(dev);
+        struct dev_mc_list *mc;
+        unsigned long flags;
+
+        if (dev->flags & (IFF_PROMISC|IFF_ALLMULTI)) {
+                zd_mc_add_all(&hash);
+        } else {
+                zd_mc_clear(&hash);
+                for (mc = dev->mc_list; mc; mc = mc->next) {
+                        dev_dbg_f(zd_mac_dev(mac), "mc addr " MAC_FMT "\n",
+                                  MAC_ARG(mc->dmi_addr));
+                        zd_mc_add_addr(&hash, mc->dmi_addr);
+                }
+        }
+
+        spin_lock_irqsave(&mac->lock, flags);
+        mac->multicast_hash = hash;
+        spin_unlock_irqrestore(&mac->lock, flags);
+        queue_work(zd_workqueue, &mac->set_multicast_hash_work);
+}
+
 int zd_mac_set_regdomain(struct zd_mac *mac, u8 regdomain)
 {
         int r;
@@ -618,6 +659,9 @@ int zd_mac_get_range(struct zd_mac *mac, struct iw_range *range)
         range->we_version_compiled = WIRELESS_EXT;
         range->we_version_source = 20;
 
+        range->enc_capa = IW_ENC_CAPA_WPA |  IW_ENC_CAPA_WPA2 |
+                          IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
+
         ZD_ASSERT(!irqs_disabled());
         spin_lock_irq(&mac->lock);
         regdomain = mac->regdomain;
@@ -930,7 +974,8 @@ static int is_data_packet_for_us(struct ieee80211_device *ieee,
         }
 
         return memcmp(hdr->addr1, netdev->dev_addr, ETH_ALEN) == 0 ||
-               is_multicast_ether_addr(hdr->addr1) ||
+               (is_multicast_ether_addr(hdr->addr1) &&
+                memcmp(hdr->addr3, netdev->dev_addr, ETH_ALEN) != 0) ||
                (netdev->flags & IFF_PROMISC);
 }
 
@@ -1062,10 +1107,8 @@ int zd_mac_rx(struct zd_mac *mac, const u8 *buffer, unsigned int length)
         memcpy(skb_put(skb, length), buffer, length);
 
         r = ieee80211_rx(ieee, skb, &stats);
-        if (!r) {
-                ZD_ASSERT(in_irq());
-                dev_kfree_skb_irq(skb);
-        }
+        if (!r)
+                dev_kfree_skb_any(skb);
         return 0;
 }
 
diff --git a/drivers/net/wireless/zd1211rw/zd_mac.h b/drivers/net/wireless/zd1211rw/zd_mac.h
index d4e8b870409d..f0cf05dc7d3e 100644
--- a/drivers/net/wireless/zd1211rw/zd_mac.h
+++ b/drivers/net/wireless/zd1211rw/zd_mac.h
@@ -133,6 +133,8 @@ struct zd_mac {
         struct iw_statistics iw_stats;
 
         struct housekeeping housekeeping;
+        struct work_struct set_multicast_hash_work;
+        struct zd_mc_hash multicast_hash;
         struct delayed_work set_rts_cts_work;
         struct delayed_work set_basic_rates_work;
 
@@ -189,6 +191,7 @@ int zd_mac_init_hw(struct zd_mac *mac, u8 device_type);
 int zd_mac_open(struct net_device *netdev);
 int zd_mac_stop(struct net_device *netdev);
 int zd_mac_set_mac_address(struct net_device *dev, void *p);
+void zd_mac_set_multicast_list(struct net_device *netdev);
 
 int zd_mac_rx(struct zd_mac *mac, const u8 *buffer, unsigned int length);
 
diff --git a/drivers/net/wireless/zd1211rw/zd_netdev.c b/drivers/net/wireless/zd1211rw/zd_netdev.c
index 60f1b0f6d45b..8bda48de31ef 100644
--- a/drivers/net/wireless/zd1211rw/zd_netdev.c
+++ b/drivers/net/wireless/zd1211rw/zd_netdev.c
@@ -242,7 +242,7 @@ struct net_device *zd_netdev_alloc(struct usb_interface *intf)
         netdev->open = zd_mac_open;
         netdev->stop = zd_mac_stop;
         /* netdev->get_stats = */
-        /* netdev->set_multicast_list = */
+        netdev->set_multicast_list = zd_mac_set_multicast_list;
         netdev->set_mac_address = zd_mac_set_mac_address;
         netdev->wireless_handlers = &iw_handler_def;
         /* netdev->ethtool_ops = */