1 files changed, 101 insertions, 72 deletions

diff --git a/drivers/net/wireless/orinoco/wext.c b/drivers/net/wireless/orinoco/wext.c
index b6ff3dbb7dd6..3e56f7643df5 100644
--- a/drivers/net/wireless/orinoco/wext.c
+++ b/drivers/net/wireless/orinoco/wext.c
@@ -22,6 +22,67 @@
 
 #define MAX_RID_LEN 1024
 
+/* Helper routine to record keys
+ * Do not call from interrupt context */
+static int orinoco_set_key(struct orinoco_private *priv, int index,
+                           enum orinoco_alg alg, const u8 *key, int key_len,
+                           const u8 *seq, int seq_len)
+{
+        kzfree(priv->keys[index].key);
+        kzfree(priv->keys[index].seq);
+
+        if (key_len) {
+                priv->keys[index].key = kzalloc(key_len, GFP_KERNEL);
+                if (!priv->keys[index].key)
+                        goto nomem;
+        } else
+                priv->keys[index].key = NULL;
+
+        if (seq_len) {
+                priv->keys[index].seq = kzalloc(seq_len, GFP_KERNEL);
+                if (!priv->keys[index].seq)
+                        goto free_key;
+        } else
+                priv->keys[index].seq = NULL;
+
+        priv->keys[index].key_len = key_len;
+        priv->keys[index].seq_len = seq_len;
+
+        if (key_len)
+                memcpy(priv->keys[index].key, key, key_len);
+        if (seq_len)
+                memcpy(priv->keys[index].seq, seq, seq_len);
+
+        switch (alg) {
+        case ORINOCO_ALG_TKIP:
+                priv->keys[index].cipher = WLAN_CIPHER_SUITE_TKIP;
+                break;
+
+        case ORINOCO_ALG_WEP:
+                priv->keys[index].cipher = (key_len > SMALL_KEY_SIZE) ?
+                        WLAN_CIPHER_SUITE_WEP104 : WLAN_CIPHER_SUITE_WEP40;
+                break;
+
+        case ORINOCO_ALG_NONE:
+        default:
+                priv->keys[index].cipher = 0;
+                break;
+        }
+
+        return 0;
+
+free_key:
+        kfree(priv->keys[index].key);
+        priv->keys[index].key = NULL;
+
+nomem:
+        priv->keys[index].key_len = 0;
+        priv->keys[index].seq_len = 0;
+        priv->keys[index].cipher = 0;
+
+        return -ENOMEM;
+}
+
 static struct iw_statistics *orinoco_get_wireless_stats(struct net_device *dev)
 {
         struct orinoco_private *priv = ndev_priv(dev);
@@ -156,7 +217,6 @@ static int orinoco_ioctl_getwap(struct net_device *dev,
 {
         struct orinoco_private *priv = ndev_priv(dev);
 
-        hermes_t *hw = &priv->hw;
         int err = 0;
         unsigned long flags;
 
@@ -164,8 +224,7 @@ static int orinoco_ioctl_getwap(struct net_device *dev,
                 return -EBUSY;
 
         ap_addr->sa_family = ARPHRD_ETHER;
-        err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID,
-                              ETH_ALEN, NULL, ap_addr->sa_data);
+        err = orinoco_hw_get_current_bssid(priv, ap_addr->sa_data);
 
         orinoco_unlock(priv, &flags);
 
@@ -180,9 +239,8 @@ static int orinoco_ioctl_setiwencode(struct net_device *dev,
         struct orinoco_private *priv = ndev_priv(dev);
         int index = (erq->flags & IW_ENCODE_INDEX) - 1;
         int setindex = priv->tx_key;
-        int encode_alg = priv->encode_alg;
+        enum orinoco_alg encode_alg = priv->encode_alg;
         int restricted = priv->wep_restrict;
-        u16 xlen = 0;
         int err = -EINPROGRESS;         /* Call commit handler */
         unsigned long flags;
 
@@ -202,25 +260,17 @@ static int orinoco_ioctl_setiwencode(struct net_device *dev,
                 return -EBUSY;
 
         /* Clear any TKIP key we have */
-        if ((priv->has_wpa) && (priv->encode_alg == IW_ENCODE_ALG_TKIP))
+        if ((priv->has_wpa) && (priv->encode_alg == ORINOCO_ALG_TKIP))
                 (void) orinoco_clear_tkip_key(priv, setindex);
 
         if (erq->length > 0) {
                 if ((index < 0) || (index >= ORINOCO_MAX_KEYS))
                         index = priv->tx_key;
 
-                /* Adjust key length to a supported value */
-                if (erq->length > SMALL_KEY_SIZE)
-                        xlen = LARGE_KEY_SIZE;
-                else if (erq->length > 0)
-                        xlen = SMALL_KEY_SIZE;
-                else
-                        xlen = 0;
-
                 /* Switch on WEP if off */
-                if ((encode_alg != IW_ENCODE_ALG_WEP) && (xlen > 0)) {
+                if (encode_alg != ORINOCO_ALG_WEP) {
                         setindex = index;
-                        encode_alg = IW_ENCODE_ALG_WEP;
+                        encode_alg = ORINOCO_ALG_WEP;
                 }
         } else {
                 /* Important note : if the user do "iwconfig eth0 enc off",
@@ -233,7 +283,7 @@ static int orinoco_ioctl_setiwencode(struct net_device *dev,
                         }
                 } else {
                         /* Set the index : Check that the key is valid */
-                        if (priv->keys[index].len == 0) {
+                        if (priv->keys[index].key_len == 0) {
                                 err = -EINVAL;
                                 goto out;
                         }
@@ -242,17 +292,15 @@ static int orinoco_ioctl_setiwencode(struct net_device *dev,
         }
 
         if (erq->flags & IW_ENCODE_DISABLED)
-                encode_alg = IW_ENCODE_ALG_NONE;
+                encode_alg = ORINOCO_ALG_NONE;
         if (erq->flags & IW_ENCODE_OPEN)
                 restricted = 0;
         if (erq->flags & IW_ENCODE_RESTRICTED)
                 restricted = 1;
 
         if (erq->pointer && erq->length > 0) {
-                priv->keys[index].len = cpu_to_le16(xlen);
-                memset(priv->keys[index].data, 0,
-                       sizeof(priv->keys[index].data));
-                memcpy(priv->keys[index].data, keybuf, erq->length);
+                err = orinoco_set_key(priv, index, ORINOCO_ALG_WEP, keybuf,
+                                      erq->length, NULL, 0);
         }
         priv->tx_key = setindex;
 
@@ -281,7 +329,6 @@ static int orinoco_ioctl_getiwencode(struct net_device *dev,
 {
         struct orinoco_private *priv = ndev_priv(dev);
         int index = (erq->flags & IW_ENCODE_INDEX) - 1;
-        u16 xlen = 0;
         unsigned long flags;
 
         if (!priv->has_wep)
@@ -303,11 +350,9 @@ static int orinoco_ioctl_getiwencode(struct net_device *dev,
         else
                 erq->flags |= IW_ENCODE_OPEN;
 
-        xlen = le16_to_cpu(priv->keys[index].len);
+        erq->length = priv->keys[index].key_len;
 
-        erq->length = xlen;
-
-        memcpy(keybuf, priv->keys[index].data, ORINOCO_MAX_KEY_SIZE);
+        memcpy(keybuf, priv->keys[index].key, erq->length);
 
         orinoco_unlock(priv, &flags);
         return 0;
@@ -793,7 +838,6 @@ static int orinoco_ioctl_set_encodeext(struct net_device *dev,
         int idx, alg = ext->alg, set_key = 1;
         unsigned long flags;
         int err = -EINVAL;
-        u16 key_len;
 
         if (orinoco_lock(priv, &flags) != 0)
                 return -EBUSY;
@@ -825,25 +869,18 @@ static int orinoco_ioctl_set_encodeext(struct net_device *dev,
                 /* Set the requested key first */
                 switch (alg) {
                 case IW_ENCODE_ALG_NONE:
-                        priv->encode_alg = alg;
-                        priv->keys[idx].len = 0;
+                        priv->encode_alg = ORINOCO_ALG_NONE;
+                        err = orinoco_set_key(priv, idx, ORINOCO_ALG_NONE,
+                                              NULL, 0, NULL, 0);
                         break;
 
                 case IW_ENCODE_ALG_WEP:
-                        if (ext->key_len > SMALL_KEY_SIZE)
-                                key_len = LARGE_KEY_SIZE;
-                        else if (ext->key_len > 0)
-                                key_len = SMALL_KEY_SIZE;
-                        else
+                        if (ext->key_len <= 0)
                                 goto out;
 
-                        priv->encode_alg = alg;
-                        priv->keys[idx].len = cpu_to_le16(key_len);
-
-                        key_len = min(ext->key_len, key_len);
-
-                        memset(priv->keys[idx].data, 0, ORINOCO_MAX_KEY_SIZE);
-                        memcpy(priv->keys[idx].data, ext->key, key_len);
+                        priv->encode_alg = ORINOCO_ALG_WEP;
+                        err = orinoco_set_key(priv, idx, ORINOCO_ALG_WEP,
+                                              ext->key, ext->key_len, NULL, 0);
                         break;
 
                 case IW_ENCODE_ALG_TKIP:
@@ -851,21 +888,22 @@ static int orinoco_ioctl_set_encodeext(struct net_device *dev,
                         u8 *tkip_iv = NULL;
 
                         if (!priv->has_wpa ||
-                            (ext->key_len > sizeof(priv->tkip_key[0])))
+                            (ext->key_len > sizeof(struct orinoco_tkip_key)))
                                 goto out;
 
-                        priv->encode_alg = alg;
-                        memset(&priv->tkip_key[idx], 0,
-                               sizeof(priv->tkip_key[idx]));
-                        memcpy(&priv->tkip_key[idx], ext->key, ext->key_len);
+                        priv->encode_alg = ORINOCO_ALG_TKIP;
 
                         if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
                                 tkip_iv = &ext->rx_seq[0];
 
+                        err = orinoco_set_key(priv, idx, ORINOCO_ALG_TKIP,
+                                              ext->key, ext->key_len, tkip_iv,
+                                              ORINOCO_SEQ_LEN);
+
                         err = __orinoco_hw_set_tkip_key(priv, idx,
                                  ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY,
-                                 (u8 *) &priv->tkip_key[idx],
-                                 tkip_iv, NULL);
+                                 priv->keys[idx].key,
+                                 tkip_iv, ORINOCO_SEQ_LEN, NULL, 0);
                         if (err)
                                 printk(KERN_ERR "%s: Error %d setting TKIP key"
                                        "\n", dev->name, err);
@@ -914,22 +952,22 @@ static int orinoco_ioctl_get_encodeext(struct net_device *dev,
         encoding->flags = idx + 1;
         memset(ext, 0, sizeof(*ext));
 
-        ext->alg = priv->encode_alg;
         switch (priv->encode_alg) {
-        case IW_ENCODE_ALG_NONE:
+        case ORINOCO_ALG_NONE:
+                ext->alg = IW_ENCODE_ALG_NONE;
                 ext->key_len = 0;
                 encoding->flags |= IW_ENCODE_DISABLED;
                 break;
-        case IW_ENCODE_ALG_WEP:
-                ext->key_len = min_t(u16, le16_to_cpu(priv->keys[idx].len),
-                                     max_key_len);
-                memcpy(ext->key, priv->keys[idx].data, ext->key_len);
+        case ORINOCO_ALG_WEP:
+                ext->alg = IW_ENCODE_ALG_WEP;
+                ext->key_len = min(priv->keys[idx].key_len, max_key_len);
+                memcpy(ext->key, priv->keys[idx].key, ext->key_len);
                 encoding->flags |= IW_ENCODE_ENABLED;
                 break;
-        case IW_ENCODE_ALG_TKIP:
-                ext->key_len = min_t(u16, sizeof(struct orinoco_tkip_key),
-                                     max_key_len);
-                memcpy(ext->key, &priv->tkip_key[idx], ext->key_len);
+        case ORINOCO_ALG_TKIP:
+                ext->alg = IW_ENCODE_ALG_TKIP;
+                ext->key_len = min(priv->keys[idx].key_len, max_key_len);
+                memcpy(ext->key, priv->keys[idx].key, ext->key_len);
                 encoding->flags |= IW_ENCODE_ENABLED;
                 break;
         }
@@ -1136,7 +1174,6 @@ static int orinoco_ioctl_set_mlme(struct net_device *dev,
                                   union iwreq_data *wrqu, char *extra)
 {
         struct orinoco_private *priv = ndev_priv(dev);
-        hermes_t *hw = &priv->hw;
         struct iw_mlme *mlme = (struct iw_mlme *)extra;
         unsigned long flags;
         int ret = 0;
@@ -1150,19 +1187,11 @@ static int orinoco_ioctl_set_mlme(struct net_device *dev,
                 break;
 
         case IW_MLME_DISASSOC:
-        {
-                struct {
-                        u8 addr[ETH_ALEN];
-                        __le16 reason_code;
-                } __attribute__ ((packed)) buf;
-
-                memcpy(buf.addr, mlme->addr.sa_data, ETH_ALEN);
-                buf.reason_code = cpu_to_le16(mlme->reason_code);
-                ret = HERMES_WRITE_RECORD(hw, USER_BAP,
-                                          HERMES_RID_CNFDISASSOCIATE,
-                                          &buf);
+
+                ret = orinoco_hw_disassociate(priv, mlme->addr.sa_data,
+                                              mlme->reason_code);
                 break;
-        }
+
         default:
                 ret = -EOPNOTSUPP;
         }