1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63#include <linux/firmware.h>
64#include "iwl-trans.h"
65#include "mvm.h"
66#include "iwl-eeprom-parse.h"
67#include "iwl-eeprom-read.h"
68#include "iwl-nvm-parse.h"
69
70
71static const int nvm_to_read[] = {
72 NVM_SECTION_TYPE_HW,
73 NVM_SECTION_TYPE_SW,
74 NVM_SECTION_TYPE_CALIBRATION,
75 NVM_SECTION_TYPE_PRODUCTION,
76};
77
78
79#define IWL_NVM_DEFAULT_CHUNK_SIZE (2*1024)
80#define IWL_MAX_NVM_SECTION_SIZE 6000
81
82#define NVM_WRITE_OPCODE 1
83#define NVM_READ_OPCODE 0
84
85
86
87
88
89static int iwl_nvm_write_chunk(struct iwl_mvm *mvm, u16 section,
90 u16 offset, u16 length, const u8 *data)
91{
92 struct iwl_nvm_access_cmd nvm_access_cmd = {
93 .offset = cpu_to_le16(offset),
94 .length = cpu_to_le16(length),
95 .type = cpu_to_le16(section),
96 .op_code = NVM_WRITE_OPCODE,
97 };
98 struct iwl_host_cmd cmd = {
99 .id = NVM_ACCESS_CMD,
100 .len = { sizeof(struct iwl_nvm_access_cmd), length },
101 .flags = CMD_SYNC | CMD_SEND_IN_RFKILL,
102 .data = { &nvm_access_cmd, data },
103
104 .dataflags = { 0, IWL_HCMD_DFL_DUP },
105 };
106
107 return iwl_mvm_send_cmd(mvm, &cmd);
108}
109
110static int iwl_nvm_read_chunk(struct iwl_mvm *mvm, u16 section,
111 u16 offset, u16 length, u8 *data)
112{
113 struct iwl_nvm_access_cmd nvm_access_cmd = {
114 .offset = cpu_to_le16(offset),
115 .length = cpu_to_le16(length),
116 .type = cpu_to_le16(section),
117 .op_code = NVM_READ_OPCODE,
118 };
119 struct iwl_nvm_access_resp *nvm_resp;
120 struct iwl_rx_packet *pkt;
121 struct iwl_host_cmd cmd = {
122 .id = NVM_ACCESS_CMD,
123 .flags = CMD_SYNC | CMD_WANT_SKB | CMD_SEND_IN_RFKILL,
124 .data = { &nvm_access_cmd, },
125 };
126 int ret, bytes_read, offset_read;
127 u8 *resp_data;
128
129 cmd.len[0] = sizeof(struct iwl_nvm_access_cmd);
130
131 ret = iwl_mvm_send_cmd(mvm, &cmd);
132 if (ret)
133 return ret;
134
135 pkt = cmd.resp_pkt;
136 if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
137 IWL_ERR(mvm, "Bad return from NVM_ACCES_COMMAND (0x%08X)\n",
138 pkt->hdr.flags);
139 ret = -EIO;
140 goto exit;
141 }
142
143
144 nvm_resp = (void *)pkt->data;
145 ret = le16_to_cpu(nvm_resp->status);
146 bytes_read = le16_to_cpu(nvm_resp->length);
147 offset_read = le16_to_cpu(nvm_resp->offset);
148 resp_data = nvm_resp->data;
149 if (ret) {
150 IWL_ERR(mvm,
151 "NVM access command failed with status %d (device: %s)\n",
152 ret, mvm->cfg->name);
153 ret = -EINVAL;
154 goto exit;
155 }
156
157 if (offset_read != offset) {
158 IWL_ERR(mvm, "NVM ACCESS response with invalid offset %d\n",
159 offset_read);
160 ret = -EINVAL;
161 goto exit;
162 }
163
164
165 memcpy(data + offset, resp_data, bytes_read);
166 ret = bytes_read;
167
168exit:
169 iwl_free_resp(&cmd);
170 return ret;
171}
172
173static int iwl_nvm_write_section(struct iwl_mvm *mvm, u16 section,
174 const u8 *data, u16 length)
175{
176 int offset = 0;
177
178
179
180 while (offset < length) {
181 int chunk_size, ret;
182
183 chunk_size = min(IWL_NVM_DEFAULT_CHUNK_SIZE,
184 length - offset);
185
186 ret = iwl_nvm_write_chunk(mvm, section, offset,
187 chunk_size, data + offset);
188 if (ret < 0)
189 return ret;
190
191 offset += chunk_size;
192 }
193
194 return 0;
195}
196
197
198
199
200
201
202
203
204
205
206
207static int iwl_nvm_read_section(struct iwl_mvm *mvm, u16 section,
208 u8 *data)
209{
210 u16 length, offset = 0;
211 int ret;
212
213
214 length = IWL_NVM_DEFAULT_CHUNK_SIZE;
215
216 ret = length;
217
218
219 while (ret == length) {
220 ret = iwl_nvm_read_chunk(mvm, section, offset, length, data);
221 if (ret < 0) {
222 IWL_ERR(mvm,
223 "Cannot read NVM from section %d offset %d, length %d\n",
224 section, offset, length);
225 return ret;
226 }
227 offset += ret;
228 }
229
230 IWL_DEBUG_EEPROM(mvm->trans->dev,
231 "NVM section %d read completed\n", section);
232 return offset;
233}
234
235static struct iwl_nvm_data *
236iwl_parse_nvm_sections(struct iwl_mvm *mvm)
237{
238 struct iwl_nvm_section *sections = mvm->nvm_sections;
239 const __le16 *hw, *sw, *calib;
240
241
242 if (!mvm->nvm_sections[NVM_SECTION_TYPE_SW].data ||
243 !mvm->nvm_sections[NVM_SECTION_TYPE_HW].data) {
244 IWL_ERR(mvm, "Can't parse empty NVM sections\n");
245 return NULL;
246 }
247
248 if (WARN_ON(!mvm->cfg))
249 return NULL;
250
251 hw = (const __le16 *)sections[NVM_SECTION_TYPE_HW].data;
252 sw = (const __le16 *)sections[NVM_SECTION_TYPE_SW].data;
253 calib = (const __le16 *)sections[NVM_SECTION_TYPE_CALIBRATION].data;
254 return iwl_parse_nvm_data(mvm->trans->dev, mvm->cfg, hw, sw, calib,
255 iwl_fw_valid_tx_ant(mvm->fw),
256 iwl_fw_valid_rx_ant(mvm->fw));
257}
258
259#define MAX_NVM_FILE_LEN 16384
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280static int iwl_mvm_load_external_nvm(struct iwl_mvm *mvm)
281{
282 int ret, section_id, section_size;
283 const struct firmware *fw_entry;
284 const struct {
285 __le16 word1;
286 __le16 word2;
287 u8 data[];
288 } *file_sec;
289 const u8 *eof;
290
291#define NVM_WORD1_LEN(x) (8 * (x & 0x03FF))
292#define NVM_WORD2_ID(x) (x >> 12)
293
294
295
296
297
298
299
300 ret = request_firmware(&fw_entry, iwlwifi_mod_params.nvm_file,
301 mvm->trans->dev);
302 if (ret) {
303 IWL_ERR(mvm, "ERROR: %s isn't available %d\n",
304 iwlwifi_mod_params.nvm_file, ret);
305 return ret;
306 }
307
308 IWL_INFO(mvm, "Loaded NVM file %s (%zu bytes)\n",
309 iwlwifi_mod_params.nvm_file, fw_entry->size);
310
311 if (fw_entry->size < sizeof(*file_sec)) {
312 IWL_ERR(mvm, "NVM file too small\n");
313 ret = -EINVAL;
314 goto out;
315 }
316
317 if (fw_entry->size > MAX_NVM_FILE_LEN) {
318 IWL_ERR(mvm, "NVM file too large\n");
319 ret = -EINVAL;
320 goto out;
321 }
322
323 eof = fw_entry->data + fw_entry->size;
324
325 file_sec = (void *)fw_entry->data;
326
327 while (true) {
328 if (file_sec->data > eof) {
329 IWL_ERR(mvm,
330 "ERROR - NVM file too short for section header\n");
331 ret = -EINVAL;
332 break;
333 }
334
335
336 if (!file_sec->word1 && !file_sec->word2) {
337 ret = 0;
338 break;
339 }
340
341 section_size = 2 * NVM_WORD1_LEN(le16_to_cpu(file_sec->word1));
342 section_id = NVM_WORD2_ID(le16_to_cpu(file_sec->word2));
343
344 if (section_size > IWL_MAX_NVM_SECTION_SIZE) {
345 IWL_ERR(mvm, "ERROR - section too large (%d)\n",
346 section_size);
347 ret = -EINVAL;
348 break;
349 }
350
351 if (!section_size) {
352 IWL_ERR(mvm, "ERROR - section empty\n");
353 ret = -EINVAL;
354 break;
355 }
356
357 if (file_sec->data + section_size > eof) {
358 IWL_ERR(mvm,
359 "ERROR - NVM file too short for section (%d bytes)\n",
360 section_size);
361 ret = -EINVAL;
362 break;
363 }
364
365 ret = iwl_nvm_write_section(mvm, section_id, file_sec->data,
366 section_size);
367 if (ret < 0) {
368 IWL_ERR(mvm, "iwl_mvm_send_cmd failed: %d\n", ret);
369 break;
370 }
371
372
373 file_sec = (void *)(file_sec->data + section_size);
374 }
375out:
376 release_firmware(fw_entry);
377 return ret;
378}
379
380int iwl_nvm_init(struct iwl_mvm *mvm)
381{
382 int ret, i, section;
383 u8 *nvm_buffer, *temp;
384
385
386 if (iwlwifi_mod_params.nvm_file) {
387
388 ret = iwl_mvm_load_external_nvm(mvm);
389 if (ret)
390 return ret;
391 }
392
393
394 IWL_DEBUG_EEPROM(mvm->trans->dev, "Read from NVM\n");
395
396
397 nvm_buffer = kmalloc(mvm->cfg->base_params->eeprom_size,
398 GFP_KERNEL);
399 if (!nvm_buffer)
400 return -ENOMEM;
401 for (i = 0; i < ARRAY_SIZE(nvm_to_read); i++) {
402 section = nvm_to_read[i];
403
404 ret = iwl_nvm_read_section(mvm, section, nvm_buffer);
405 if (ret < 0)
406 break;
407 temp = kmemdup(nvm_buffer, ret, GFP_KERNEL);
408 if (!temp) {
409 ret = -ENOMEM;
410 break;
411 }
412 mvm->nvm_sections[section].data = temp;
413 mvm->nvm_sections[section].length = ret;
414 }
415 kfree(nvm_buffer);
416 if (ret < 0)
417 return ret;
418
419 mvm->nvm_data = iwl_parse_nvm_sections(mvm);
420 if (!mvm->nvm_data)
421 return -ENODATA;
422
423 return 0;
424}
425