← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/net/wireless/iwmc3200wifi/eeprom.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
#include <linux/slab.h>
 
41
 
 
42
#include "iwm.h"
 
43
#include "umac.h"
 
44
#include "commands.h"
 
45
#include "eeprom.h"
 
46
 
 
47
static struct iwm_eeprom_entry eeprom_map[] = {
 
48
        [IWM_EEPROM_SIG] =
 
49
        {"Signature", IWM_EEPROM_SIG_OFF, IWM_EEPROM_SIG_LEN},
 
50
 
 
51
        [IWM_EEPROM_VERSION] =
 
52
        {"Version", IWM_EEPROM_VERSION_OFF, IWM_EEPROM_VERSION_LEN},
 
53
 
 
54
        [IWM_EEPROM_OEM_HW_VERSION] =
 
55
        {"OEM HW version", IWM_EEPROM_OEM_HW_VERSION_OFF,
 
56
         IWM_EEPROM_OEM_HW_VERSION_LEN},
 
57
 
 
58
        [IWM_EEPROM_MAC_VERSION] =
 
59
        {"MAC version", IWM_EEPROM_MAC_VERSION_OFF, IWM_EEPROM_MAC_VERSION_LEN},
 
60
 
 
61
        [IWM_EEPROM_CARD_ID] =
 
62
        {"Card ID", IWM_EEPROM_CARD_ID_OFF, IWM_EEPROM_CARD_ID_LEN},
 
63
 
 
64
        [IWM_EEPROM_RADIO_CONF] =
 
65
        {"Radio config", IWM_EEPROM_RADIO_CONF_OFF, IWM_EEPROM_RADIO_CONF_LEN},
 
66
 
 
67
        [IWM_EEPROM_SKU_CAP] =
 
68
        {"SKU capabilities", IWM_EEPROM_SKU_CAP_OFF, IWM_EEPROM_SKU_CAP_LEN},
 
69
 
 
70
        [IWM_EEPROM_FAT_CHANNELS_CAP] =
 
71
        {"HT channels capabilities", IWM_EEPROM_FAT_CHANNELS_CAP_OFF,
 
72
         IWM_EEPROM_FAT_CHANNELS_CAP_LEN},
 
73
 
 
74
        [IWM_EEPROM_CALIB_RXIQ_OFFSET] =
 
75
        {"RX IQ offset", IWM_EEPROM_CALIB_RXIQ_OFF, IWM_EEPROM_INDIRECT_LEN},
 
76
 
 
77
        [IWM_EEPROM_CALIB_RXIQ] =
 
78
        {"Calib RX IQ", 0, IWM_EEPROM_CALIB_RXIQ_LEN},
 
79
};
 
80
 
 
81
 
 
82
static int iwm_eeprom_read(struct iwm_priv *iwm, u8 eeprom_id)
 
83
{
 
84
        int ret;
 
85
        u32 entry_size, chunk_size, data_offset = 0, addr_offset = 0;
 
86
        u32 addr;
 
87
        struct iwm_udma_wifi_cmd udma_cmd;
 
88
        struct iwm_umac_cmd umac_cmd;
 
89
        struct iwm_umac_cmd_eeprom_proxy eeprom_cmd;
 
90
 
 
91
        if (eeprom_id > (IWM_EEPROM_LAST - 1))
 
92
                return -EINVAL;
 
93
 
 
94
        entry_size = eeprom_map[eeprom_id].length;
 
95
 
 
96
        if (eeprom_id >= IWM_EEPROM_INDIRECT_DATA) {
 
97
                /* indirect data */
 
98
                u32 off_id = eeprom_id - IWM_EEPROM_INDIRECT_DATA +
 
99
                             IWM_EEPROM_INDIRECT_OFFSET;
 
100
 
 
101
                eeprom_map[eeprom_id].offset =
 
102
                        *(u16 *)(iwm->eeprom + eeprom_map[off_id].offset) << 1;
 
103
        }
 
104
 
 
105
        addr = eeprom_map[eeprom_id].offset;
 
106
 
 
107
        udma_cmd.eop = 1;
 
108
        udma_cmd.credit_group = 0x4;
 
109
        udma_cmd.ra_tid = UMAC_HDI_ACT_TBL_IDX_HOST_CMD;
 
110
        udma_cmd.lmac_offset = 0;
 
111
 
 
112
        umac_cmd.id = UMAC_CMD_OPCODE_EEPROM_PROXY;
 
113
        umac_cmd.resp = 1;
 
114
 
 
115
        while (entry_size > 0) {
 
116
                chunk_size = min_t(u32, entry_size, IWM_MAX_EEPROM_DATA_LEN);
 
117
 
 
118
                eeprom_cmd.hdr.type =
 
119
                        cpu_to_le32(IWM_UMAC_CMD_EEPROM_TYPE_READ);
 
120
                eeprom_cmd.hdr.offset = cpu_to_le32(addr + addr_offset);
 
121
                eeprom_cmd.hdr.len = cpu_to_le32(chunk_size);
 
122
 
 
123
                ret = iwm_hal_send_umac_cmd(iwm, &udma_cmd,
 
124
                                            &umac_cmd, &eeprom_cmd,
 
125
                                     sizeof(struct iwm_umac_cmd_eeprom_proxy));
 
126
                if (ret < 0) {
 
127
                        IWM_ERR(iwm, "Couldn't read eeprom\n");
 
128
                        return ret;
 
129
                }
 
130
 
 
131
                ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_EEPROM_PROXY,
 
132
                                       IWM_SRC_UMAC, 2*HZ);
 
133
                if (ret < 0) {
 
134
                        IWM_ERR(iwm, "Did not get any eeprom answer\n");
 
135
                        return ret;
 
136
                }
 
137
 
 
138
                data_offset += chunk_size;
 
139
                addr_offset += chunk_size;
 
140
                entry_size -= chunk_size;
 
141
        }
 
142
 
 
143
        return 0;
 
144
}
 
145
 
 
146
u8 *iwm_eeprom_access(struct iwm_priv *iwm, u8 eeprom_id)
 
147
{
 
148
        if (!iwm->eeprom)
 
149
                return ERR_PTR(-ENODEV);
 
150
 
 
151
        return iwm->eeprom + eeprom_map[eeprom_id].offset;
 
152
}
 
153
 
 
154
int iwm_eeprom_fat_channels(struct iwm_priv *iwm)
 
155
{
 
156
        struct wiphy *wiphy = iwm_to_wiphy(iwm);
 
157
        struct ieee80211_supported_band *band;
 
158
        u16 *channels, i;
 
159
 
 
160
        channels = (u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_FAT_CHANNELS_CAP);
 
161
        if (IS_ERR(channels))
 
162
                return PTR_ERR(channels);
 
163
 
 
164
        band = wiphy->bands[IEEE80211_BAND_2GHZ];
 
165
        band->ht_cap.ht_supported = true;
 
166
 
 
167
        for (i = 0; i < IWM_EEPROM_FAT_CHANNELS_24; i++)
 
168
                if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
 
169
                        band->ht_cap.ht_supported = false;
 
170
 
 
171
        band = wiphy->bands[IEEE80211_BAND_5GHZ];
 
172
        band->ht_cap.ht_supported = true;
 
173
        for (i = IWM_EEPROM_FAT_CHANNELS_24; i < IWM_EEPROM_FAT_CHANNELS; i++)
 
174
                if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
 
175
                        band->ht_cap.ht_supported = false;
 
176
 
 
177
        return 0;
 
178
}
 
179
 
 
180
u32 iwm_eeprom_wireless_mode(struct iwm_priv *iwm)
 
181
{
 
182
        u16 sku_cap;
 
183
        u32 wireless_mode = 0;
 
184
 
 
185
        sku_cap = *((u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_SKU_CAP));
 
186
 
 
187
        if (sku_cap & IWM_EEPROM_SKU_CAP_BAND_24GHZ)
 
188
                wireless_mode |= WIRELESS_MODE_11G;
 
189
 
 
190
        if (sku_cap & IWM_EEPROM_SKU_CAP_BAND_52GHZ)
 
191
                wireless_mode |= WIRELESS_MODE_11A;
 
192
 
 
193
        if (sku_cap & IWM_EEPROM_SKU_CAP_11N_ENABLE)
 
194
                wireless_mode |= WIRELESS_MODE_11N;
 
195
 
 
196
        return wireless_mode;
 
197
}
 
198
 
 
199
 
 
200
int iwm_eeprom_init(struct iwm_priv *iwm)
 
201
{
 
202
        int i, ret = 0;
 
203
        char name[32];
 
204
 
 
205
        iwm->eeprom = kzalloc(IWM_EEPROM_LEN, GFP_KERNEL);
 
206
        if (!iwm->eeprom)
 
207
                return -ENOMEM;
 
208
 
 
209
        for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
 
210
                ret = iwm_eeprom_read(iwm, i);
 
211
                if (ret < 0) {
 
212
                        IWM_ERR(iwm, "Couldn't read eeprom entry #%d: %s\n",
 
213
                                i, eeprom_map[i].name);
 
214
                        break;
 
215
                }
 
216
        }
 
217
 
 
218
        IWM_DBG_BOOT(iwm, DBG, "EEPROM dump:\n");
 
219
        for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
 
220
                memset(name, 0, 32);
 
221
                sprintf(name, "%s: ", eeprom_map[i].name);
 
222
 
 
223
                IWM_HEXDUMP(iwm, DBG, BOOT, name,
 
224
                            iwm->eeprom + eeprom_map[i].offset,
 
225
                            eeprom_map[i].length);
 
226
        }
 
227
 
 
228
        return ret;
 
229
}
 
230
 
 
231
void iwm_eeprom_exit(struct iwm_priv *iwm)
 
232
{
 
233
        kfree(iwm->eeprom);
 
234
}