p54: prepare the eeprom parser routines for longbow

This patch adds support to upload pre-calculated calibration data to the firmware.

Signed-off-by: Christian Lamparter <chunkeey@web.de>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 143 insertions, 45 deletions

diff --git a/drivers/net/wireless/p54/p54common.c b/drivers/net/wireless/p54/p54common.c
index 85aff1685a10..ec0d109c0095 100644
--- a/drivers/net/wireless/p54/p54common.c
+++ b/drivers/net/wireless/p54/p54common.c
@@ -272,13 +272,19 @@ static int p54_convert_rev0(struct ieee80211_hw *dev,
         unsigned int i, j;
         void *source, *target;
 
-        priv->curve_data = kmalloc(cd_len, GFP_KERNEL);
+        priv->curve_data = kmalloc(sizeof(*priv->curve_data) + cd_len,
+                                   GFP_KERNEL);
         if (!priv->curve_data)
                 return -ENOMEM;
 
-        memcpy(priv->curve_data, curve_data, sizeof(*curve_data));
+        priv->curve_data->entries = curve_data->channels;
+        priv->curve_data->entry_size = sizeof(__le16) +
+                sizeof(*dst) * curve_data->points_per_channel;
+        priv->curve_data->offset = offsetof(struct pda_pa_curve_data, data);
+        priv->curve_data->len = cd_len;
+        memcpy(priv->curve_data->data, curve_data, sizeof(*curve_data));
         source = curve_data->data;
-        target = priv->curve_data->data;
+        target = ((struct pda_pa_curve_data *) priv->curve_data->data)->data;
         for (i = 0; i < curve_data->channels; i++) {
                 __le16 *freq = source;
                 source += sizeof(__le16);
@@ -318,13 +324,19 @@ static int p54_convert_rev1(struct ieee80211_hw *dev,
         unsigned int i, j;
         void *source, *target;
 
-        priv->curve_data = kmalloc(cd_len, GFP_KERNEL);
+        priv->curve_data = kzalloc(cd_len + sizeof(*priv->curve_data),
+                                   GFP_KERNEL);
         if (!priv->curve_data)
                 return -ENOMEM;
 
-        memcpy(priv->curve_data, curve_data, sizeof(*curve_data));
+        priv->curve_data->entries = curve_data->channels;
+        priv->curve_data->entry_size = sizeof(__le16) +
+                sizeof(*dst) * curve_data->points_per_channel;
+        priv->curve_data->offset = offsetof(struct pda_pa_curve_data, data);
+        priv->curve_data->len = cd_len;
+        memcpy(priv->curve_data->data, curve_data, sizeof(*curve_data));
         source = curve_data->data;
-        target = priv->curve_data->data;
+        target = ((struct pda_pa_curve_data *) priv->curve_data->data)->data;
         for (i = 0; i < curve_data->channels; i++) {
                 __le16 *freq = source;
                 source += sizeof(__le16);
@@ -406,6 +418,71 @@ static void p54_parse_default_country(struct ieee80211_hw *dev,
         }
 }
 
+static int p54_convert_output_limits(struct ieee80211_hw *dev,
+                                     u8 *data, size_t len)
+{
+        struct p54_common *priv = dev->priv;
+
+        if (len < 2)
+                return -EINVAL;
+
+        if (data[0] != 0) {
+                printk(KERN_ERR "%s: unknown output power db revision:%x\n",
+                       wiphy_name(dev->wiphy), data[0]);
+                return -EINVAL;
+        }
+
+        if (2 + data[1] * sizeof(struct pda_channel_output_limit) > len)
+                return -EINVAL;
+
+        priv->output_limit = kmalloc(data[1] *
+                sizeof(struct pda_channel_output_limit) +
+                sizeof(*priv->output_limit), GFP_KERNEL);
+
+        if (!priv->output_limit)
+                return -ENOMEM;
+
+        priv->output_limit->offset = 0;
+        priv->output_limit->entries = data[1];
+        priv->output_limit->entry_size =
+                sizeof(struct pda_channel_output_limit);
+        priv->output_limit->len = priv->output_limit->entry_size *
+                                  priv->output_limit->entries +
+                                  priv->output_limit->offset;
+
+        memcpy(priv->output_limit->data, &data[2],
+               data[1] * sizeof(struct pda_channel_output_limit));
+
+        return 0;
+}
+
+static struct p54_cal_database *p54_convert_db(struct pda_custom_wrapper *src,
+                                               size_t total_len)
+{
+        struct p54_cal_database *dst;
+        size_t payload_len, entries, entry_size, offset;
+
+        payload_len = le16_to_cpu(src->len);
+        entries = le16_to_cpu(src->entries);
+        entry_size = le16_to_cpu(src->entry_size);
+        offset = le16_to_cpu(src->offset);
+        if (((entries * entry_size + offset) != payload_len) ||
+             (payload_len + sizeof(*src) != total_len))
+                return NULL;
+
+        dst = kmalloc(sizeof(*dst) + payload_len, GFP_KERNEL);
+        if (!dst)
+                return NULL;
+
+        dst->entries = entries;
+        dst->entry_size = entry_size;
+        dst->offset = offset;
+        dst->len = payload_len;
+
+        memcpy(dst->data, src->data, payload_len);
+        return dst;
+}
+
 static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
 {
         struct p54_common *priv = dev->priv;
@@ -431,30 +508,17 @@ static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
 
                 switch (le16_to_cpu(entry->code)) {
                 case PDR_MAC_ADDRESS:
+                        if (data_len != ETH_ALEN)
+                                break;
                         SET_IEEE80211_PERM_ADDR(dev, entry->data);
                         break;
                 case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS:
-                        if (data_len < 2) {
-                                err = -EINVAL;
-                                goto err;
-                        }
-
-                        if (2 + entry->data[1]*sizeof(*priv->output_limit) > data_len) {
-                                err = -EINVAL;
-                                goto err;
-                        }
-
-                        priv->output_limit = kmalloc(entry->data[1] *
-                                sizeof(*priv->output_limit), GFP_KERNEL);
-
-                        if (!priv->output_limit) {
-                                err = -ENOMEM;
+                        if (priv->output_limit)
+                                break;
+                        err = p54_convert_output_limits(dev, entry->data,
+                                                        data_len);
+                        if (err)
                                 goto err;
-                        }
-
-                        memcpy(priv->output_limit, &entry->data[2],
-                               entry->data[1]*sizeof(*priv->output_limit));
-                        priv->output_limit_len = entry->data[1];
                         break;
                 case PDR_PRISM_PA_CAL_CURVE_DATA: {
                         struct pda_pa_curve_data *curve_data =
@@ -506,6 +570,8 @@ static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                         }
                         break;
                 case PDR_HARDWARE_PLATFORM_COMPONENT_ID:
+                        if (data_len < 2)
+                                break;
                         priv->version = *(u8 *)(entry->data + 1);
                         break;
                 case PDR_RSSI_LINEAR_APPROXIMATION:
@@ -514,6 +580,34 @@ static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                         p54_parse_rssical(dev, entry->data, data_len,
                                           le16_to_cpu(entry->code));
                         break;
+                case PDR_RSSI_LINEAR_APPROXIMATION_CUSTOM: {
+                        __le16 *src = (void *) entry->data;
+                        s16 *dst = (void *) &priv->rssical_db;
+                        int i;
+
+                        if (data_len != sizeof(priv->rssical_db)) {
+                                err = -EINVAL;
+                                goto err;
+                        }
+                        for (i = 0; i < sizeof(priv->rssical_db) /
+                                        sizeof(*src); i++)
+                                *(dst++) = (s16) le16_to_cpu(*(src++));
+                        }
+                        break;
+                case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS_CUSTOM: {
+                        struct pda_custom_wrapper *pda = (void *) entry->data;
+                        if (priv->output_limit || data_len < sizeof(*pda))
+                                break;
+                        priv->output_limit = p54_convert_db(pda, data_len);
+                        }
+                        break;
+                case PDR_PRISM_PA_CAL_CURVE_DATA_CUSTOM: {
+                        struct pda_custom_wrapper *pda = (void *) entry->data;
+                        if (priv->curve_data || data_len < sizeof(*pda))
+                                break;
+                        priv->curve_data = p54_convert_db(pda, data_len);
+                        }
+                        break;
                 case PDR_END:
                         /* make it overrun */
                         entry_len = len;
@@ -1624,8 +1718,8 @@ static int p54_scan(struct ieee80211_hw *dev, u16 mode, u16 dwell)
         struct p54_scan *chan;
         unsigned int i;
         void *entry;
-        __le16 freq = cpu_to_le16(dev->conf.channel->center_freq);
         int band = dev->conf.channel->band;
+        __le16 freq = cpu_to_le16(dev->conf.channel->center_freq);
 
         skb = p54_alloc_skb(dev, P54_HDR_FLAG_CONTROL_OPSET, sizeof(*chan),
                             P54_CONTROL_TYPE_SCAN, GFP_ATOMIC);
@@ -1633,7 +1727,7 @@ static int p54_scan(struct ieee80211_hw *dev, u16 mode, u16 dwell)
                 return -ENOMEM;
 
         chan = (struct p54_scan *) skb_put(skb, sizeof(*chan));
-        memset(chan->padding1, 0, sizeof(chan->padding1));
+        memset(chan->scan_params, 0, sizeof(chan->scan_params));
         chan->mode = cpu_to_le16(mode);
         chan->dwell = cpu_to_le16(dwell);
 
@@ -1648,41 +1742,45 @@ static int p54_scan(struct ieee80211_hw *dev, u16 mode, u16 dwell)
         if (i == priv->iq_autocal_len)
                 goto err;
 
-        for (i = 0; i < priv->output_limit_len; i++) {
-                if (priv->output_limit[i].freq != freq)
+        for (i = 0; i < priv->output_limit->entries; i++) {
+                struct pda_channel_output_limit *limits;
+                __le16 *entry_freq = (void *) (priv->output_limit->data +
+                        priv->output_limit->entry_size * i);
+
+                if (*entry_freq != freq)
                         continue;
 
+                limits = (void *) entry_freq;
                 chan->val_barker = 0x38;
-                chan->val_bpsk = chan->dup_bpsk =
-                        priv->output_limit[i].val_bpsk;
-                chan->val_qpsk = chan->dup_qpsk =
-                        priv->output_limit[i].val_qpsk;
-                chan->val_16qam = chan->dup_16qam =
-                        priv->output_limit[i].val_16qam;
-                chan->val_64qam = chan->dup_64qam =
-                        priv->output_limit[i].val_64qam;
+                chan->val_bpsk = chan->dup_bpsk = limits->val_bpsk;
+                chan->val_qpsk = chan->dup_qpsk = limits->val_qpsk;
+                chan->val_16qam = chan->dup_16qam = limits->val_16qam;
+                chan->val_64qam = chan->dup_64qam = limits->val_64qam;
                 break;
         }
-        if (i == priv->output_limit_len)
+        if (i == priv->output_limit->entries)
                 goto err;
 
-        entry = priv->curve_data->data;
-        for (i = 0; i < priv->curve_data->channels; i++) {
+        entry = (void *)(priv->curve_data->data + priv->curve_data->offset);
+        for (i = 0; i < priv->curve_data->entries; i++) {
+                struct pda_pa_curve_data *curve_data;
                 if (*((__le16 *)entry) != freq) {
-                        entry += sizeof(__le16);
-                        entry += sizeof(struct p54_pa_curve_data_sample) *
-                                 priv->curve_data->points_per_channel;
+                        entry += priv->curve_data->entry_size;
                         continue;
                 }
 
                 entry += sizeof(__le16);
                 chan->pa_points_per_curve = 8;
                 memset(chan->curve_data, 0, sizeof(*chan->curve_data));
+                curve_data = (void *) priv->curve_data->data;
+
                 memcpy(chan->curve_data, entry,
                        sizeof(struct p54_pa_curve_data_sample) *
-                       min((u8)8, priv->curve_data->points_per_channel));
+                       min_t(u8, 8, curve_data->points_per_channel));
                 break;
         }
+        if (i == priv->curve_data->entries)
+                goto err;
 
         if (priv->fw_var < 0x500) {
                 chan->v1_rssi.mul = cpu_to_le16(priv->rssical_db[band].mul);