1 /******************************************************************************
5 * Copyright(c) 2008 - 2012 Intel Corporation. All rights reserved.
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.
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.
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,
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
24 * Contact Information:
25 * Intel Linux Wireless <ilw@linux.intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
28 *****************************************************************************/
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>
37 #include "iwl-ucode.h"
42 #include "iwl-agn-hw.h"
44 #include "iwl-agn-calib.h"
45 #include "iwl-trans.h"
47 #include "iwl-op-mode.h"
49 static struct iwl_wimax_coex_event_entry cu_priorities[COEX_NUM_OF_EVENTS] = {
50 {COEX_CU_UNASSOC_IDLE_RP, COEX_CU_UNASSOC_IDLE_WP,
51 0, COEX_UNASSOC_IDLE_FLAGS},
52 {COEX_CU_UNASSOC_MANUAL_SCAN_RP, COEX_CU_UNASSOC_MANUAL_SCAN_WP,
53 0, COEX_UNASSOC_MANUAL_SCAN_FLAGS},
54 {COEX_CU_UNASSOC_AUTO_SCAN_RP, COEX_CU_UNASSOC_AUTO_SCAN_WP,
55 0, COEX_UNASSOC_AUTO_SCAN_FLAGS},
56 {COEX_CU_CALIBRATION_RP, COEX_CU_CALIBRATION_WP,
57 0, COEX_CALIBRATION_FLAGS},
58 {COEX_CU_PERIODIC_CALIBRATION_RP, COEX_CU_PERIODIC_CALIBRATION_WP,
59 0, COEX_PERIODIC_CALIBRATION_FLAGS},
60 {COEX_CU_CONNECTION_ESTAB_RP, COEX_CU_CONNECTION_ESTAB_WP,
61 0, COEX_CONNECTION_ESTAB_FLAGS},
62 {COEX_CU_ASSOCIATED_IDLE_RP, COEX_CU_ASSOCIATED_IDLE_WP,
63 0, COEX_ASSOCIATED_IDLE_FLAGS},
64 {COEX_CU_ASSOC_MANUAL_SCAN_RP, COEX_CU_ASSOC_MANUAL_SCAN_WP,
65 0, COEX_ASSOC_MANUAL_SCAN_FLAGS},
66 {COEX_CU_ASSOC_AUTO_SCAN_RP, COEX_CU_ASSOC_AUTO_SCAN_WP,
67 0, COEX_ASSOC_AUTO_SCAN_FLAGS},
68 {COEX_CU_ASSOC_ACTIVE_LEVEL_RP, COEX_CU_ASSOC_ACTIVE_LEVEL_WP,
69 0, COEX_ASSOC_ACTIVE_LEVEL_FLAGS},
70 {COEX_CU_RF_ON_RP, COEX_CU_RF_ON_WP, 0, COEX_CU_RF_ON_FLAGS},
71 {COEX_CU_RF_OFF_RP, COEX_CU_RF_OFF_WP, 0, COEX_RF_OFF_FLAGS},
72 {COEX_CU_STAND_ALONE_DEBUG_RP, COEX_CU_STAND_ALONE_DEBUG_WP,
73 0, COEX_STAND_ALONE_DEBUG_FLAGS},
74 {COEX_CU_IPAN_ASSOC_LEVEL_RP, COEX_CU_IPAN_ASSOC_LEVEL_WP,
75 0, COEX_IPAN_ASSOC_LEVEL_FLAGS},
76 {COEX_CU_RSRVD1_RP, COEX_CU_RSRVD1_WP, 0, COEX_RSRVD1_FLAGS},
77 {COEX_CU_RSRVD2_RP, COEX_CU_RSRVD2_WP, 0, COEX_RSRVD2_FLAGS}
80 /******************************************************************************
82 * uCode download functions
84 ******************************************************************************/
86 static void iwl_free_fw_desc(struct iwl_nic *nic, struct fw_desc *desc)
89 dma_free_coherent(trans(nic)->dev, desc->len,
90 desc->v_addr, desc->p_addr);
95 static void iwl_free_fw_img(struct iwl_nic *nic, struct fw_img *img)
97 iwl_free_fw_desc(nic, &img->code);
98 iwl_free_fw_desc(nic, &img->data);
101 void iwl_dealloc_ucode(struct iwl_nic *nic)
103 iwl_free_fw_img(nic, &nic->fw.ucode_rt);
104 iwl_free_fw_img(nic, &nic->fw.ucode_init);
105 iwl_free_fw_img(nic, &nic->fw.ucode_wowlan);
108 static int iwl_alloc_fw_desc(struct iwl_nic *nic, struct fw_desc *desc,
109 const void *data, size_t len)
116 desc->v_addr = dma_alloc_coherent(trans(nic)->dev, len,
117 &desc->p_addr, GFP_KERNEL);
122 memcpy(desc->v_addr, data, len);
126 static inline struct fw_img *iwl_get_ucode_image(struct iwl_nic *nic,
127 enum iwl_ucode_type ucode_type)
129 switch (ucode_type) {
131 return &nic->fw.ucode_init;
132 case IWL_UCODE_WOWLAN:
133 return &nic->fw.ucode_wowlan;
134 case IWL_UCODE_REGULAR:
135 return &nic->fw.ucode_rt;
145 static int iwl_set_Xtal_calib(struct iwl_trans *trans)
147 struct iwl_calib_xtal_freq_cmd cmd;
149 (__le16 *)iwl_eeprom_query_addr(trans->shrd, EEPROM_XTAL);
151 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD);
152 cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]);
153 cmd.cap_pin2 = le16_to_cpu(xtal_calib[1]);
154 return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
157 static int iwl_set_temperature_offset_calib(struct iwl_trans *trans)
159 struct iwl_calib_temperature_offset_cmd cmd;
160 __le16 *offset_calib =
161 (__le16 *)iwl_eeprom_query_addr(trans->shrd,
162 EEPROM_RAW_TEMPERATURE);
164 memset(&cmd, 0, sizeof(cmd));
165 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
166 memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(*offset_calib));
167 if (!(cmd.radio_sensor_offset))
168 cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET;
170 IWL_DEBUG_CALIB(trans, "Radio sensor offset: %d\n",
171 le16_to_cpu(cmd.radio_sensor_offset));
172 return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
175 static int iwl_set_temperature_offset_calib_v2(struct iwl_trans *trans)
177 struct iwl_calib_temperature_offset_v2_cmd cmd;
178 __le16 *offset_calib_high = (__le16 *)iwl_eeprom_query_addr(trans->shrd,
179 EEPROM_KELVIN_TEMPERATURE);
180 __le16 *offset_calib_low =
181 (__le16 *)iwl_eeprom_query_addr(trans->shrd,
182 EEPROM_RAW_TEMPERATURE);
183 struct iwl_eeprom_calib_hdr *hdr;
185 memset(&cmd, 0, sizeof(cmd));
186 iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD);
187 hdr = (struct iwl_eeprom_calib_hdr *)iwl_eeprom_query_addr(trans->shrd,
189 memcpy(&cmd.radio_sensor_offset_high, offset_calib_high,
190 sizeof(*offset_calib_high));
191 memcpy(&cmd.radio_sensor_offset_low, offset_calib_low,
192 sizeof(*offset_calib_low));
193 if (!(cmd.radio_sensor_offset_low)) {
194 IWL_DEBUG_CALIB(trans, "no info in EEPROM, use default\n");
195 cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET;
196 cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET;
198 memcpy(&cmd.burntVoltageRef, &hdr->voltage,
199 sizeof(hdr->voltage));
201 IWL_DEBUG_CALIB(trans, "Radio sensor offset high: %d\n",
202 le16_to_cpu(cmd.radio_sensor_offset_high));
203 IWL_DEBUG_CALIB(trans, "Radio sensor offset low: %d\n",
204 le16_to_cpu(cmd.radio_sensor_offset_low));
205 IWL_DEBUG_CALIB(trans, "Voltage Ref: %d\n",
206 le16_to_cpu(cmd.burntVoltageRef));
208 return iwl_calib_set(trans, (void *)&cmd, sizeof(cmd));
211 static int iwl_send_calib_cfg(struct iwl_trans *trans)
213 struct iwl_calib_cfg_cmd calib_cfg_cmd;
214 struct iwl_host_cmd cmd = {
215 .id = CALIBRATION_CFG_CMD,
216 .len = { sizeof(struct iwl_calib_cfg_cmd), },
217 .data = { &calib_cfg_cmd, },
220 memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
221 calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
222 calib_cfg_cmd.ucd_calib_cfg.once.start = IWL_CALIB_INIT_CFG_ALL;
223 calib_cfg_cmd.ucd_calib_cfg.once.send_res = IWL_CALIB_INIT_CFG_ALL;
224 calib_cfg_cmd.ucd_calib_cfg.flags =
225 IWL_CALIB_CFG_FLAG_SEND_COMPLETE_NTFY_MSK;
227 return iwl_trans_send_cmd(trans, &cmd);
230 int iwlagn_rx_calib_result(struct iwl_priv *priv,
231 struct iwl_rx_mem_buffer *rxb,
232 struct iwl_device_cmd *cmd)
234 struct iwl_rx_packet *pkt = rxb_addr(rxb);
235 struct iwl_calib_hdr *hdr = (struct iwl_calib_hdr *)pkt->u.raw;
236 int len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
238 /* reduce the size of the length field itself */
241 if (iwl_calib_set(trans(priv), hdr, len))
242 IWL_ERR(priv, "Failed to record calibration data %d\n",
248 int iwl_init_alive_start(struct iwl_trans *trans)
252 if (cfg(trans)->bt_params &&
253 cfg(trans)->bt_params->advanced_bt_coexist) {
255 * Tell uCode we are ready to perform calibration
256 * need to perform this before any calibration
257 * no need to close the envlope since we are going
258 * to load the runtime uCode later.
260 ret = iwl_send_bt_env(trans, IWL_BT_COEX_ENV_OPEN,
261 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
267 ret = iwl_send_calib_cfg(trans);
272 * temperature offset calibration is only needed for runtime ucode,
273 * so prepare the value now.
275 if (cfg(trans)->need_temp_offset_calib) {
276 if (cfg(trans)->temp_offset_v2)
277 return iwl_set_temperature_offset_calib_v2(trans);
279 return iwl_set_temperature_offset_calib(trans);
285 static int iwl_send_wimax_coex(struct iwl_trans *trans)
287 struct iwl_wimax_coex_cmd coex_cmd;
289 if (cfg(trans)->base_params->support_wimax_coexist) {
290 /* UnMask wake up src at associated sleep */
291 coex_cmd.flags = COEX_FLAGS_ASSOC_WA_UNMASK_MSK;
293 /* UnMask wake up src at unassociated sleep */
294 coex_cmd.flags |= COEX_FLAGS_UNASSOC_WA_UNMASK_MSK;
295 memcpy(coex_cmd.sta_prio, cu_priorities,
296 sizeof(struct iwl_wimax_coex_event_entry) *
299 /* enabling the coexistence feature */
300 coex_cmd.flags |= COEX_FLAGS_COEX_ENABLE_MSK;
302 /* enabling the priorities tables */
303 coex_cmd.flags |= COEX_FLAGS_STA_TABLE_VALID_MSK;
305 /* coexistence is disabled */
306 memset(&coex_cmd, 0, sizeof(coex_cmd));
308 return iwl_trans_send_cmd_pdu(trans,
309 COEX_PRIORITY_TABLE_CMD, CMD_SYNC,
310 sizeof(coex_cmd), &coex_cmd);
313 static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
314 ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
315 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
316 ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
317 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
318 ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
319 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
320 ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
321 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
322 ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
323 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
324 ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
325 (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
326 ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
327 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
328 ((BT_COEX_PRIO_TBL_PRIO_COEX_OFF << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
329 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
330 ((BT_COEX_PRIO_TBL_PRIO_COEX_ON << IWL_BT_COEX_PRIO_TBL_PRIO_POS) |
331 (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)),
335 void iwl_send_prio_tbl(struct iwl_trans *trans)
337 struct iwl_bt_coex_prio_table_cmd prio_tbl_cmd;
339 memcpy(prio_tbl_cmd.prio_tbl, iwl_bt_prio_tbl,
340 sizeof(iwl_bt_prio_tbl));
341 if (iwl_trans_send_cmd_pdu(trans,
342 REPLY_BT_COEX_PRIO_TABLE, CMD_SYNC,
343 sizeof(prio_tbl_cmd), &prio_tbl_cmd))
344 IWL_ERR(trans, "failed to send BT prio tbl command\n");
347 int iwl_send_bt_env(struct iwl_trans *trans, u8 action, u8 type)
349 struct iwl_bt_coex_prot_env_cmd env_cmd;
352 env_cmd.action = action;
354 ret = iwl_trans_send_cmd_pdu(trans,
355 REPLY_BT_COEX_PROT_ENV, CMD_SYNC,
356 sizeof(env_cmd), &env_cmd);
358 IWL_ERR(trans, "failed to send BT env command\n");
363 static int iwl_alive_notify(struct iwl_trans *trans)
365 struct iwl_priv *priv = priv(trans);
366 struct iwl_rxon_context *ctx;
369 if (!priv->tx_cmd_pool)
371 kmem_cache_create("iwl_dev_cmd",
372 sizeof(struct iwl_device_cmd),
373 sizeof(void *), 0, NULL);
375 if (!priv->tx_cmd_pool)
378 iwl_trans_fw_alive(trans);
379 for_each_context(priv, ctx)
380 ctx->last_tx_rejected = false;
382 ret = iwl_send_wimax_coex(trans);
386 if (!cfg(priv)->no_xtal_calib) {
387 ret = iwl_set_Xtal_calib(trans);
392 return iwl_send_calib_results(trans);
397 * iwl_verify_inst_sparse - verify runtime uCode image in card vs. host,
398 * using sample data 100 bytes apart. If these sample points are good,
399 * it's a pretty good bet that everything between them is good, too.
401 static int iwl_verify_inst_sparse(struct iwl_nic *nic,
402 struct fw_desc *fw_desc)
404 struct iwl_trans *trans = trans(nic);
405 __le32 *image = (__le32 *)fw_desc->v_addr;
406 u32 len = fw_desc->len;
410 IWL_DEBUG_FW(nic, "ucode inst image size is %u\n", len);
412 for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) {
413 /* read data comes through single port, auto-incr addr */
414 /* NOTE: Use the debugless read so we don't flood kernel log
415 * if IWL_DL_IO is set */
416 iwl_write_direct32(trans, HBUS_TARG_MEM_RADDR,
417 i + IWLAGN_RTC_INST_LOWER_BOUND);
418 val = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
419 if (val != le32_to_cpu(*image))
426 static void iwl_print_mismatch_inst(struct iwl_nic *nic,
427 struct fw_desc *fw_desc)
429 struct iwl_trans *trans = trans(nic);
430 __le32 *image = (__le32 *)fw_desc->v_addr;
431 u32 len = fw_desc->len;
436 IWL_DEBUG_FW(nic, "ucode inst image size is %u\n", len);
438 iwl_write_direct32(trans, HBUS_TARG_MEM_RADDR,
439 IWLAGN_RTC_INST_LOWER_BOUND);
442 offs < len && errors < 20;
443 offs += sizeof(u32), image++) {
444 /* read data comes through single port, auto-incr addr */
445 val = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
446 if (val != le32_to_cpu(*image)) {
447 IWL_ERR(nic, "uCode INST section at "
448 "offset 0x%x, is 0x%x, s/b 0x%x\n",
449 offs, val, le32_to_cpu(*image));
456 * iwl_verify_ucode - determine which instruction image is in SRAM,
457 * and verify its contents
459 static int iwl_verify_ucode(struct iwl_nic *nic,
460 enum iwl_ucode_type ucode_type)
462 struct fw_img *img = iwl_get_ucode_image(nic, ucode_type);
465 IWL_ERR(nic, "Invalid ucode requested (%d)\n", ucode_type);
469 if (!iwl_verify_inst_sparse(nic, &img->code)) {
470 IWL_DEBUG_FW(nic, "uCode is good in inst SRAM\n");
474 IWL_ERR(nic, "UCODE IMAGE IN INSTRUCTION SRAM NOT VALID!!\n");
476 iwl_print_mismatch_inst(nic, &img->code);
480 struct iwl_alive_data {
485 static void iwl_alive_fn(struct iwl_trans *trans,
486 struct iwl_rx_packet *pkt,
489 struct iwl_alive_data *alive_data = data;
490 struct iwl_alive_resp *palive;
492 palive = &pkt->u.alive_frame;
494 IWL_DEBUG_FW(trans, "Alive ucode status 0x%08X revision "
496 palive->is_valid, palive->ver_type,
497 palive->ver_subtype);
499 trans->shrd->device_pointers.error_event_table =
500 le32_to_cpu(palive->error_event_table_ptr);
501 trans->shrd->device_pointers.log_event_table =
502 le32_to_cpu(palive->log_event_table_ptr);
504 alive_data->subtype = palive->ver_subtype;
505 alive_data->valid = palive->is_valid == UCODE_VALID_OK;
508 /* notification wait support */
509 void iwl_init_notification_wait(struct iwl_shared *shrd,
510 struct iwl_notification_wait *wait_entry,
512 void (*fn)(struct iwl_trans *trans,
513 struct iwl_rx_packet *pkt,
518 wait_entry->fn_data = fn_data;
519 wait_entry->cmd = cmd;
520 wait_entry->triggered = false;
521 wait_entry->aborted = false;
523 spin_lock_bh(&shrd->notif_wait_lock);
524 list_add(&wait_entry->list, &shrd->notif_waits);
525 spin_unlock_bh(&shrd->notif_wait_lock);
528 int iwl_wait_notification(struct iwl_shared *shrd,
529 struct iwl_notification_wait *wait_entry,
530 unsigned long timeout)
534 ret = wait_event_timeout(shrd->notif_waitq,
535 wait_entry->triggered || wait_entry->aborted,
538 spin_lock_bh(&shrd->notif_wait_lock);
539 list_del(&wait_entry->list);
540 spin_unlock_bh(&shrd->notif_wait_lock);
542 if (wait_entry->aborted)
545 /* return value is always >= 0 */
551 void iwl_remove_notification(struct iwl_shared *shrd,
552 struct iwl_notification_wait *wait_entry)
554 spin_lock_bh(&shrd->notif_wait_lock);
555 list_del(&wait_entry->list);
556 spin_unlock_bh(&shrd->notif_wait_lock);
559 void iwl_abort_notification_waits(struct iwl_shared *shrd)
562 struct iwl_notification_wait *wait_entry;
564 spin_lock_irqsave(&shrd->notif_wait_lock, flags);
565 list_for_each_entry(wait_entry, &shrd->notif_waits, list)
566 wait_entry->aborted = true;
567 spin_unlock_irqrestore(&shrd->notif_wait_lock, flags);
569 wake_up_all(&shrd->notif_waitq);
572 #define UCODE_ALIVE_TIMEOUT HZ
573 #define UCODE_CALIB_TIMEOUT (2*HZ)
575 int iwl_load_ucode_wait_alive(struct iwl_trans *trans,
576 enum iwl_ucode_type ucode_type)
578 struct iwl_notification_wait alive_wait;
579 struct iwl_alive_data alive_data;
582 enum iwl_ucode_type old_type;
584 iwl_init_notification_wait(trans->shrd, &alive_wait, REPLY_ALIVE,
585 iwl_alive_fn, &alive_data);
587 old_type = trans->shrd->ucode_type;
588 trans->shrd->ucode_type = ucode_type;
589 fw = iwl_get_ucode_image(nic(trans), ucode_type);
594 ret = iwl_trans_start_fw(trans, fw);
596 trans->shrd->ucode_type = old_type;
597 iwl_remove_notification(trans->shrd, &alive_wait);
602 * Some things may run in the background now, but we
603 * just wait for the ALIVE notification here.
605 ret = iwl_wait_notification(trans->shrd, &alive_wait,
606 UCODE_ALIVE_TIMEOUT);
608 trans->shrd->ucode_type = old_type;
612 if (!alive_data.valid) {
613 IWL_ERR(trans, "Loaded ucode is not valid!\n");
614 trans->shrd->ucode_type = old_type;
619 * This step takes a long time (60-80ms!!) and
620 * WoWLAN image should be loaded quickly, so
621 * skip it for WoWLAN.
623 if (ucode_type != IWL_UCODE_WOWLAN) {
624 ret = iwl_verify_ucode(nic(trans), ucode_type);
626 trans->shrd->ucode_type = old_type;
630 /* delay a bit to give rfkill time to run */
634 ret = iwl_alive_notify(trans);
637 "Could not complete ALIVE transition: %d\n", ret);
638 trans->shrd->ucode_type = old_type;
645 int iwl_run_init_ucode(struct iwl_trans *trans)
647 struct iwl_notification_wait calib_wait;
650 lockdep_assert_held(&trans->shrd->mutex);
652 /* No init ucode required? Curious, but maybe ok */
653 if (!nic(trans)->fw.ucode_init.code.len)
656 if (trans->shrd->ucode_type != IWL_UCODE_NONE)
659 iwl_init_notification_wait(trans->shrd, &calib_wait,
660 CALIBRATION_COMPLETE_NOTIFICATION,
663 /* Will also start the device */
664 ret = iwl_load_ucode_wait_alive(trans, IWL_UCODE_INIT);
668 ret = iwl_init_alive_start(trans);
673 * Some things may run in the background now, but we
674 * just wait for the calibration complete notification.
676 ret = iwl_wait_notification(trans->shrd, &calib_wait,
677 UCODE_CALIB_TIMEOUT);
682 iwl_remove_notification(trans->shrd, &calib_wait);
684 /* Whatever happened, stop the device */
685 iwl_trans_stop_device(trans);
689 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
691 #define UCODE_EXPERIMENTAL_TAG "exp"
693 int __must_check iwl_request_firmware(struct iwl_nic *nic, bool first)
695 struct iwl_cfg *cfg = cfg(nic);
696 const char *name_pre = cfg->fw_name_pre;
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) {
705 nic->fw_index = cfg->ucode_api_max;
706 sprintf(tag, "%d", nic->fw_index);
709 sprintf(tag, "%d", nic->fw_index);
712 if (nic->fw_index < cfg->ucode_api_min) {
713 IWL_ERR(nic, "no suitable firmware found!\n");
717 sprintf(nic->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
719 IWL_DEBUG_INFO(nic, "attempting to load firmware %s'%s'\n",
720 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
721 ? "EXPERIMENTAL " : "",
724 return request_firmware_nowait(THIS_MODULE, 1, nic->firmware_name,
726 GFP_KERNEL, nic, iwl_ucode_callback);
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;
734 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
735 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
738 static int iwl_parse_v1_v2_firmware(struct iwl_nic *nic,
739 const struct firmware *ucode_raw,
740 struct iwlagn_firmware_pieces *pieces)
742 struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
743 u32 api_ver, hdr_size, build;
747 nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
748 api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
753 if (ucode_raw->size < hdr_size) {
754 IWL_ERR(nic, "File size too small!\n");
757 build = le32_to_cpu(ucode->u.v2.build);
758 pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
759 pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
760 pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
761 pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
762 src = ucode->u.v2.data;
768 if (ucode_raw->size < hdr_size) {
769 IWL_ERR(nic, "File size too small!\n");
773 pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
774 pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
775 pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
776 pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
777 src = ucode->u.v1.data;
782 sprintf(buildstr, " build %u%s", build,
783 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
788 snprintf(nic->fw.fw_version,
789 sizeof(nic->fw.fw_version),
791 IWL_UCODE_MAJOR(nic->fw.ucode_ver),
792 IWL_UCODE_MINOR(nic->fw.ucode_ver),
793 IWL_UCODE_API(nic->fw.ucode_ver),
794 IWL_UCODE_SERIAL(nic->fw.ucode_ver),
797 /* Verify size of file vs. image size info in file's header */
798 if (ucode_raw->size != hdr_size + pieces->inst_size +
799 pieces->data_size + pieces->init_size +
800 pieces->init_data_size) {
803 "uCode file size %d does not match expected size\n",
804 (int)ucode_raw->size);
809 src += pieces->inst_size;
811 src += pieces->data_size;
813 src += pieces->init_size;
814 pieces->init_data = src;
815 src += pieces->init_data_size;
820 static int iwl_parse_tlv_firmware(struct iwl_nic *nic,
821 const struct firmware *ucode_raw,
822 struct iwlagn_firmware_pieces *pieces,
823 struct iwl_ucode_capabilities *capa)
825 struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
826 struct iwl_ucode_tlv *tlv;
827 size_t len = ucode_raw->size;
829 int wanted_alternative = iwlagn_mod_params.wanted_ucode_alternative;
833 enum iwl_ucode_tlv_type tlv_type;
838 if (len < sizeof(*ucode)) {
839 IWL_ERR(nic, "uCode has invalid length: %zd\n", len);
843 if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
844 IWL_ERR(nic, "invalid uCode magic: 0X%x\n",
845 le32_to_cpu(ucode->magic));
850 * Check which alternatives are present, and "downgrade"
851 * when the chosen alternative is not present, warning
852 * the user when that happens. Some files may not have
853 * any alternatives, so don't warn in that case.
855 alternatives = le64_to_cpu(ucode->alternatives);
856 tmp = wanted_alternative;
857 if (wanted_alternative > 63)
858 wanted_alternative = 63;
859 while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
860 wanted_alternative--;
861 if (wanted_alternative && wanted_alternative != tmp)
863 "uCode alternative %d not available, choosing %d\n",
864 tmp, wanted_alternative);
866 nic->fw.ucode_ver = le32_to_cpu(ucode->ver);
867 build = le32_to_cpu(ucode->build);
870 sprintf(buildstr, " build %u%s", build,
871 (nic->fw_index == UCODE_EXPERIMENTAL_INDEX)
876 snprintf(nic->fw.fw_version,
877 sizeof(nic->fw.fw_version),
879 IWL_UCODE_MAJOR(nic->fw.ucode_ver),
880 IWL_UCODE_MINOR(nic->fw.ucode_ver),
881 IWL_UCODE_API(nic->fw.ucode_ver),
882 IWL_UCODE_SERIAL(nic->fw.ucode_ver),
887 len -= sizeof(*ucode);
889 while (len >= sizeof(*tlv)) {
895 tlv_len = le32_to_cpu(tlv->length);
896 tlv_type = le16_to_cpu(tlv->type);
897 tlv_alt = le16_to_cpu(tlv->alternative);
898 tlv_data = tlv->data;
901 IWL_ERR(nic, "invalid TLV len: %zd/%u\n",
905 len -= ALIGN(tlv_len, 4);
906 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
909 * Alternative 0 is always valid.
911 * Skip alternative TLVs that are not selected.
913 if (tlv_alt != 0 && tlv_alt != wanted_alternative)
917 case IWL_UCODE_TLV_INST:
918 pieces->inst = tlv_data;
919 pieces->inst_size = tlv_len;
921 case IWL_UCODE_TLV_DATA:
922 pieces->data = tlv_data;
923 pieces->data_size = tlv_len;
925 case IWL_UCODE_TLV_INIT:
926 pieces->init = tlv_data;
927 pieces->init_size = tlv_len;
929 case IWL_UCODE_TLV_INIT_DATA:
930 pieces->init_data = tlv_data;
931 pieces->init_data_size = tlv_len;
933 case IWL_UCODE_TLV_BOOT:
934 IWL_ERR(nic, "Found unexpected BOOT ucode\n");
936 case IWL_UCODE_TLV_PROBE_MAX_LEN:
937 if (tlv_len != sizeof(u32))
938 goto invalid_tlv_len;
939 capa->max_probe_length =
940 le32_to_cpup((__le32 *)tlv_data);
942 case IWL_UCODE_TLV_PAN:
944 goto invalid_tlv_len;
945 capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
947 case IWL_UCODE_TLV_FLAGS:
948 /* must be at least one u32 */
949 if (tlv_len < sizeof(u32))
950 goto invalid_tlv_len;
951 /* and a proper number of u32s */
952 if (tlv_len % sizeof(u32))
953 goto invalid_tlv_len;
955 * This driver only reads the first u32 as
956 * right now no more features are defined,
957 * if that changes then either the driver
958 * will not work with the new firmware, or
959 * it'll not take advantage of new features.
961 capa->flags = le32_to_cpup((__le32 *)tlv_data);
963 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
964 if (tlv_len != sizeof(u32))
965 goto invalid_tlv_len;
966 pieces->init_evtlog_ptr =
967 le32_to_cpup((__le32 *)tlv_data);
969 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
970 if (tlv_len != sizeof(u32))
971 goto invalid_tlv_len;
972 pieces->init_evtlog_size =
973 le32_to_cpup((__le32 *)tlv_data);
975 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
976 if (tlv_len != sizeof(u32))
977 goto invalid_tlv_len;
978 pieces->init_errlog_ptr =
979 le32_to_cpup((__le32 *)tlv_data);
981 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
982 if (tlv_len != sizeof(u32))
983 goto invalid_tlv_len;
984 pieces->inst_evtlog_ptr =
985 le32_to_cpup((__le32 *)tlv_data);
987 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
988 if (tlv_len != sizeof(u32))
989 goto invalid_tlv_len;
990 pieces->inst_evtlog_size =
991 le32_to_cpup((__le32 *)tlv_data);
993 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
994 if (tlv_len != sizeof(u32))
995 goto invalid_tlv_len;
996 pieces->inst_errlog_ptr =
997 le32_to_cpup((__le32 *)tlv_data);
999 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
1001 goto invalid_tlv_len;
1002 nic->fw.enhance_sensitivity_table = true;
1004 case IWL_UCODE_TLV_WOWLAN_INST:
1005 pieces->wowlan_inst = tlv_data;
1006 pieces->wowlan_inst_size = tlv_len;
1008 case IWL_UCODE_TLV_WOWLAN_DATA:
1009 pieces->wowlan_data = tlv_data;
1010 pieces->wowlan_data_size = tlv_len;
1012 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
1013 if (tlv_len != sizeof(u32))
1014 goto invalid_tlv_len;
1015 capa->standard_phy_calibration_size =
1016 le32_to_cpup((__le32 *)tlv_data);
1019 IWL_DEBUG_INFO(nic, "unknown TLV: %d\n", tlv_type);
1025 IWL_ERR(nic, "invalid TLV after parsing: %zd\n", len);
1026 iwl_print_hex_dump(nic, IWL_DL_FW, (u8 *)data, len);
1033 IWL_ERR(nic, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
1034 iwl_print_hex_dump(nic, IWL_DL_FW, tlv_data, tlv_len);
1040 * iwl_ucode_callback - callback when firmware was loaded
1042 * If loaded successfully, copies the firmware into buffers
1043 * for the card to fetch (via DMA).
1045 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
1047 struct iwl_nic *nic = context;
1048 struct iwl_cfg *cfg = cfg(nic);
1049 struct iwl_fw *fw = &nic->fw;
1050 struct iwl_ucode_header *ucode;
1052 struct iwlagn_firmware_pieces pieces;
1053 const unsigned int api_max = cfg->ucode_api_max;
1054 unsigned int api_ok = cfg->ucode_api_ok;
1055 const unsigned int api_min = cfg->ucode_api_min;
1058 fw->ucode_capa.max_probe_length = 200;
1059 fw->ucode_capa.standard_phy_calibration_size =
1060 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1065 memset(&pieces, 0, sizeof(pieces));
1068 if (nic->fw_index <= api_ok)
1070 "request for firmware file '%s' failed.\n",
1071 nic->firmware_name);
1075 IWL_DEBUG_INFO(nic, "Loaded firmware file '%s' (%zd bytes).\n",
1076 nic->firmware_name, ucode_raw->size);
1078 /* Make sure that we got at least the API version number */
1079 if (ucode_raw->size < 4) {
1080 IWL_ERR(nic, "File size way too small!\n");
1084 /* Data from ucode file: header followed by uCode images */
1085 ucode = (struct iwl_ucode_header *)ucode_raw->data;
1088 err = iwl_parse_v1_v2_firmware(nic, ucode_raw, &pieces);
1090 err = iwl_parse_tlv_firmware(nic, ucode_raw, &pieces,
1096 api_ver = IWL_UCODE_API(nic->fw.ucode_ver);
1099 * api_ver should match the api version forming part of the
1100 * firmware filename ... but we don't check for that and only rely
1101 * on the API version read from firmware header from here on forward
1103 /* no api version check required for experimental uCode */
1104 if (nic->fw_index != UCODE_EXPERIMENTAL_INDEX) {
1105 if (api_ver < api_min || api_ver > api_max) {
1107 "Driver unable to support your firmware API. "
1108 "Driver supports v%u, firmware is v%u.\n",
1113 if (api_ver < api_ok) {
1114 if (api_ok != api_max)
1115 IWL_ERR(nic, "Firmware has old API version, "
1116 "expected v%u through v%u, got v%u.\n",
1117 api_ok, api_max, api_ver);
1119 IWL_ERR(nic, "Firmware has old API version, "
1120 "expected v%u, got v%u.\n",
1122 IWL_ERR(nic, "New firmware can be obtained from "
1123 "http://www.intellinuxwireless.org/.\n");
1127 IWL_INFO(nic, "loaded firmware version %s", nic->fw.fw_version);
1130 * For any of the failures below (before allocating pci memory)
1131 * we will try to load a version with a smaller API -- maybe the
1132 * user just got a corrupted version of the latest API.
1135 IWL_DEBUG_INFO(nic, "f/w package hdr ucode version raw = 0x%x\n",
1137 IWL_DEBUG_INFO(nic, "f/w package hdr runtime inst size = %Zd\n",
1139 IWL_DEBUG_INFO(nic, "f/w package hdr runtime data size = %Zd\n",
1141 IWL_DEBUG_INFO(nic, "f/w package hdr init inst size = %Zd\n",
1143 IWL_DEBUG_INFO(nic, "f/w package hdr init data size = %Zd\n",
1144 pieces.init_data_size);
1146 /* Verify that uCode images will fit in card's SRAM */
1147 if (pieces.inst_size > cfg->max_inst_size) {
1148 IWL_ERR(nic, "uCode instr len %Zd too large to fit in\n",
1153 if (pieces.data_size > cfg->max_data_size) {
1154 IWL_ERR(nic, "uCode data len %Zd too large to fit in\n",
1159 if (pieces.init_size > cfg->max_inst_size) {
1160 IWL_ERR(nic, "uCode init instr len %Zd too large to fit in\n",
1165 if (pieces.init_data_size > cfg->max_data_size) {
1166 IWL_ERR(nic, "uCode init data len %Zd too large to fit in\n",
1167 pieces.init_data_size);
1171 /* Allocate ucode buffers for card's bus-master loading ... */
1173 /* Runtime instructions and 2 copies of data:
1174 * 1) unmodified from disk
1175 * 2) backup cache for save/restore during power-downs */
1176 if (iwl_alloc_fw_desc(nic, &nic->fw.ucode_rt.code,
1177 pieces.inst, pieces.inst_size))
1179 if (iwl_alloc_fw_desc(nic, &nic->fw.ucode_rt.data,
1180 pieces.data, pieces.data_size))
1183 /* Initialization instructions and data */
1184 if (pieces.init_size && pieces.init_data_size) {
1185 if (iwl_alloc_fw_desc(nic,
1186 &nic->fw.ucode_init.code,
1187 pieces.init, pieces.init_size))
1189 if (iwl_alloc_fw_desc(nic,
1190 &nic->fw.ucode_init.data,
1191 pieces.init_data, pieces.init_data_size))
1195 /* WoWLAN instructions and data */
1196 if (pieces.wowlan_inst_size && pieces.wowlan_data_size) {
1197 if (iwl_alloc_fw_desc(nic,
1198 &nic->fw.ucode_wowlan.code,
1200 pieces.wowlan_inst_size))
1202 if (iwl_alloc_fw_desc(nic,
1203 &nic->fw.ucode_wowlan.data,
1205 pieces.wowlan_data_size))
1209 /* Now that we can no longer fail, copy information */
1212 * The (size - 16) / 12 formula is based on the information recorded
1213 * for each event, which is of mode 1 (including timestamp) for all
1214 * new microcodes that include this information.
1216 nic->init_evtlog_ptr = pieces.init_evtlog_ptr;
1217 if (pieces.init_evtlog_size)
1218 nic->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
1220 nic->init_evtlog_size =
1221 cfg->base_params->max_event_log_size;
1222 nic->init_errlog_ptr = pieces.init_errlog_ptr;
1223 nic->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
1224 if (pieces.inst_evtlog_size)
1225 nic->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
1227 nic->inst_evtlog_size =
1228 cfg->base_params->max_event_log_size;
1229 nic->inst_errlog_ptr = pieces.inst_errlog_ptr;
1232 * figure out the offset of chain noise reset and gain commands
1233 * base on the size of standard phy calibration commands table size
1235 if (fw->ucode_capa.standard_phy_calibration_size >
1236 IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1237 fw->ucode_capa.standard_phy_calibration_size =
1238 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1240 /* We have our copies now, allow OS release its copies */
1241 release_firmware(ucode_raw);
1242 complete(&nic->request_firmware_complete);
1244 nic->op_mode = iwl_dvm_ops.start(nic->shrd->trans);
1252 /* try next, if any */
1253 release_firmware(ucode_raw);
1254 if (iwl_request_firmware(nic, false))
1259 IWL_ERR(nic, "failed to allocate pci memory\n");
1260 iwl_dealloc_ucode(nic);
1261 release_firmware(ucode_raw);
1263 complete(&nic->request_firmware_complete);
1264 device_release_driver(trans(nic)->dev);