?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: move event and err pointers to iwl_nic
[linux-2.6.git] / drivers / net / wireless / iwlwifi / iwl-ucode.c
blob0d04a4d7dc8432bad560e51e96ab0635565293d2
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_INDEX 100
691 #define UCODE_EXPERIMENTAL_TAG "exp"
692
693 int __must_check iwl_request_firmware(struct iwl_priv *priv, bool first)
694 {
695 struct iwl_nic *nic = nic(priv);
696 const char *name_pre = cfg(priv)->fw_name_pre;
697 char tag[8];
698
699 if (first) {
700 #ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
701 nic->fw_index = UCODE_EXPERIMENTAL_INDEX;
702 strcpy(tag, UCODE_EXPERIMENTAL_TAG);
703 } else if (nic->fw_index == UCODE_EXPERIMENTAL_INDEX) {
704 #endif
705 nic->fw_index = cfg(priv)->ucode_api_max;
706 sprintf(tag, "%d", nic->fw_index);
707 } else {
708 nic->fw_index--;
709 sprintf(tag, "%d", nic->fw_index);
710 }
711
712 if (nic->fw_index < cfg(priv)->ucode_api_min) {
713 IWL_ERR(priv, "no suitable firmware found!\n");
714 return -ENOENT;
715 }
716
717 sprintf(nic->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
718
719 IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n",
720 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
721 ? "EXPERIMENTAL " : "",
722 nic->firmware_name);
723
724 return request_firmware_nowait(THIS_MODULE, 1, nic->firmware_name,
725 trans(priv)->dev,
726 GFP_KERNEL, priv, iwl_ucode_callback);
727 }
728
729 struct iwlagn_firmware_pieces {
730 const void *inst, *data, *init, *init_data, *wowlan_inst, *wowlan_data;
731 size_t inst_size, data_size, init_size, init_data_size,
732 wowlan_inst_size, wowlan_data_size;
733
734 u32 build;
735
736 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
737 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
738 };
739
740 static int iwlagn_load_legacy_firmware(struct iwl_priv *priv,
741 const struct firmware *ucode_raw,
742 struct iwlagn_firmware_pieces *pieces)
743 {
744 struct iwl_nic *nic = nic(priv);
745 struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
746 u32 api_ver, hdr_size;
747 const u8 *src;
748
749 nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
750 api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
751
752 switch (api_ver) {
753 default:
754 hdr_size = 28;
755 if (ucode_raw->size < hdr_size) {
756 IWL_ERR(priv, "File size too small!\n");
757 return -EINVAL;
758 }
759 pieces->build = le32_to_cpu(ucode->u.v2.build);
760 pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
761 pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
762 pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
763 pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
764 src = ucode->u.v2.data;
765 break;
766 case 0:
767 case 1:
768 case 2:
769 hdr_size = 24;
770 if (ucode_raw->size < hdr_size) {
771 IWL_ERR(priv, "File size too small!\n");
772 return -EINVAL;
773 }
774 pieces->build = 0;
775 pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
776 pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
777 pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
778 pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
779 src = ucode->u.v1.data;
780 break;
781 }
782
783 /* Verify size of file vs. image size info in file's header */
784 if (ucode_raw->size != hdr_size + pieces->inst_size +
785 pieces->data_size + pieces->init_size +
786 pieces->init_data_size) {
787
788 IWL_ERR(priv,
789 "uCode file size %d does not match expected size\n",
790 (int)ucode_raw->size);
791 return -EINVAL;
792 }
793
794 pieces->inst = src;
795 src += pieces->inst_size;
796 pieces->data = src;
797 src += pieces->data_size;
798 pieces->init = src;
799 src += pieces->init_size;
800 pieces->init_data = src;
801 src += pieces->init_data_size;
802
803 return 0;
804 }
805
806 static int iwlagn_load_firmware(struct iwl_priv *priv,
807 const struct firmware *ucode_raw,
808 struct iwlagn_firmware_pieces *pieces,
809 struct iwlagn_ucode_capabilities *capa)
810 {
811 struct iwl_nic *nic = nic(priv);
812 struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
813 struct iwl_ucode_tlv *tlv;
814 size_t len = ucode_raw->size;
815 const u8 *data;
816 int wanted_alternative = iwlagn_mod_params.wanted_ucode_alternative;
817 int tmp;
818 u64 alternatives;
819 u32 tlv_len;
820 enum iwl_ucode_tlv_type tlv_type;
821 const u8 *tlv_data;
822
823 if (len < sizeof(*ucode)) {
824 IWL_ERR(priv, "uCode has invalid length: %zd\n", len);
825 return -EINVAL;
826 }
827
828 if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
829 IWL_ERR(priv, "invalid uCode magic: 0X%x\n",
830 le32_to_cpu(ucode->magic));
831 return -EINVAL;
832 }
833
834 /*
835 * Check which alternatives are present, and "downgrade"
836 * when the chosen alternative is not present, warning
837 * the user when that happens. Some files may not have
838 * any alternatives, so don't warn in that case.
839 */
840 alternatives = le64_to_cpu(ucode->alternatives);
841 tmp = wanted_alternative;
842 if (wanted_alternative > 63)
843 wanted_alternative = 63;
844 while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
845 wanted_alternative--;
846 if (wanted_alternative && wanted_alternative != tmp)
847 IWL_WARN(priv,
848 "uCode alternative %d not available, choosing %d\n",
849 tmp, wanted_alternative);
850
851 nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
852 pieces->build = le32_to_cpu(ucode->build);
853 data = ucode->data;
854
855 len -= sizeof(*ucode);
856
857 while (len >= sizeof(*tlv)) {
858 u16 tlv_alt;
859
860 len -= sizeof(*tlv);
861 tlv = (void *)data;
862
863 tlv_len = le32_to_cpu(tlv->length);
864 tlv_type = le16_to_cpu(tlv->type);
865 tlv_alt = le16_to_cpu(tlv->alternative);
866 tlv_data = tlv->data;
867
868 if (len < tlv_len) {
869 IWL_ERR(priv, "invalid TLV len: %zd/%u\n",
870 len, tlv_len);
871 return -EINVAL;
872 }
873 len -= ALIGN(tlv_len, 4);
874 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
875
876 /*
877 * Alternative 0 is always valid.
878 *
879 * Skip alternative TLVs that are not selected.
880 */
881 if (tlv_alt != 0 && tlv_alt != wanted_alternative)
882 continue;
883
884 switch (tlv_type) {
885 case IWL_UCODE_TLV_INST:
886 pieces->inst = tlv_data;
887 pieces->inst_size = tlv_len;
888 break;
889 case IWL_UCODE_TLV_DATA:
890 pieces->data = tlv_data;
891 pieces->data_size = tlv_len;
892 break;
893 case IWL_UCODE_TLV_INIT:
894 pieces->init = tlv_data;
895 pieces->init_size = tlv_len;
896 break;
897 case IWL_UCODE_TLV_INIT_DATA:
898 pieces->init_data = tlv_data;
899 pieces->init_data_size = tlv_len;
900 break;
901 case IWL_UCODE_TLV_BOOT:
902 IWL_ERR(priv, "Found unexpected BOOT ucode\n");
903 break;
904 case IWL_UCODE_TLV_PROBE_MAX_LEN:
905 if (tlv_len != sizeof(u32))
906 goto invalid_tlv_len;
907 capa->max_probe_length =
908 le32_to_cpup((__le32 *)tlv_data);
909 break;
910 case IWL_UCODE_TLV_PAN:
911 if (tlv_len)
912 goto invalid_tlv_len;
913 capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
914 break;
915 case IWL_UCODE_TLV_FLAGS:
916 /* must be at least one u32 */
917 if (tlv_len < sizeof(u32))
918 goto invalid_tlv_len;
919 /* and a proper number of u32s */
920 if (tlv_len % sizeof(u32))
921 goto invalid_tlv_len;
922 /*
923 * This driver only reads the first u32 as
924 * right now no more features are defined,
925 * if that changes then either the driver
926 * will not work with the new firmware, or
927 * it'll not take advantage of new features.
928 */
929 capa->flags = le32_to_cpup((__le32 *)tlv_data);
930 break;
931 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
932 if (tlv_len != sizeof(u32))
933 goto invalid_tlv_len;
934 pieces->init_evtlog_ptr =
935 le32_to_cpup((__le32 *)tlv_data);
936 break;
937 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
938 if (tlv_len != sizeof(u32))
939 goto invalid_tlv_len;
940 pieces->init_evtlog_size =
941 le32_to_cpup((__le32 *)tlv_data);
942 break;
943 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
944 if (tlv_len != sizeof(u32))
945 goto invalid_tlv_len;
946 pieces->init_errlog_ptr =
947 le32_to_cpup((__le32 *)tlv_data);
948 break;
949 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
950 if (tlv_len != sizeof(u32))
951 goto invalid_tlv_len;
952 pieces->inst_evtlog_ptr =
953 le32_to_cpup((__le32 *)tlv_data);
954 break;
955 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
956 if (tlv_len != sizeof(u32))
957 goto invalid_tlv_len;
958 pieces->inst_evtlog_size =
959 le32_to_cpup((__le32 *)tlv_data);
960 break;
961 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
962 if (tlv_len != sizeof(u32))
963 goto invalid_tlv_len;
964 pieces->inst_errlog_ptr =
965 le32_to_cpup((__le32 *)tlv_data);
966 break;
967 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
968 if (tlv_len)
969 goto invalid_tlv_len;
970 nic->fw.enhance_sensitivity_table = true;
971 break;
972 case IWL_UCODE_TLV_WOWLAN_INST:
973 pieces->wowlan_inst = tlv_data;
974 pieces->wowlan_inst_size = tlv_len;
975 break;
976 case IWL_UCODE_TLV_WOWLAN_DATA:
977 pieces->wowlan_data = tlv_data;
978 pieces->wowlan_data_size = tlv_len;
979 break;
980 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
981 if (tlv_len != sizeof(u32))
982 goto invalid_tlv_len;
983 capa->standard_phy_calibration_size =
984 le32_to_cpup((__le32 *)tlv_data);
985 break;
986 default:
987 IWL_DEBUG_INFO(priv, "unknown TLV: %d\n", tlv_type);
988 break;
989 }
990 }
991
992 if (len) {
993 IWL_ERR(priv, "invalid TLV after parsing: %zd\n", len);
994 iwl_print_hex_dump(priv, IWL_DL_FW, (u8 *)data, len);
995 return -EINVAL;
996 }
997
998 return 0;
999
1000 invalid_tlv_len:
1001 IWL_ERR(priv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
1002 iwl_print_hex_dump(priv, IWL_DL_FW, tlv_data, tlv_len);
1003
1004 return -EINVAL;
1005 }
1006
1007 /**
1008 * iwl_ucode_callback - callback when firmware was loaded
1009 *
1010 * If loaded successfully, copies the firmware into buffers
1011 * for the card to fetch (via DMA).
1012 */
1013 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
1014 {
1015 struct iwl_priv *priv = context;
1016 struct iwl_nic *nic = nic(priv);
1017 struct iwl_ucode_header *ucode;
1018 int err;
1019 struct iwlagn_firmware_pieces pieces;
1020 const unsigned int api_max = cfg(priv)->ucode_api_max;
1021 unsigned int api_ok = cfg(priv)->ucode_api_ok;
1022 const unsigned int api_min = cfg(priv)->ucode_api_min;
1023 u32 api_ver;
1024 char buildstr[25];
1025 u32 build;
1026 struct iwlagn_ucode_capabilities ucode_capa = {
1027 .max_probe_length = 200,
1028 .standard_phy_calibration_size =
1029 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE,
1030 };
1031
1032 if (!api_ok)
1033 api_ok = api_max;
1034
1035 memset(&pieces, 0, sizeof(pieces));
1036
1037 if (!ucode_raw) {
1038 if (nic->fw_index <= api_ok)
1039 IWL_ERR(priv,
1040 "request for firmware file '%s' failed.\n",
1041 nic->firmware_name);
1042 goto try_again;
1043 }
1044
1045 IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n",
1046 nic->firmware_name, ucode_raw->size);
1047
1048 /* Make sure that we got at least the API version number */
1049 if (ucode_raw->size < 4) {
1050 IWL_ERR(priv, "File size way too small!\n");
1051 goto try_again;
1052 }
1053
1054 /* Data from ucode file: header followed by uCode images */
1055 ucode = (struct iwl_ucode_header *)ucode_raw->data;
1056
1057 if (ucode->ver)
1058 err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces);
1059 else
1060 err = iwlagn_load_firmware(priv, ucode_raw, &pieces,
1061 &ucode_capa);
1062
1063 if (err)
1064 goto try_again;
1065
1066 api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
1067 build = pieces.build;
1068
1069 /*
1070 * api_ver should match the api version forming part of the
1071 * firmware filename ... but we don't check for that and only rely
1072 * on the API version read from firmware header from here on forward
1073 */
1074 /* no api version check required for experimental uCode */
1075 if (nic->fw_index != UCODE_EXPERIMENTAL_INDEX) {
1076 if (api_ver < api_min || api_ver > api_max) {
1077 IWL_ERR(priv,
1078 "Driver unable to support your firmware API. "
1079 "Driver supports v%u, firmware is v%u.\n",
1080 api_max, api_ver);
1081 goto try_again;
1082 }
1083
1084 if (api_ver < api_ok) {
1085 if (api_ok != api_max)
1086 IWL_ERR(priv, "Firmware has old API version, "
1087 "expected v%u through v%u, got v%u.\n",
1088 api_ok, api_max, api_ver);
1089 else
1090 IWL_ERR(priv, "Firmware has old API version, "
1091 "expected v%u, got v%u.\n",
1092 api_max, api_ver);
1093 IWL_ERR(priv, "New firmware can be obtained from "
1094 "http://www.intellinuxwireless.org/.\n");
1095 }
1096 }
1097
1098 if (build)
1099 sprintf(buildstr, " build %u%s", build,
1100 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
1101 ? " (EXP)" : "");
1102 else
1103 buildstr[0] = '\0';
1104
1105 IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u%s\n",
1106 IWL_UCODE_MAJOR(nic->fw.ucode_ver),
1107 IWL_UCODE_MINOR(nic->fw.ucode_ver),
1108 IWL_UCODE_API(nic->fw.ucode_ver),
1109 IWL_UCODE_SERIAL(nic->fw.ucode_ver),
1110 buildstr);
1111
1112 snprintf(priv->hw->wiphy->fw_version,
1113 sizeof(priv->hw->wiphy->fw_version),
1114 "%u.%u.%u.%u%s",
1115 IWL_UCODE_MAJOR(nic->fw.ucode_ver),
1116 IWL_UCODE_MINOR(nic->fw.ucode_ver),
1117 IWL_UCODE_API(nic->fw.ucode_ver),
1118 IWL_UCODE_SERIAL(nic->fw.ucode_ver),
1119 buildstr);
1120
1121 /*
1122 * For any of the failures below (before allocating pci memory)
1123 * we will try to load a version with a smaller API -- maybe the
1124 * user just got a corrupted version of the latest API.
1125 */
1126
1127 IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
1128 nic->fw.ucode_ver);
1129 IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %Zd\n",
1130 pieces.inst_size);
1131 IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %Zd\n",
1132 pieces.data_size);
1133 IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %Zd\n",
1134 pieces.init_size);
1135 IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %Zd\n",
1136 pieces.init_data_size);
1137
1138 /* Verify that uCode images will fit in card's SRAM */
1139 if (pieces.inst_size > hw_params(priv).max_inst_size) {
1140 IWL_ERR(priv, "uCode instr len %Zd too large to fit in\n",
1141 pieces.inst_size);
1142 goto try_again;
1143 }
1144
1145 if (pieces.data_size > hw_params(priv).max_data_size) {
1146 IWL_ERR(priv, "uCode data len %Zd too large to fit in\n",
1147 pieces.data_size);
1148 goto try_again;
1149 }
1150
1151 if (pieces.init_size > hw_params(priv).max_inst_size) {
1152 IWL_ERR(priv, "uCode init instr len %Zd too large to fit in\n",
1153 pieces.init_size);
1154 goto try_again;
1155 }
1156
1157 if (pieces.init_data_size > hw_params(priv).max_data_size) {
1158 IWL_ERR(priv, "uCode init data len %Zd too large to fit in\n",
1159 pieces.init_data_size);
1160 goto try_again;
1161 }
1162
1163 /* Allocate ucode buffers for card's bus-master loading ... */
1164
1165 /* Runtime instructions and 2 copies of data:
1166 * 1) unmodified from disk
1167 * 2) backup cache for save/restore during power-downs */
1168 if (iwl_alloc_fw_desc(nic(priv), &nic(priv)->fw.ucode_rt.code,
1169 pieces.inst, pieces.inst_size))
1170 goto err_pci_alloc;
1171 if (iwl_alloc_fw_desc(nic(priv), &nic(priv)->fw.ucode_rt.data,
1172 pieces.data, pieces.data_size))
1173 goto err_pci_alloc;
1174
1175 /* Initialization instructions and data */
1176 if (pieces.init_size && pieces.init_data_size) {
1177 if (iwl_alloc_fw_desc(nic(priv),
1178 &nic(priv)->fw.ucode_init.code,
1179 pieces.init, pieces.init_size))
1180 goto err_pci_alloc;
1181 if (iwl_alloc_fw_desc(nic(priv),
1182 &nic(priv)->fw.ucode_init.data,
1183 pieces.init_data, pieces.init_data_size))
1184 goto err_pci_alloc;
1185 }
1186
1187 /* WoWLAN instructions and data */
1188 if (pieces.wowlan_inst_size && pieces.wowlan_data_size) {
1189 if (iwl_alloc_fw_desc(nic(priv),
1190 &nic(priv)->fw.ucode_wowlan.code,
1191 pieces.wowlan_inst,
1192 pieces.wowlan_inst_size))
1193 goto err_pci_alloc;
1194 if (iwl_alloc_fw_desc(nic(priv),
1195 &nic(priv)->fw.ucode_wowlan.data,
1196 pieces.wowlan_data,
1197 pieces.wowlan_data_size))
1198 goto err_pci_alloc;
1199 }
1200
1201 /* Now that we can no longer fail, copy information */
1202
1203 /*
1204 * The (size - 16) / 12 formula is based on the information recorded
1205 * for each event, which is of mode 1 (including timestamp) for all
1206 * new microcodes that include this information.
1207 */
1208 nic->init_evtlog_ptr = pieces.init_evtlog_ptr;
1209 if (pieces.init_evtlog_size)
1210 nic->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
1211 else
1212 nic->init_evtlog_size =
1213 cfg(priv)->base_params->max_event_log_size;
1214 nic->init_errlog_ptr = pieces.init_errlog_ptr;
1215 nic->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
1216 if (pieces.inst_evtlog_size)
1217 nic->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
1218 else
1219 nic->inst_evtlog_size =
1220 cfg(priv)->base_params->max_event_log_size;
1221 nic->inst_errlog_ptr = pieces.inst_errlog_ptr;
1222 #ifndef CONFIG_IWLWIFI_P2P
1223 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
1224 #endif
1225
1226 priv->new_scan_threshold_behaviour =
1227 !!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
1228
1229 if (!(cfg(priv)->sku & EEPROM_SKU_CAP_IPAN_ENABLE))
1230 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
1231
1232 /*
1233 * if not PAN, then don't support P2P -- might be a uCode
1234 * packaging bug or due to the eeprom check above
1235 */
1236 if (!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN))
1237 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_P2P;
1238
1239 if (ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN) {
1240 priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
1241 priv->shrd->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
1242 } else {
1243 priv->sta_key_max_num = STA_KEY_MAX_NUM;
1244 priv->shrd->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
1245 }
1246 /*
1247 * figure out the offset of chain noise reset and gain commands
1248 * base on the size of standard phy calibration commands table size
1249 */
1250 if (ucode_capa.standard_phy_calibration_size >
1251 IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1252 ucode_capa.standard_phy_calibration_size =
1253 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1254
1255 priv->phy_calib_chain_noise_reset_cmd =
1256 ucode_capa.standard_phy_calibration_size;
1257 priv->phy_calib_chain_noise_gain_cmd =
1258 ucode_capa.standard_phy_calibration_size + 1;
1259
1260 /* initialize all valid contexts */
1261 iwl_init_context(priv, ucode_capa.flags);
1262
1263 /**************************************************
1264 * This is still part of probe() in a sense...
1265 *
1266 * 9. Setup and register with mac80211 and debugfs
1267 **************************************************/
1268 err = iwlagn_mac_setup_register(priv, &ucode_capa);
1269 if (err)
1270 goto out_unbind;
1271
1272 err = iwl_dbgfs_register(priv, DRV_NAME);
1273 if (err)
1274 IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);
1275
1276 /* We have our copies now, allow OS release its copies */
1277 release_firmware(ucode_raw);
1278 complete(&nic->request_firmware_complete);
1279 return;
1280
1281 try_again:
1282 /* try next, if any */
1283 if (iwl_request_firmware(priv, false))
1284 goto out_unbind;
1285 release_firmware(ucode_raw);
1286 return;
1287
1288 err_pci_alloc:
1289 IWL_ERR(priv, "failed to allocate pci memory\n");
1290 iwl_dealloc_ucode(nic(priv));
1291 out_unbind:
1292 complete(&nic->request_firmware_complete);
1293 device_release_driver(trans(priv)->dev);
1294 release_firmware(ucode_raw);
1295 }
1296
Linus' kernel tree