drivers/net/wireless/iwmc3200wifi/eeprom.c

   1 /*
   2  * Intel Wireless Multicomm 3200 WiFi driver
   3  *
   4  * Copyright (C) 2009 Intel Corporation. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  *   * Redistributions of source code must retain the above copyright
  11  *     notice, this list of conditions and the following disclaimer.
  12  *   * Redistributions in binary form must reproduce the above copyright
  13  *     notice, this list of conditions and the following disclaimer in
  14  *     the documentation and/or other materials provided with the
  15  *     distribution.
  16  *   * Neither the name of Intel Corporation nor the names of its
  17  *     contributors may be used to endorse or promote products derived
  18  *     from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  *
  33  * Intel Corporation <ilw@linux.intel.com>
  34  * Samuel Ortiz <samuel.ortiz@intel.com>
  35  * Zhu Yi <yi.zhu@intel.com>
  36  *
  37  */
  38
  39 #include <linux/kernel.h>
  40
  41 #include "iwm.h"
  42 #include "umac.h"
  43 #include "commands.h"
  44 #include "eeprom.h"
  45
  46 static struct iwm_eeprom_entry eeprom_map[] = {
  47         [IWM_EEPROM_SIG] =
  48         {"Signature", IWM_EEPROM_SIG_OFF, IWM_EEPROM_SIG_LEN},
  49
  50         [IWM_EEPROM_VERSION] =
  51         {"Version", IWM_EEPROM_VERSION_OFF, IWM_EEPROM_VERSION_LEN},
  52
  53         [IWM_EEPROM_OEM_HW_VERSION] =
  54         {"OEM HW version", IWM_EEPROM_OEM_HW_VERSION_OFF,
  55          IWM_EEPROM_OEM_HW_VERSION_LEN},
  56
  57         [IWM_EEPROM_MAC_VERSION] =
  58         {"MAC version", IWM_EEPROM_MAC_VERSION_OFF, IWM_EEPROM_MAC_VERSION_LEN},
  59
  60         [IWM_EEPROM_CARD_ID] =
  61         {"Card ID", IWM_EEPROM_CARD_ID_OFF, IWM_EEPROM_CARD_ID_LEN},
  62
  63         [IWM_EEPROM_RADIO_CONF] =
  64         {"Radio config", IWM_EEPROM_RADIO_CONF_OFF, IWM_EEPROM_RADIO_CONF_LEN},
  65
  66         [IWM_EEPROM_SKU_CAP] =
  67         {"SKU capabilities", IWM_EEPROM_SKU_CAP_OFF, IWM_EEPROM_SKU_CAP_LEN},
  68
  69         [IWM_EEPROM_FAT_CHANNELS_CAP] =
  70         {"HT channels capabilities", IWM_EEPROM_FAT_CHANNELS_CAP_OFF,
  71          IWM_EEPROM_FAT_CHANNELS_CAP_LEN},
  72
  73         [IWM_EEPROM_CALIB_RXIQ_OFFSET] =
  74         {"RX IQ offset", IWM_EEPROM_CALIB_RXIQ_OFF, IWM_EEPROM_INDIRECT_LEN},
  75
  76         [IWM_EEPROM_CALIB_RXIQ] =
  77         {"Calib RX IQ", 0, IWM_EEPROM_CALIB_RXIQ_LEN},
  78 };
  79
  80
  81 static int iwm_eeprom_read(struct iwm_priv *iwm, u8 eeprom_id)
  82 {
  83         int ret;
  84         u32 entry_size, chunk_size, data_offset = 0, addr_offset = 0;
  85         u32 addr;
  86         struct iwm_udma_wifi_cmd udma_cmd;
  87         struct iwm_umac_cmd umac_cmd;
  88         struct iwm_umac_cmd_eeprom_proxy eeprom_cmd;
  89
  90         if (eeprom_id > (IWM_EEPROM_LAST - 1))
  91                 return -EINVAL;
  92
  93         entry_size = eeprom_map[eeprom_id].length;
  94
  95         if (eeprom_id >= IWM_EEPROM_INDIRECT_DATA) {
  96                 /* indirect data */
  97                 u32 off_id = eeprom_id - IWM_EEPROM_INDIRECT_DATA +
  98                              IWM_EEPROM_INDIRECT_OFFSET;
  99
 100                 eeprom_map[eeprom_id].offset =
 101                         *(u16 *)(iwm->eeprom + eeprom_map[off_id].offset) << 1;
 102         }
 103
 104         addr = eeprom_map[eeprom_id].offset;
 105
 106         udma_cmd.eop = 1;
 107         udma_cmd.credit_group = 0x4;
 108         udma_cmd.ra_tid = UMAC_HDI_ACT_TBL_IDX_HOST_CMD;
 109         udma_cmd.lmac_offset = 0;
 110
 111         umac_cmd.id = UMAC_CMD_OPCODE_EEPROM_PROXY;
 112         umac_cmd.resp = 1;
 113
 114         while (entry_size > 0) {
 115                 chunk_size = min_t(u32, entry_size, IWM_MAX_EEPROM_DATA_LEN);
 116
 117                 eeprom_cmd.hdr.type =
 118                         cpu_to_le32(IWM_UMAC_CMD_EEPROM_TYPE_READ);
 119                 eeprom_cmd.hdr.offset = cpu_to_le32(addr + addr_offset);
 120                 eeprom_cmd.hdr.len = cpu_to_le32(chunk_size);
 121
 122                 ret = iwm_hal_send_umac_cmd(iwm, &udma_cmd,
 123                                             &umac_cmd, &eeprom_cmd,
 124                                      sizeof(struct iwm_umac_cmd_eeprom_proxy));
 125                 if (ret < 0) {
 126                         IWM_ERR(iwm, "Couldn't read eeprom\n");
 127                         return ret;
 128                 }
 129
 130                 ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_EEPROM_PROXY,
 131                                        IWM_SRC_UMAC, 2*HZ);
 132                 if (ret < 0) {
 133                         IWM_ERR(iwm, "Did not get any eeprom answer\n");
 134                         return ret;
 135                 }
 136
 137                 data_offset += chunk_size;
 138                 addr_offset += chunk_size;
 139                 entry_size -= chunk_size;
 140         }
 141
 142         return 0;
 143 }
 144
 145 u8 *iwm_eeprom_access(struct iwm_priv *iwm, u8 eeprom_id)
 146 {
 147         if (!iwm->eeprom)
 148                 return ERR_PTR(-ENODEV);
 149
 150         return iwm->eeprom + eeprom_map[eeprom_id].offset;
 151 }
 152
 153 int iwm_eeprom_fat_channels(struct iwm_priv *iwm)
 154 {
 155         struct wiphy *wiphy = iwm_to_wiphy(iwm);
 156         struct ieee80211_supported_band *band;
 157         u16 *channels, i;
 158
 159         channels = (u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_FAT_CHANNELS_CAP);
 160         if (IS_ERR(channels))
 161                 return PTR_ERR(channels);
 162
 163         band = wiphy->bands[IEEE80211_BAND_2GHZ];
 164         band->ht_cap.ht_supported = true;
 165
 166         for (i = 0; i < IWM_EEPROM_FAT_CHANNELS_24; i++)
 167                 if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
 168                         band->ht_cap.ht_supported = false;
 169
 170         band = wiphy->bands[IEEE80211_BAND_5GHZ];
 171         band->ht_cap.ht_supported = true;
 172         for (i = IWM_EEPROM_FAT_CHANNELS_24; i < IWM_EEPROM_FAT_CHANNELS; i++)
 173                 if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
 174                         band->ht_cap.ht_supported = false;
 175
 176         return 0;
 177 }
 178
 179 u32 iwm_eeprom_wireless_mode(struct iwm_priv *iwm)
 180 {
 181         u16 sku_cap;
 182         u32 wireless_mode = 0;
 183
 184         sku_cap = *((u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_SKU_CAP));
 185
 186         if (sku_cap & IWM_EEPROM_SKU_CAP_BAND_24GHZ)
 187                 wireless_mode |= WIRELESS_MODE_11G;
 188
 189         if (sku_cap & IWM_EEPROM_SKU_CAP_BAND_52GHZ)
 190                 wireless_mode |= WIRELESS_MODE_11A;
 191
 192         if (sku_cap & IWM_EEPROM_SKU_CAP_11N_ENABLE)
 193                 wireless_mode |= WIRELESS_MODE_11N;
 194
 195         return wireless_mode;
 196 }
 197
 198
 199 int iwm_eeprom_init(struct iwm_priv *iwm)
 200 {
 201         int i, ret = 0;
 202         char name[32];
 203
 204         iwm->eeprom = kzalloc(IWM_EEPROM_LEN, GFP_KERNEL);
 205         if (!iwm->eeprom)
 206                 return -ENOMEM;
 207
 208         for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
 209                 ret = iwm_eeprom_read(iwm, i);
 210                 if (ret < 0) {
 211                         IWM_ERR(iwm, "Couldn't read eeprom entry #%d: %s\n",
 212                                 i, eeprom_map[i].name);
 213                         break;
 214                 }
 215         }
 216
 217         IWM_DBG_BOOT(iwm, DBG, "EEPROM dump:\n");
 218         for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
 219                 memset(name, 0, 32);
 220                 sprintf(name, "%s: ", eeprom_map[i].name);
 221
 222                 IWM_HEXDUMP(iwm, DBG, BOOT, name,
 223                             iwm->eeprom + eeprom_map[i].offset,
 224                             eeprom_map[i].length);
 225         }
 226
 227         return ret;
 228 }
 229
 230 void iwm_eeprom_exit(struct iwm_priv *iwm)
 231 {
 232         kfree(iwm->eeprom);
 233 }