projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
iwlwifi: move uCode flags handling to op_mode
[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-ucode.c
1 /******************************************************************************
2 *
3 * GPL LICENSE SUMMARY
4 *
5 * Copyright(c) 2008 - 2012 Intel Corporation. All rights reserved.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
19 * USA
20 *
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
23 *
24 * Contact Information:
25 * Intel Linux Wireless <ilw@linux.intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *
28 *****************************************************************************/
29
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/sched.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/firmware.h>
36
37 #include "iwl-ucode.h"
38 #include "iwl-wifi.h"
39 #include "iwl-dev.h"
40 #include "iwl-core.h"
41 #include "iwl-io.h"
42 #include "iwl-agn-hw.h"
43 #include "iwl-agn.h"
44 #include "iwl-agn-calib.h"
45 #include "iwl-trans.h"
46 #include "iwl-fh.h"
47
48 static struct iwl_wimax_coex_event_entry cu_priorities[COEX_NUM_OF_EVENTS] = {
49 {COEX_CU_UNASSOC_IDLE_RP, COEX_CU_UNASSOC_IDLE_WP,
50 0, COEX_UNASSOC_IDLE_FLAGS},
51 {COEX_CU_UNASSOC_MANUAL_SCAN_RP, COEX_CU_UNASSOC_MANUAL_SCAN_WP,
52 0, COEX_UNASSOC_MANUAL_SCAN_FLAGS},
53 {COEX_CU_UNASSOC_AUTO_SCAN_RP, COEX_CU_UNASSOC_AUTO_SCAN_WP,
54 0, COEX_UNASSOC_AUTO_SCAN_FLAGS},
55 {COEX_CU_CALIBRATION_RP, COEX_CU_CALIBRATION_WP,
56 0, COEX_CALIBRATION_FLAGS},
57 {COEX_CU_PERIODIC_CALIBRATION_RP, COEX_CU_PERIODIC_CALIBRATION_WP,
58 0, COEX_PERIODIC_CALIBRATION_FLAGS},
59 {COEX_CU_CONNECTION_ESTAB_RP, COEX_CU_CONNECTION_ESTAB_WP,
60 0, COEX_CONNECTION_ESTAB_FLAGS},
61 {COEX_CU_ASSOCIATED_IDLE_RP, COEX_CU_ASSOCIATED_IDLE_WP,
62 0, COEX_ASSOCIATED_IDLE_FLAGS},
63 {COEX_CU_ASSOC_MANUAL_SCAN_RP, COEX_CU_ASSOC_MANUAL_SCAN_WP,
64 0, COEX_ASSOC_MANUAL_SCAN_FLAGS},
65 {COEX_CU_ASSOC_AUTO_SCAN_RP, COEX_CU_ASSOC_AUTO_SCAN_WP,
66 0, COEX_ASSOC_AUTO_SCAN_FLAGS},
67 {COEX_CU_ASSOC_ACTIVE_LEVEL_RP, COEX_CU_ASSOC_ACTIVE_LEVEL_WP,
68 0, COEX_ASSOC_ACTIVE_LEVEL_FLAGS},
69 {COEX_CU_RF_ON_RP, COEX_CU_RF_ON_WP, 0, COEX_CU_RF_ON_FLAGS},
70 {COEX_CU_RF_OFF_RP, COEX_CU_RF_OFF_WP, 0, COEX_RF_OFF_FLAGS},
71 {COEX_CU_STAND_ALONE_DEBUG_RP, COEX_CU_STAND_ALONE_DEBUG_WP,
72 0, COEX_STAND_ALONE_DEBUG_FLAGS},
73 {COEX_CU_IPAN_ASSOC_LEVEL_RP, COEX_CU_IPAN_ASSOC_LEVEL_WP,
74 0, COEX_IPAN_ASSOC_LEVEL_FLAGS},
75 {COEX_CU_RSRVD1_RP, COEX_CU_RSRVD1_WP, 0, COEX_RSRVD1_FLAGS},
76 {COEX_CU_RSRVD2_RP, COEX_CU_RSRVD2_WP, 0, COEX_RSRVD2_FLAGS}
77 };
78
79 /******************************************************************************
80 *
81 * uCode download functions
82 *
83 ******************************************************************************/
84
85 static void iwl_free_fw_desc(struct iwl_nic *nic, struct fw_desc *desc)
86 {
87 if (desc->v_addr)
88 dma_free_coherent(trans(nic)->dev, desc->len,
89 desc->v_addr, desc->p_addr);
90 desc->v_addr = NULL;
91 desc->len = 0;
92 }
93
94 static void iwl_free_fw_img(struct iwl_nic *nic, struct fw_img *img)
95 {
96 iwl_free_fw_desc(nic, &img->code);
97 iwl_free_fw_desc(nic, &img->data);
98 }
99
100 void iwl_dealloc_ucode(struct iwl_nic *nic)
101 {
102 iwl_free_fw_img(nic, &nic->fw.ucode_rt);
103 iwl_free_fw_img(nic, &nic->fw.ucode_init);
104 iwl_free_fw_img(nic, &nic->fw.ucode_wowlan);
105 }
106
107 static int iwl_alloc_fw_desc(struct iwl_nic *nic, struct fw_desc *desc,
108 const void *data, size_t len)
109 {
110 if (!len) {
111 desc->v_addr = NULL;
112 return -EINVAL;
113 }
114
115 desc->v_addr = dma_alloc_coherent(trans(nic)->dev, len,
116 &desc->p_addr, GFP_KERNEL);
117 if (!desc->v_addr)
118 return -ENOMEM;
119
120 desc->len = len;
121 memcpy(desc->v_addr, data, len);
122 return 0;
123 }
124
125 static inline struct fw_img *iwl_get_ucode_image(struct iwl_nic *nic,
126 enum iwl_ucode_type ucode_type)
127 {
128 switch (ucode_type) {
129 case IWL_UCODE_INIT:
130 return &nic->fw.ucode_init;
131 case IWL_UCODE_WOWLAN:
132 return &nic->fw.ucode_wowlan;
133 case IWL_UCODE_REGULAR:
134 return &nic->fw.ucode_rt;
135 case IWL_UCODE_NONE:
136 break;
137 }
138 return NULL;
139 }
140
141 /*
142 * Calibration
143 */
144 static int iwl_set_Xtal_calib(struct iwl_trans *trans)
145 {
146 struct iwl_calib_xtal_freq_cmd cmd;
147 __le16 *xtal_calib =
148 (__le16 *)iwl_eeprom_query_addr(trans->shrd, EEPROM_XTAL);
149
150 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD);
151 cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]);
152 cmd.cap_pin2 = le16_to_cpu(xtal_calib[1]);
153 return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
154 }
155
156 static int iwl_set_temperature_offset_calib(struct iwl_trans *trans)
157 {
158 struct iwl_calib_temperature_offset_cmd cmd;
159 __le16 *offset_calib =
160 (__le16 *)iwl_eeprom_query_addr(trans->shrd,
161 EEPROM_RAW_TEMPERATURE);
162
163 memset(&cmd, 0, sizeof(cmd));
164 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
165 memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(*offset_calib));
166 if (!(cmd.radio_sensor_offset))
167 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET;
168
169 IWL_DEBUG_CALIB(trans, "Radio sensor offset: %d\n",
170 le16_to_cpu(cmd.radio_sensor_offset));
171 return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
172 }
173
174 static int iwl_set_temperature_offset_calib_v2(struct iwl_trans *trans)
175 {
176 struct iwl_calib_temperature_offset_v2_cmd cmd;
177 __le16 *offset_calib_high = (__le16 *)iwl_eeprom_query_addr(trans->shrd,
178 EEPROM_KELVIN_TEMPERATURE);
179 __le16 *offset_calib_low =
180 (__le16 *)iwl_eeprom_query_addr(trans->shrd,
181 EEPROM_RAW_TEMPERATURE);
182 struct iwl_eeprom_calib_hdr *hdr;
183
184 memset(&cmd, 0, sizeof(cmd));
185 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
186 hdr = (struct iwl_eeprom_calib_hdr *)iwl_eeprom_query_addr(trans->shrd,
187 EEPROM_CALIB_ALL);
188 memcpy(&cmd.radio_sensor_offset_high, offset_calib_high,
189 sizeof(*offset_calib_high));
190 memcpy(&cmd.radio_sensor_offset_low, offset_calib_low,
191 sizeof(*offset_calib_low));
192 if (!(cmd.radio_sensor_offset_low)) {
193 IWL_DEBUG_CALIB(trans, "no info in EEPROM, use default\n");
194 cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET;
195 cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET;
196 }
197 memcpy(&cmd.burntVoltageRef, &hdr->voltage,
198 sizeof(hdr->voltage));
199
200 IWL_DEBUG_CALIB(trans, "Radio sensor offset high: %d\n",
201 le16_to_cpu(cmd.radio_sensor_offset_high));
202 IWL_DEBUG_CALIB(trans, "Radio sensor offset low: %d\n",
203 le16_to_cpu(cmd.radio_sensor_offset_low));
204 IWL_DEBUG_CALIB(trans, "Voltage Ref: %d\n",
205 le16_to_cpu(cmd.burntVoltageRef));
206
207 return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
208 }
209
210 static int iwl_send_calib_cfg(struct iwl_trans *trans)
211 {
212 struct iwl_calib_cfg_cmd calib_cfg_cmd;
213 struct iwl_host_cmd cmd = {
214 .id = CALIBRATION_CFG_CMD,
215 .len = { sizeof(struct iwl_calib_cfg_cmd), },
216 .data = { &calib_cfg_cmd, },
217 };
218
219 memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
220 calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
221 calib_cfg_cmd.ucd_calib_cfg.once.start = IWL_CALIB_INIT_CFG_ALL;
222 calib_cfg_cmd.ucd_calib_cfg.once.send_res = IWL_CALIB_INIT_CFG_ALL;
223 calib_cfg_cmd.ucd_calib_cfg.flags =
224 IWL_CALIB_CFG_FLAG_SEND_COMPLETE_NTFY_MSK;
225
226 return iwl_trans_send_cmd(trans, &cmd);
227 }
228
229 int iwlagn_rx_calib_result(struct iwl_priv *priv,
230 struct iwl_rx_mem_buffer *rxb,
231 struct iwl_device_cmd *cmd)
232 {
233 struct iwl_rx_packet *pkt = rxb_addr(rxb);
234 struct iwl_calib_hdr *hdr = (struct iwl_calib_hdr *)pkt->u.raw;
235 int len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
236
237 /* reduce the size of the length field itself */
238 len -= 4;
239
240 if (iwl_calib_set(trans(priv), hdr, len))
241 IWL_ERR(priv, "Failed to record calibration data %d\n",
242 hdr->op_code);
243
244 return 0;
245 }
246
247 int iwl_init_alive_start(struct iwl_trans *trans)
248 {
249 int ret;
250
251 if (cfg(trans)->bt_params &&
252 cfg(trans)->bt_params->advanced_bt_coexist) {
253 /*
254 * Tell uCode we are ready to perform calibration
255 * need to perform this before any calibration
256 * no need to close the envlope since we are going
257 * to load the runtime uCode later.
258 */
259 ret = iwl_send_bt_env(trans, IWL_BT_COEX_ENV_OPEN,
260 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
261 if (ret)
262 return ret;
263
264 }
265
266 ret = iwl_send_calib_cfg(trans);
267 if (ret)
268 return ret;
269
270 /**
271 * temperature offset calibration is only needed for runtime ucode,
272 * so prepare the value now.
273 */
274 if (cfg(trans)->need_temp_offset_calib) {
275 if (cfg(trans)->temp_offset_v2)
276 return iwl_set_temperature_offset_calib_v2(trans);
277 else
278 return iwl_set_temperature_offset_calib(trans);
279 }
280
281 return 0;
282 }
283
284 static int iwl_send_wimax_coex(struct iwl_trans *trans)
285 {
286 struct iwl_wimax_coex_cmd coex_cmd;
287
288 if (cfg(trans)->base_params->support_wimax_coexist) {
289 /* UnMask wake up src at associated sleep */
290 coex_cmd.flags = COEX_FLAGS_ASSOC_WA_UNMASK_MSK;
291
292 /* UnMask wake up src at unassociated sleep */
293 coex_cmd.flags |= COEX_FLAGS_UNASSOC_WA_UNMASK_MSK;
294 memcpy(coex_cmd.sta_prio, cu_priorities,
295 sizeof(struct iwl_wimax_coex_event_entry) *
296 COEX_NUM_OF_EVENTS);
297
298 /* enabling the coexistence feature */
299 coex_cmd.flags |= COEX_FLAGS_COEX_ENABLE_MSK;
300
301 /* enabling the priorities tables */
302 coex_cmd.flags |= COEX_FLAGS_STA_TABLE_VALID_MSK;
303 } else {
304 /* coexistence is disabled */
305 memset(&coex_cmd, 0, sizeof(coex_cmd));
306 }
307 return iwl_trans_send_cmd_pdu(trans,
308 COEX_PRIORITY_TABLE_CMD, CMD_SYNC,
309 sizeof(coex_cmd), &coex_cmd);
310 }
311
312 static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
313 ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
314 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
315 ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
316 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
317 ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
318 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
319 ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
320 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
321 ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
322 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
323 ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
324 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
325 ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
326 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
327 ((BT_COEX_PRIO_TBL_PRIO_COEX_OFF << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
328 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
329 ((BT_COEX_PRIO_TBL_PRIO_COEX_ON << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
330 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
331 0, 0, 0, 0, 0, 0, 0
332 };
333
334 void iwl_send_prio_tbl(struct iwl_trans *trans)
335 {
336 struct iwl_bt_coex_prio_table_cmd prio_tbl_cmd;
337
338 memcpy(prio_tbl_cmd.prio_tbl, iwl_bt_prio_tbl,
339 sizeof(iwl_bt_prio_tbl));
340 if (iwl_trans_send_cmd_pdu(trans,
341 REPLY_BT_COEX_PRIO_TABLE, CMD_SYNC,
342 sizeof(prio_tbl_cmd), &prio_tbl_cmd))
343 IWL_ERR(trans, "failed to send BT prio tbl command\n");
344 }
345
346 int iwl_send_bt_env(struct iwl_trans *trans, u8 action, u8 type)
347 {
348 struct iwl_bt_coex_prot_env_cmd env_cmd;
349 int ret;
350
351 env_cmd.action = action;
352 env_cmd.type = type;
353 ret = iwl_trans_send_cmd_pdu(trans,
354 REPLY_BT_COEX_PROT_ENV, CMD_SYNC,
355 sizeof(env_cmd), &env_cmd);
356 if (ret)
357 IWL_ERR(trans, "failed to send BT env command\n");
358 return ret;
359 }
360
361
362 static int iwl_alive_notify(struct iwl_trans *trans)
363 {
364 struct iwl_priv *priv = priv(trans);
365 struct iwl_rxon_context *ctx;
366 int ret;
367
368 if (!priv->tx_cmd_pool)
369 priv->tx_cmd_pool =
370 kmem_cache_create("iwl_dev_cmd",
371 sizeof(struct iwl_device_cmd),
372 sizeof(void *), 0, NULL);
373
374 if (!priv->tx_cmd_pool)
375 return -ENOMEM;
376
377 iwl_trans_fw_alive(trans);
378 for_each_context(priv, ctx)
379 ctx->last_tx_rejected = false;
380
381 ret = iwl_send_wimax_coex(trans);
382 if (ret)
383 return ret;
384
385 if (!cfg(priv)->no_xtal_calib) {
386 ret = iwl_set_Xtal_calib(trans);
387 if (ret)
388 return ret;
389 }
390
391 return iwl_send_calib_results(trans);
392 }
393
394
395 /**
396 * iwl_verify_inst_sparse - verify runtime uCode image in card vs. host,
397 * using sample data 100 bytes apart. If these sample points are good,
398 * it's a pretty good bet that everything between them is good, too.
399 */
400 static int iwl_verify_inst_sparse(struct iwl_nic *nic,
401 struct fw_desc *fw_desc)
402 {
403 struct iwl_trans *trans = trans(nic);
404 __le32 *image = (__le32 *)fw_desc->v_addr;
405 u32 len = fw_desc->len;
406 u32 val;
407 u32 i;
408
409 IWL_DEBUG_FW(nic, "ucode inst image size is %u\n", len);
410
411 for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) {
412 /* read data comes through single port, auto-incr addr */
413 /* NOTE: Use the debugless read so we don't flood kernel log
414 * if IWL_DL_IO is set */
415 iwl_write_direct32(trans, HBUS_TARG_MEM_RADDR,
416 i + IWLAGN_RTC_INST_LOWER_BOUND);
417 val = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
418 if (val != le32_to_cpu(*image))
419 return -EIO;
420 }
421
422 return 0;
423 }
424
425 static void iwl_print_mismatch_inst(struct iwl_nic *nic,
426 struct fw_desc *fw_desc)
427 {
428 struct iwl_trans *trans = trans(nic);
429 __le32 *image = (__le32 *)fw_desc->v_addr;
430 u32 len = fw_desc->len;
431 u32 val;
432 u32 offs;
433 int errors = 0;
434
435 IWL_DEBUG_FW(nic, "ucode inst image size is %u\n", len);
436
437 iwl_write_direct32(trans, HBUS_TARG_MEM_RADDR,
438 IWLAGN_RTC_INST_LOWER_BOUND);
439
440 for (offs = 0;
441 offs < len && errors < 20;
442 offs += sizeof(u32), image++) {
443 /* read data comes through single port, auto-incr addr */
444 val = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
445 if (val != le32_to_cpu(*image)) {
446 IWL_ERR(nic, "uCode INST section at "
447 "offset 0x%x, is 0x%x, s/b 0x%x\n",
448 offs, val, le32_to_cpu(*image));
449 errors++;
450 }
451 }
452 }
453
454 /**
455 * iwl_verify_ucode - determine which instruction image is in SRAM,
456 * and verify its contents
457 */
458 static int iwl_verify_ucode(struct iwl_nic *nic,
459 enum iwl_ucode_type ucode_type)
460 {
461 struct fw_img *img = iwl_get_ucode_image(nic, ucode_type);
462
463 if (!img) {
464 IWL_ERR(nic, "Invalid ucode requested (%d)\n", ucode_type);
465 return -EINVAL;
466 }
467
468 if (!iwl_verify_inst_sparse(nic, &img->code)) {
469 IWL_DEBUG_FW(nic, "uCode is good in inst SRAM\n");
470 return 0;
471 }
472
473 IWL_ERR(nic, "UCODE IMAGE IN INSTRUCTION SRAM NOT VALID!!\n");
474
475 iwl_print_mismatch_inst(nic, &img->code);
476 return -EIO;
477 }
478
479 struct iwl_alive_data {
480 bool valid;
481 u8 subtype;
482 };
483
484 static void iwl_alive_fn(struct iwl_trans *trans,
485 struct iwl_rx_packet *pkt,
486 void *data)
487 {
488 struct iwl_alive_data *alive_data = data;
489 struct iwl_alive_resp *palive;
490
491 palive = &pkt->u.alive_frame;
492
493 IWL_DEBUG_FW(trans, "Alive ucode status 0x%08X revision "
494 "0x%01X 0x%01X\n",
495 palive->is_valid, palive->ver_type,
496 palive->ver_subtype);
497
498 trans->shrd->device_pointers.error_event_table =
499 le32_to_cpu(palive->error_event_table_ptr);
500 trans->shrd->device_pointers.log_event_table =
501 le32_to_cpu(palive->log_event_table_ptr);
502
503 alive_data->subtype = palive->ver_subtype;
504 alive_data->valid = palive->is_valid == UCODE_VALID_OK;
505 }
506
507 /* notification wait support */
508 void iwl_init_notification_wait(struct iwl_shared *shrd,
509 struct iwl_notification_wait *wait_entry,
510 u8 cmd,
511 void (*fn)(struct iwl_trans *trans,
512 struct iwl_rx_packet *pkt,
513 void *data),
514 void *fn_data)
515 {
516 wait_entry->fn = fn;
517 wait_entry->fn_data = fn_data;
518 wait_entry->cmd = cmd;
519 wait_entry->triggered = false;
520 wait_entry->aborted = false;
521
522 spin_lock_bh(&shrd->notif_wait_lock);
523 list_add(&wait_entry->list, &shrd->notif_waits);
524 spin_unlock_bh(&shrd->notif_wait_lock);
525 }
526
527 int iwl_wait_notification(struct iwl_shared *shrd,
528 struct iwl_notification_wait *wait_entry,
529 unsigned long timeout)
530 {
531 int ret;
532
533 ret = wait_event_timeout(shrd->notif_waitq,
534 wait_entry->triggered || wait_entry->aborted,
535 timeout);
536
537 spin_lock_bh(&shrd->notif_wait_lock);
538 list_del(&wait_entry->list);
539 spin_unlock_bh(&shrd->notif_wait_lock);
540
541 if (wait_entry->aborted)
542 return -EIO;
543
544 /* return value is always >= 0 */
545 if (ret <= 0)
546 return -ETIMEDOUT;
547 return 0;
548 }
549
550 void iwl_remove_notification(struct iwl_shared *shrd,
551 struct iwl_notification_wait *wait_entry)
552 {
553 spin_lock_bh(&shrd->notif_wait_lock);
554 list_del(&wait_entry->list);
555 spin_unlock_bh(&shrd->notif_wait_lock);
556 }
557
558 void iwl_abort_notification_waits(struct iwl_shared *shrd)
559 {
560 unsigned long flags;
561 struct iwl_notification_wait *wait_entry;
562
563 spin_lock_irqsave(&shrd->notif_wait_lock, flags);
564 list_for_each_entry(wait_entry, &shrd->notif_waits, list)
565 wait_entry->aborted = true;
566 spin_unlock_irqrestore(&shrd->notif_wait_lock, flags);
567
568 wake_up_all(&shrd->notif_waitq);
569 }
570
571 #define UCODE_ALIVE_TIMEOUT HZ
572 #define UCODE_CALIB_TIMEOUT (2*HZ)
573
574 int iwl_load_ucode_wait_alive(struct iwl_trans *trans,
575 enum iwl_ucode_type ucode_type)
576 {
577 struct iwl_notification_wait alive_wait;
578 struct iwl_alive_data alive_data;
579 struct fw_img *fw;
580 int ret;
581 enum iwl_ucode_type old_type;
582
583 iwl_init_notification_wait(trans->shrd, &alive_wait, REPLY_ALIVE,
584 iwl_alive_fn, &alive_data);
585
586 old_type = trans->shrd->ucode_type;
587 trans->shrd->ucode_type = ucode_type;
588 fw = iwl_get_ucode_image(nic(trans), ucode_type);
589
590 if (!fw)
591 return -EINVAL;
592
593 ret = iwl_trans_start_fw(trans, fw);
594 if (ret) {
595 trans->shrd->ucode_type = old_type;
596 iwl_remove_notification(trans->shrd, &alive_wait);
597 return ret;
598 }
599
600 /*
601 * Some things may run in the background now, but we
602 * just wait for the ALIVE notification here.
603 */
604 ret = iwl_wait_notification(trans->shrd, &alive_wait,
605 UCODE_ALIVE_TIMEOUT);
606 if (ret) {
607 trans->shrd->ucode_type = old_type;
608 return ret;
609 }
610
611 if (!alive_data.valid) {
612 IWL_ERR(trans, "Loaded ucode is not valid!\n");
613 trans->shrd->ucode_type = old_type;
614 return -EIO;
615 }
616
617 /*
618 * This step takes a long time (60-80ms!!) and
619 * WoWLAN image should be loaded quickly, so
620 * skip it for WoWLAN.
621 */
622 if (ucode_type != IWL_UCODE_WOWLAN) {
623 ret = iwl_verify_ucode(nic(trans), ucode_type);
624 if (ret) {
625 trans->shrd->ucode_type = old_type;
626 return ret;
627 }
628
629 /* delay a bit to give rfkill time to run */
630 msleep(5);
631 }
632
633 ret = iwl_alive_notify(trans);
634 if (ret) {
635 IWL_WARN(trans,
636 "Could not complete ALIVE transition: %d\n", ret);
637 trans->shrd->ucode_type = old_type;
638 return ret;
639 }
640
641 return 0;
642 }
643
644 int iwl_run_init_ucode(struct iwl_trans *trans)
645 {
646 struct iwl_notification_wait calib_wait;
647 int ret;
648
649 lockdep_assert_held(&trans->shrd->mutex);
650
651 /* No init ucode required? Curious, but maybe ok */
652 if (!nic(trans)->fw.ucode_init.code.len)
653 return 0;
654
655 if (trans->shrd->ucode_type != IWL_UCODE_NONE)
656 return 0;
657
658 iwl_init_notification_wait(trans->shrd, &calib_wait,
659 CALIBRATION_COMPLETE_NOTIFICATION,
660 NULL, NULL);
661
662 /* Will also start the device */
663 ret = iwl_load_ucode_wait_alive(trans, IWL_UCODE_INIT);
664 if (ret)
665 goto error;
666
667 ret = iwl_init_alive_start(trans);
668 if (ret)
669 goto error;
670
671 /*
672 * Some things may run in the background now, but we
673 * just wait for the calibration complete notification.
674 */
675 ret = iwl_wait_notification(trans->shrd, &calib_wait,
676 UCODE_CALIB_TIMEOUT);
677
678 goto out;
679
680 error:
681 iwl_remove_notification(trans->shrd, &calib_wait);
682 out:
683 /* Whatever happened, stop the device */
684 iwl_trans_stop_device(trans);
685 return ret;
686 }
687
688 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
689
690 #define UCODE_EXPERIMENTAL_TAG "exp"
691
692 int __must_check iwl_request_firmware(struct iwl_nic *nic, bool first)
693 {
694 struct iwl_cfg *cfg = cfg(nic);
695 const char *name_pre = cfg->fw_name_pre;
696 char tag[8];
697
698 if (first) {
699 #ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
700 nic->fw_index = UCODE_EXPERIMENTAL_INDEX;
701 strcpy(tag, UCODE_EXPERIMENTAL_TAG);
702 } else if (nic->fw_index == UCODE_EXPERIMENTAL_INDEX) {
703 #endif
704 nic->fw_index = cfg->ucode_api_max;
705 sprintf(tag, "%d", nic->fw_index);
706 } else {
707 nic->fw_index--;
708 sprintf(tag, "%d", nic->fw_index);
709 }
710
711 if (nic->fw_index < cfg->ucode_api_min) {
712 IWL_ERR(nic, "no suitable firmware found!\n");
713 return -ENOENT;
714 }
715
716 sprintf(nic->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
717
718 IWL_DEBUG_INFO(nic, "attempting to load firmware %s'%s'\n",
719 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
720 ? "EXPERIMENTAL " : "",
721 nic->firmware_name);
722
723 return request_firmware_nowait(THIS_MODULE, 1, nic->firmware_name,
724 trans(nic)->dev,
725 GFP_KERNEL, nic, iwl_ucode_callback);
726 }
727
728 struct iwlagn_firmware_pieces {
729 const void *inst, *data, *init, *init_data, *wowlan_inst, *wowlan_data;
730 size_t inst_size, data_size, init_size, init_data_size,
731 wowlan_inst_size, wowlan_data_size;
732
733 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
734 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
735 };
736
737 static int iwl_parse_v1_v2_firmware(struct iwl_nic *nic,
738 const struct firmware *ucode_raw,
739 struct iwlagn_firmware_pieces *pieces)
740 {
741 struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
742 u32 api_ver, hdr_size, build;
743 char buildstr[25];
744 const u8 *src;
745
746 nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
747 api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
748
749 switch (api_ver) {
750 default:
751 hdr_size = 28;
752 if (ucode_raw->size < hdr_size) {
753 IWL_ERR(nic, "File size too small!\n");
754 return -EINVAL;
755 }
756 build = le32_to_cpu(ucode->u.v2.build);
757 pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
758 pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
759 pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
760 pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
761 src = ucode->u.v2.data;
762 break;
763 case 0:
764 case 1:
765 case 2:
766 hdr_size = 24;
767 if (ucode_raw->size < hdr_size) {
768 IWL_ERR(nic, "File size too small!\n");
769 return -EINVAL;
770 }
771 build = 0;
772 pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
773 pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
774 pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
775 pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
776 src = ucode->u.v1.data;
777 break;
778 }
779
780 if (build)
781 sprintf(buildstr, " build %u%s", build,
782 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
783 ? " (EXP)" : "");
784 else
785 buildstr[0] = '\0';
786
787 snprintf(nic->fw.fw_version,
788 sizeof(nic->fw.fw_version),
789 "%u.%u.%u.%u%s",
790 IWL_UCODE_MAJOR(nic->fw.ucode_ver),
791 IWL_UCODE_MINOR(nic->fw.ucode_ver),
792 IWL_UCODE_API(nic->fw.ucode_ver),
793 IWL_UCODE_SERIAL(nic->fw.ucode_ver),
794 buildstr);
795
796 /* Verify size of file vs. image size info in file's header */
797 if (ucode_raw->size != hdr_size + pieces->inst_size +
798 pieces->data_size + pieces->init_size +
799 pieces->init_data_size) {
800
801 IWL_ERR(nic,
802 "uCode file size %d does not match expected size\n",
803 (int)ucode_raw->size);
804 return -EINVAL;
805 }
806
807 pieces->inst = src;
808 src += pieces->inst_size;
809 pieces->data = src;
810 src += pieces->data_size;
811 pieces->init = src;
812 src += pieces->init_size;
813 pieces->init_data = src;
814 src += pieces->init_data_size;
815
816 return 0;
817 }
818
819 static int iwl_parse_tlv_firmware(struct iwl_nic *nic,
820 const struct firmware *ucode_raw,
821 struct iwlagn_firmware_pieces *pieces,
822 struct iwl_ucode_capabilities *capa)
823 {
824 struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
825 struct iwl_ucode_tlv *tlv;
826 size_t len = ucode_raw->size;
827 const u8 *data;
828 int wanted_alternative = iwlagn_mod_params.wanted_ucode_alternative;
829 int tmp;
830 u64 alternatives;
831 u32 tlv_len;
832 enum iwl_ucode_tlv_type tlv_type;
833 const u8 *tlv_data;
834 char buildstr[25];
835 u32 build;
836
837 if (len < sizeof(*ucode)) {
838 IWL_ERR(nic, "uCode has invalid length: %zd\n", len);
839 return -EINVAL;
840 }
841
842 if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
843 IWL_ERR(nic, "invalid uCode magic: 0X%x\n",
844 le32_to_cpu(ucode->magic));
845 return -EINVAL;
846 }
847
848 /*
849 * Check which alternatives are present, and "downgrade"
850 * when the chosen alternative is not present, warning
851 * the user when that happens. Some files may not have
852 * any alternatives, so don't warn in that case.
853 */
854 alternatives = le64_to_cpu(ucode->alternatives);
855 tmp = wanted_alternative;
856 if (wanted_alternative > 63)
857 wanted_alternative = 63;
858 while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
859 wanted_alternative--;
860 if (wanted_alternative && wanted_alternative != tmp)
861 IWL_WARN(nic,
862 "uCode alternative %d not available, choosing %d\n",
863 tmp, wanted_alternative);
864
865 nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
866 build = le32_to_cpu(ucode->build);
867
868 if (build)
869 sprintf(buildstr, " build %u%s", build,
870 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
871 ? " (EXP)" : "");
872 else
873 buildstr[0] = '\0';
874
875 snprintf(nic->fw.fw_version,
876 sizeof(nic->fw.fw_version),
877 "%u.%u.%u.%u%s",
878 IWL_UCODE_MAJOR(nic->fw.ucode_ver),
879 IWL_UCODE_MINOR(nic->fw.ucode_ver),
880 IWL_UCODE_API(nic->fw.ucode_ver),
881 IWL_UCODE_SERIAL(nic->fw.ucode_ver),
882 buildstr);
883
884 data = ucode->data;
885
886 len -= sizeof(*ucode);
887
888 while (len >= sizeof(*tlv)) {
889 u16 tlv_alt;
890
891 len -= sizeof(*tlv);
892 tlv = (void *)data;
893
894 tlv_len = le32_to_cpu(tlv->length);
895 tlv_type = le16_to_cpu(tlv->type);
896 tlv_alt = le16_to_cpu(tlv->alternative);
897 tlv_data = tlv->data;
898
899 if (len < tlv_len) {
900 IWL_ERR(nic, "invalid TLV len: %zd/%u\n",
901 len, tlv_len);
902 return -EINVAL;
903 }
904 len -= ALIGN(tlv_len, 4);
905 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
906
907 /*
908 * Alternative 0 is always valid.
909 *
910 * Skip alternative TLVs that are not selected.
911 */
912 if (tlv_alt != 0 && tlv_alt != wanted_alternative)
913 continue;
914
915 switch (tlv_type) {
916 case IWL_UCODE_TLV_INST:
917 pieces->inst = tlv_data;
918 pieces->inst_size = tlv_len;
919 break;
920 case IWL_UCODE_TLV_DATA:
921 pieces->data = tlv_data;
922 pieces->data_size = tlv_len;
923 break;
924 case IWL_UCODE_TLV_INIT:
925 pieces->init = tlv_data;
926 pieces->init_size = tlv_len;
927 break;
928 case IWL_UCODE_TLV_INIT_DATA:
929 pieces->init_data = tlv_data;
930 pieces->init_data_size = tlv_len;
931 break;
932 case IWL_UCODE_TLV_BOOT:
933 IWL_ERR(nic, "Found unexpected BOOT ucode\n");
934 break;
935 case IWL_UCODE_TLV_PROBE_MAX_LEN:
936 if (tlv_len != sizeof(u32))
937 goto invalid_tlv_len;
938 capa->max_probe_length =
939 le32_to_cpup((__le32 *)tlv_data);
940 break;
941 case IWL_UCODE_TLV_PAN:
942 if (tlv_len)
943 goto invalid_tlv_len;
944 capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
945 break;
946 case IWL_UCODE_TLV_FLAGS:
947 /* must be at least one u32 */
948 if (tlv_len < sizeof(u32))
949 goto invalid_tlv_len;
950 /* and a proper number of u32s */
951 if (tlv_len % sizeof(u32))
952 goto invalid_tlv_len;
953 /*
954 * This driver only reads the first u32 as
955 * right now no more features are defined,
956 * if that changes then either the driver
957 * will not work with the new firmware, or
958 * it'll not take advantage of new features.
959 */
960 capa->flags = le32_to_cpup((__le32 *)tlv_data);
961 break;
962 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
963 if (tlv_len != sizeof(u32))
964 goto invalid_tlv_len;
965 pieces->init_evtlog_ptr =
966 le32_to_cpup((__le32 *)tlv_data);
967 break;
968 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
969 if (tlv_len != sizeof(u32))
970 goto invalid_tlv_len;
971 pieces->init_evtlog_size =
972 le32_to_cpup((__le32 *)tlv_data);
973 break;
974 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
975 if (tlv_len != sizeof(u32))
976 goto invalid_tlv_len;
977 pieces->init_errlog_ptr =
978 le32_to_cpup((__le32 *)tlv_data);
979 break;
980 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
981 if (tlv_len != sizeof(u32))
982 goto invalid_tlv_len;
983 pieces->inst_evtlog_ptr =
984 le32_to_cpup((__le32 *)tlv_data);
985 break;
986 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
987 if (tlv_len != sizeof(u32))
988 goto invalid_tlv_len;
989 pieces->inst_evtlog_size =
990 le32_to_cpup((__le32 *)tlv_data);
991 break;
992 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
993 if (tlv_len != sizeof(u32))
994 goto invalid_tlv_len;
995 pieces->inst_errlog_ptr =
996 le32_to_cpup((__le32 *)tlv_data);
997 break;
998 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
999 if (tlv_len)
1000 goto invalid_tlv_len;
1001 nic->fw.enhance_sensitivity_table = true;
1002 break;
1003 case IWL_UCODE_TLV_WOWLAN_INST:
1004 pieces->wowlan_inst = tlv_data;
1005 pieces->wowlan_inst_size = tlv_len;
1006 break;
1007 case IWL_UCODE_TLV_WOWLAN_DATA:
1008 pieces->wowlan_data = tlv_data;
1009 pieces->wowlan_data_size = tlv_len;
1010 break;
1011 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
1012 if (tlv_len != sizeof(u32))
1013 goto invalid_tlv_len;
1014 capa->standard_phy_calibration_size =
1015 le32_to_cpup((__le32 *)tlv_data);
1016 break;
1017 default:
1018 IWL_DEBUG_INFO(nic, "unknown TLV: %d\n", tlv_type);
1019 break;
1020 }
1021 }
1022
1023 if (len) {
1024 IWL_ERR(nic, "invalid TLV after parsing: %zd\n", len);
1025 iwl_print_hex_dump(nic, IWL_DL_FW, (u8 *)data, len);
1026 return -EINVAL;
1027 }
1028
1029 return 0;
1030
1031 invalid_tlv_len:
1032 IWL_ERR(nic, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
1033 iwl_print_hex_dump(nic, IWL_DL_FW, tlv_data, tlv_len);
1034
1035 return -EINVAL;
1036 }
1037
1038 /**
1039 * iwl_ucode_callback - callback when firmware was loaded
1040 *
1041 * If loaded successfully, copies the firmware into buffers
1042 * for the card to fetch (via DMA).
1043 */
1044 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
1045 {
1046 struct iwl_nic *nic = context;
1047 struct iwl_cfg *cfg = cfg(nic);
1048 struct iwl_fw *fw = &nic->fw;
1049 struct iwl_ucode_header *ucode;
1050 int err;
1051 struct iwlagn_firmware_pieces pieces;
1052 const unsigned int api_max = cfg->ucode_api_max;
1053 unsigned int api_ok = cfg->ucode_api_ok;
1054 const unsigned int api_min = cfg->ucode_api_min;
1055 u32 api_ver;
1056
1057 fw->ucode_capa.max_probe_length = 200;
1058 fw->ucode_capa.standard_phy_calibration_size =
1059 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1060
1061 if (!api_ok)
1062 api_ok = api_max;
1063
1064 memset(&pieces, 0, sizeof(pieces));
1065
1066 if (!ucode_raw) {
1067 if (nic->fw_index <= api_ok)
1068 IWL_ERR(nic,
1069 "request for firmware file '%s' failed.\n",
1070 nic->firmware_name);
1071 goto try_again;
1072 }
1073
1074 IWL_DEBUG_INFO(nic, "Loaded firmware file '%s' (%zd bytes).\n",
1075 nic->firmware_name, ucode_raw->size);
1076
1077 /* Make sure that we got at least the API version number */
1078 if (ucode_raw->size < 4) {
1079 IWL_ERR(nic, "File size way too small!\n");
1080 goto try_again;
1081 }
1082
1083 /* Data from ucode file: header followed by uCode images */
1084 ucode = (struct iwl_ucode_header *)ucode_raw->data;
1085
1086 if (ucode->ver)
1087 err = iwl_parse_v1_v2_firmware(nic, ucode_raw, &pieces);
1088 else
1089 err = iwl_parse_tlv_firmware(nic, ucode_raw, &pieces,
1090 &fw->ucode_capa);
1091
1092 if (err)
1093 goto try_again;
1094
1095 api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
1096
1097 /*
1098 * api_ver should match the api version forming part of the
1099 * firmware filename ... but we don't check for that and only rely
1100 * on the API version read from firmware header from here on forward
1101 */
1102 /* no api version check required for experimental uCode */
1103 if (nic->fw_index != UCODE_EXPERIMENTAL_INDEX) {
1104 if (api_ver < api_min || api_ver > api_max) {
1105 IWL_ERR(nic,
1106 "Driver unable to support your firmware API. "
1107 "Driver supports v%u, firmware is v%u.\n",
1108 api_max, api_ver);
1109 goto try_again;
1110 }
1111
1112 if (api_ver < api_ok) {
1113 if (api_ok != api_max)
1114 IWL_ERR(nic, "Firmware has old API version, "
1115 "expected v%u through v%u, got v%u.\n",
1116 api_ok, api_max, api_ver);
1117 else
1118 IWL_ERR(nic, "Firmware has old API version, "
1119 "expected v%u, got v%u.\n",
1120 api_max, api_ver);
1121 IWL_ERR(nic, "New firmware can be obtained from "
1122 "http://www.intellinuxwireless.org/.\n");
1123 }
1124 }
1125
1126 IWL_INFO(nic, "loaded firmware version %s", nic->fw.fw_version);
1127
1128 /*
1129 * For any of the failures below (before allocating pci memory)
1130 * we will try to load a version with a smaller API -- maybe the
1131 * user just got a corrupted version of the latest API.
1132 */
1133
1134 IWL_DEBUG_INFO(nic, "f/w package hdr ucode version raw = 0x%x\n",
1135 nic->fw.ucode_ver);
1136 IWL_DEBUG_INFO(nic, "f/w package hdr runtime inst size = %Zd\n",
1137 pieces.inst_size);
1138 IWL_DEBUG_INFO(nic, "f/w package hdr runtime data size = %Zd\n",
1139 pieces.data_size);
1140 IWL_DEBUG_INFO(nic, "f/w package hdr init inst size = %Zd\n",
1141 pieces.init_size);
1142 IWL_DEBUG_INFO(nic, "f/w package hdr init data size = %Zd\n",
1143 pieces.init_data_size);
1144
1145 /* Verify that uCode images will fit in card's SRAM */
1146 if (pieces.inst_size > cfg->max_inst_size) {
1147 IWL_ERR(nic, "uCode instr len %Zd too large to fit in\n",
1148 pieces.inst_size);
1149 goto try_again;
1150 }
1151
1152 if (pieces.data_size > cfg->max_data_size) {
1153 IWL_ERR(nic, "uCode data len %Zd too large to fit in\n",
1154 pieces.data_size);
1155 goto try_again;
1156 }
1157
1158 if (pieces.init_size > cfg->max_inst_size) {
1159 IWL_ERR(nic, "uCode init instr len %Zd too large to fit in\n",
1160 pieces.init_size);
1161 goto try_again;
1162 }
1163
1164 if (pieces.init_data_size > cfg->max_data_size) {
1165 IWL_ERR(nic, "uCode init data len %Zd too large to fit in\n",
1166 pieces.init_data_size);
1167 goto try_again;
1168 }
1169
1170 /* Allocate ucode buffers for card's bus-master loading ... */
1171
1172 /* Runtime instructions and 2 copies of data:
1173 * 1) unmodified from disk
1174 * 2) backup cache for save/restore during power-downs */
1175 if (iwl_alloc_fw_desc(nic, &nic->fw.ucode_rt.code,
1176 pieces.inst, pieces.inst_size))
1177 goto err_pci_alloc;
1178 if (iwl_alloc_fw_desc(nic, &nic->fw.ucode_rt.data,
1179 pieces.data, pieces.data_size))
1180 goto err_pci_alloc;
1181
1182 /* Initialization instructions and data */
1183 if (pieces.init_size && pieces.init_data_size) {
1184 if (iwl_alloc_fw_desc(nic,
1185 &nic->fw.ucode_init.code,
1186 pieces.init, pieces.init_size))
1187 goto err_pci_alloc;
1188 if (iwl_alloc_fw_desc(nic,
1189 &nic->fw.ucode_init.data,
1190 pieces.init_data, pieces.init_data_size))
1191 goto err_pci_alloc;
1192 }
1193
1194 /* WoWLAN instructions and data */
1195 if (pieces.wowlan_inst_size && pieces.wowlan_data_size) {
1196 if (iwl_alloc_fw_desc(nic,
1197 &nic->fw.ucode_wowlan.code,
1198 pieces.wowlan_inst,
1199 pieces.wowlan_inst_size))
1200 goto err_pci_alloc;
1201 if (iwl_alloc_fw_desc(nic,
1202 &nic->fw.ucode_wowlan.data,
1203 pieces.wowlan_data,
1204 pieces.wowlan_data_size))
1205 goto err_pci_alloc;
1206 }
1207
1208 /* Now that we can no longer fail, copy information */
1209
1210 /*
1211 * The (size - 16) / 12 formula is based on the information recorded
1212 * for each event, which is of mode 1 (including timestamp) for all
1213 * new microcodes that include this information.
1214 */
1215 nic->init_evtlog_ptr = pieces.init_evtlog_ptr;
1216 if (pieces.init_evtlog_size)
1217 nic->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
1218 else
1219 nic->init_evtlog_size =
1220 cfg->base_params->max_event_log_size;
1221 nic->init_errlog_ptr = pieces.init_errlog_ptr;
1222 nic->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
1223 if (pieces.inst_evtlog_size)
1224 nic->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
1225 else
1226 nic->inst_evtlog_size =
1227 cfg->base_params->max_event_log_size;
1228 nic->inst_errlog_ptr = pieces.inst_errlog_ptr;
1229
1230 /*
1231 * figure out the offset of chain noise reset and gain commands
1232 * base on the size of standard phy calibration commands table size
1233 */
1234 if (fw->ucode_capa.standard_phy_calibration_size >
1235 IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1236 fw->ucode_capa.standard_phy_calibration_size =
1237 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1238
1239 /* We have our copies now, allow OS release its copies */
1240 release_firmware(ucode_raw);
1241 complete(&nic->request_firmware_complete);
1242
1243 if (iwl_op_mode_dvm_start(bus(nic), trans(nic)->ops, cfg))
1244 goto out_unbind;
1245
1246 return;
1247
1248 try_again:
1249 /* try next, if any */
1250 release_firmware(ucode_raw);
1251 if (iwl_request_firmware(nic, false))
1252 goto out_unbind;
1253 return;
1254
1255 err_pci_alloc:
1256 IWL_ERR(nic, "failed to allocate pci memory\n");
1257 iwl_dealloc_ucode(nic);
1258 release_firmware(ucode_raw);
1259 out_unbind:
1260 complete(&nic->request_firmware_complete);
1261 device_release_driver(trans(nic)->dev);
1262 }
1263
Linux kernel - Deliverables
This page took 0.055695 seconds and 6 git commands to generate.