diff options
author | Johannes Berg <johannes.berg@intel.com> | 2012-05-15 06:16:34 -0400 |
---|---|---|
committer | Johannes Berg <johannes.berg@intel.com> | 2012-06-06 07:21:14 -0400 |
commit | 1023fdc4858b6b8cb88ff28cafd425b77555be9f (patch) | |
tree | 16571db8e1a8c8be475b50513a3af33c3583bfc4 /drivers/net/wireless/iwlwifi/dvm/ucode.c | |
parent | 20041ea622fcb1992df536d253de5120808e64a5 (diff) |
iwlwifi: move DVM code into subdirectory
Since we're working on another mode/driver
inside iwlwifi, move the current one into a
subdirectory to more cleanly separate the
code. While at it, rename all the files.
Reviewed-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Diffstat (limited to 'drivers/net/wireless/iwlwifi/dvm/ucode.c')
-rw-r--r-- | drivers/net/wireless/iwlwifi/dvm/ucode.c | 533 |
1 files changed, 533 insertions, 0 deletions
diff --git a/drivers/net/wireless/iwlwifi/dvm/ucode.c b/drivers/net/wireless/iwlwifi/dvm/ucode.c new file mode 100644 index 000000000000..5a2e186c7ded --- /dev/null +++ b/drivers/net/wireless/iwlwifi/dvm/ucode.c | |||
@@ -0,0 +1,533 @@ | |||
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/init.h> | ||
32 | |||
33 | #include "iwl-io.h" | ||
34 | #include "iwl-agn-hw.h" | ||
35 | #include "iwl-trans.h" | ||
36 | #include "iwl-fh.h" | ||
37 | #include "iwl-op-mode.h" | ||
38 | |||
39 | #include "dev.h" | ||
40 | #include "agn.h" | ||
41 | #include "calib.h" | ||
42 | |||
43 | /****************************************************************************** | ||
44 | * | ||
45 | * uCode download functions | ||
46 | * | ||
47 | ******************************************************************************/ | ||
48 | |||
49 | static inline const struct fw_img * | ||
50 | iwl_get_ucode_image(struct iwl_priv *priv, enum iwl_ucode_type ucode_type) | ||
51 | { | ||
52 | if (ucode_type >= IWL_UCODE_TYPE_MAX) | ||
53 | return NULL; | ||
54 | |||
55 | return &priv->fw->img[ucode_type]; | ||
56 | } | ||
57 | |||
58 | /* | ||
59 | * Calibration | ||
60 | */ | ||
61 | static int iwl_set_Xtal_calib(struct iwl_priv *priv) | ||
62 | { | ||
63 | struct iwl_calib_xtal_freq_cmd cmd; | ||
64 | __le16 *xtal_calib = | ||
65 | (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_XTAL); | ||
66 | |||
67 | iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD); | ||
68 | cmd.cap_pin1 = le16_to_cpu(xtal_calib[0]); | ||
69 | cmd.cap_pin2 = le16_to_cpu(xtal_calib[1]); | ||
70 | return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd)); | ||
71 | } | ||
72 | |||
73 | static int iwl_set_temperature_offset_calib(struct iwl_priv *priv) | ||
74 | { | ||
75 | struct iwl_calib_temperature_offset_cmd cmd; | ||
76 | __le16 *offset_calib = | ||
77 | (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_RAW_TEMPERATURE); | ||
78 | |||
79 | memset(&cmd, 0, sizeof(cmd)); | ||
80 | iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD); | ||
81 | memcpy(&cmd.radio_sensor_offset, offset_calib, sizeof(*offset_calib)); | ||
82 | if (!(cmd.radio_sensor_offset)) | ||
83 | cmd.radio_sensor_offset = DEFAULT_RADIO_SENSOR_OFFSET; | ||
84 | |||
85 | IWL_DEBUG_CALIB(priv, "Radio sensor offset: %d\n", | ||
86 | le16_to_cpu(cmd.radio_sensor_offset)); | ||
87 | return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd)); | ||
88 | } | ||
89 | |||
90 | static int iwl_set_temperature_offset_calib_v2(struct iwl_priv *priv) | ||
91 | { | ||
92 | struct iwl_calib_temperature_offset_v2_cmd cmd; | ||
93 | __le16 *offset_calib_high = (__le16 *)iwl_eeprom_query_addr(priv, | ||
94 | EEPROM_KELVIN_TEMPERATURE); | ||
95 | __le16 *offset_calib_low = | ||
96 | (__le16 *)iwl_eeprom_query_addr(priv, EEPROM_RAW_TEMPERATURE); | ||
97 | struct iwl_eeprom_calib_hdr *hdr; | ||
98 | |||
99 | memset(&cmd, 0, sizeof(cmd)); | ||
100 | iwl_set_calib_hdr(&cmd.hdr, IWL_PHY_CALIBRATE_TEMP_OFFSET_CMD); | ||
101 | hdr = (struct iwl_eeprom_calib_hdr *)iwl_eeprom_query_addr(priv, | ||
102 | EEPROM_CALIB_ALL); | ||
103 | memcpy(&cmd.radio_sensor_offset_high, offset_calib_high, | ||
104 | sizeof(*offset_calib_high)); | ||
105 | memcpy(&cmd.radio_sensor_offset_low, offset_calib_low, | ||
106 | sizeof(*offset_calib_low)); | ||
107 | if (!(cmd.radio_sensor_offset_low)) { | ||
108 | IWL_DEBUG_CALIB(priv, "no info in EEPROM, use default\n"); | ||
109 | cmd.radio_sensor_offset_low = DEFAULT_RADIO_SENSOR_OFFSET; | ||
110 | cmd.radio_sensor_offset_high = DEFAULT_RADIO_SENSOR_OFFSET; | ||
111 | } | ||
112 | memcpy(&cmd.burntVoltageRef, &hdr->voltage, | ||
113 | sizeof(hdr->voltage)); | ||
114 | |||
115 | IWL_DEBUG_CALIB(priv, "Radio sensor offset high: %d\n", | ||
116 | le16_to_cpu(cmd.radio_sensor_offset_high)); | ||
117 | IWL_DEBUG_CALIB(priv, "Radio sensor offset low: %d\n", | ||
118 | le16_to_cpu(cmd.radio_sensor_offset_low)); | ||
119 | IWL_DEBUG_CALIB(priv, "Voltage Ref: %d\n", | ||
120 | le16_to_cpu(cmd.burntVoltageRef)); | ||
121 | |||
122 | return iwl_calib_set(priv, (void *)&cmd, sizeof(cmd)); | ||
123 | } | ||
124 | |||
125 | static int iwl_send_calib_cfg(struct iwl_priv *priv) | ||
126 | { | ||
127 | struct iwl_calib_cfg_cmd calib_cfg_cmd; | ||
128 | struct iwl_host_cmd cmd = { | ||
129 | .id = CALIBRATION_CFG_CMD, | ||
130 | .len = { sizeof(struct iwl_calib_cfg_cmd), }, | ||
131 | .data = { &calib_cfg_cmd, }, | ||
132 | }; | ||
133 | |||
134 | memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd)); | ||
135 | calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL; | ||
136 | calib_cfg_cmd.ucd_calib_cfg.once.start = IWL_CALIB_INIT_CFG_ALL; | ||
137 | calib_cfg_cmd.ucd_calib_cfg.once.send_res = IWL_CALIB_INIT_CFG_ALL; | ||
138 | calib_cfg_cmd.ucd_calib_cfg.flags = | ||
139 | IWL_CALIB_CFG_FLAG_SEND_COMPLETE_NTFY_MSK; | ||
140 | |||
141 | return iwl_dvm_send_cmd(priv, &cmd); | ||
142 | } | ||
143 | |||
144 | int iwl_init_alive_start(struct iwl_priv *priv) | ||
145 | { | ||
146 | int ret; | ||
147 | |||
148 | if (priv->cfg->bt_params && | ||
149 | priv->cfg->bt_params->advanced_bt_coexist) { | ||
150 | /* | ||
151 | * Tell uCode we are ready to perform calibration | ||
152 | * need to perform this before any calibration | ||
153 | * no need to close the envlope since we are going | ||
154 | * to load the runtime uCode later. | ||
155 | */ | ||
156 | ret = iwl_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN, | ||
157 | BT_COEX_PRIO_TBL_EVT_INIT_CALIB2); | ||
158 | if (ret) | ||
159 | return ret; | ||
160 | |||
161 | } | ||
162 | |||
163 | ret = iwl_send_calib_cfg(priv); | ||
164 | if (ret) | ||
165 | return ret; | ||
166 | |||
167 | /** | ||
168 | * temperature offset calibration is only needed for runtime ucode, | ||
169 | * so prepare the value now. | ||
170 | */ | ||
171 | if (priv->cfg->need_temp_offset_calib) { | ||
172 | if (priv->cfg->temp_offset_v2) | ||
173 | return iwl_set_temperature_offset_calib_v2(priv); | ||
174 | else | ||
175 | return iwl_set_temperature_offset_calib(priv); | ||
176 | } | ||
177 | |||
178 | return 0; | ||
179 | } | ||
180 | |||
181 | static int iwl_send_wimax_coex(struct iwl_priv *priv) | ||
182 | { | ||
183 | struct iwl_wimax_coex_cmd coex_cmd; | ||
184 | |||
185 | /* coexistence is disabled */ | ||
186 | memset(&coex_cmd, 0, sizeof(coex_cmd)); | ||
187 | |||
188 | return iwl_dvm_send_cmd_pdu(priv, | ||
189 | COEX_PRIORITY_TABLE_CMD, CMD_SYNC, | ||
190 | sizeof(coex_cmd), &coex_cmd); | ||
191 | } | ||
192 | |||
193 | static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = { | ||
194 | ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
195 | (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
196 | ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
197 | (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
198 | ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
199 | (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
200 | ((BT_COEX_PRIO_TBL_PRIO_LOW << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
201 | (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
202 | ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
203 | (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
204 | ((BT_COEX_PRIO_TBL_PRIO_HIGH << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
205 | (1 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
206 | ((BT_COEX_PRIO_TBL_PRIO_BYPASS << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
207 | (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
208 | ((BT_COEX_PRIO_TBL_PRIO_COEX_OFF << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
209 | (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
210 | ((BT_COEX_PRIO_TBL_PRIO_COEX_ON << IWL_BT_COEX_PRIO_TBL_PRIO_POS) | | ||
211 | (0 << IWL_BT_COEX_PRIO_TBL_SHARED_ANTENNA_POS)), | ||
212 | 0, 0, 0, 0, 0, 0, 0 | ||
213 | }; | ||
214 | |||
215 | void iwl_send_prio_tbl(struct iwl_priv *priv) | ||
216 | { | ||
217 | struct iwl_bt_coex_prio_table_cmd prio_tbl_cmd; | ||
218 | |||
219 | memcpy(prio_tbl_cmd.prio_tbl, iwl_bt_prio_tbl, | ||
220 | sizeof(iwl_bt_prio_tbl)); | ||
221 | if (iwl_dvm_send_cmd_pdu(priv, | ||
222 | REPLY_BT_COEX_PRIO_TABLE, CMD_SYNC, | ||
223 | sizeof(prio_tbl_cmd), &prio_tbl_cmd)) | ||
224 | IWL_ERR(priv, "failed to send BT prio tbl command\n"); | ||
225 | } | ||
226 | |||
227 | int iwl_send_bt_env(struct iwl_priv *priv, u8 action, u8 type) | ||
228 | { | ||
229 | struct iwl_bt_coex_prot_env_cmd env_cmd; | ||
230 | int ret; | ||
231 | |||
232 | env_cmd.action = action; | ||
233 | env_cmd.type = type; | ||
234 | ret = iwl_dvm_send_cmd_pdu(priv, | ||
235 | REPLY_BT_COEX_PROT_ENV, CMD_SYNC, | ||
236 | sizeof(env_cmd), &env_cmd); | ||
237 | if (ret) | ||
238 | IWL_ERR(priv, "failed to send BT env command\n"); | ||
239 | return ret; | ||
240 | } | ||
241 | |||
242 | |||
243 | static int iwl_alive_notify(struct iwl_priv *priv) | ||
244 | { | ||
245 | int ret; | ||
246 | |||
247 | iwl_trans_fw_alive(priv->trans); | ||
248 | |||
249 | priv->passive_no_rx = false; | ||
250 | priv->transport_queue_stop = 0; | ||
251 | |||
252 | ret = iwl_send_wimax_coex(priv); | ||
253 | if (ret) | ||
254 | return ret; | ||
255 | |||
256 | if (!priv->cfg->no_xtal_calib) { | ||
257 | ret = iwl_set_Xtal_calib(priv); | ||
258 | if (ret) | ||
259 | return ret; | ||
260 | } | ||
261 | |||
262 | return iwl_send_calib_results(priv); | ||
263 | } | ||
264 | |||
265 | |||
266 | /** | ||
267 | * iwl_verify_inst_sparse - verify runtime uCode image in card vs. host, | ||
268 | * using sample data 100 bytes apart. If these sample points are good, | ||
269 | * it's a pretty good bet that everything between them is good, too. | ||
270 | */ | ||
271 | static int iwl_verify_sec_sparse(struct iwl_priv *priv, | ||
272 | const struct fw_desc *fw_desc) | ||
273 | { | ||
274 | __le32 *image = (__le32 *)fw_desc->v_addr; | ||
275 | u32 len = fw_desc->len; | ||
276 | u32 val; | ||
277 | u32 i; | ||
278 | |||
279 | IWL_DEBUG_FW(priv, "ucode inst image size is %u\n", len); | ||
280 | |||
281 | for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) { | ||
282 | /* read data comes through single port, auto-incr addr */ | ||
283 | /* NOTE: Use the debugless read so we don't flood kernel log | ||
284 | * if IWL_DL_IO is set */ | ||
285 | iwl_write_direct32(priv->trans, HBUS_TARG_MEM_RADDR, | ||
286 | i + fw_desc->offset); | ||
287 | val = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT); | ||
288 | if (val != le32_to_cpu(*image)) | ||
289 | return -EIO; | ||
290 | } | ||
291 | |||
292 | return 0; | ||
293 | } | ||
294 | |||
295 | static void iwl_print_mismatch_sec(struct iwl_priv *priv, | ||
296 | const struct fw_desc *fw_desc) | ||
297 | { | ||
298 | __le32 *image = (__le32 *)fw_desc->v_addr; | ||
299 | u32 len = fw_desc->len; | ||
300 | u32 val; | ||
301 | u32 offs; | ||
302 | int errors = 0; | ||
303 | |||
304 | IWL_DEBUG_FW(priv, "ucode inst image size is %u\n", len); | ||
305 | |||
306 | iwl_write_direct32(priv->trans, HBUS_TARG_MEM_RADDR, | ||
307 | fw_desc->offset); | ||
308 | |||
309 | for (offs = 0; | ||
310 | offs < len && errors < 20; | ||
311 | offs += sizeof(u32), image++) { | ||
312 | /* read data comes through single port, auto-incr addr */ | ||
313 | val = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT); | ||
314 | if (val != le32_to_cpu(*image)) { | ||
315 | IWL_ERR(priv, "uCode INST section at " | ||
316 | "offset 0x%x, is 0x%x, s/b 0x%x\n", | ||
317 | offs, val, le32_to_cpu(*image)); | ||
318 | errors++; | ||
319 | } | ||
320 | } | ||
321 | } | ||
322 | |||
323 | /** | ||
324 | * iwl_verify_ucode - determine which instruction image is in SRAM, | ||
325 | * and verify its contents | ||
326 | */ | ||
327 | static int iwl_verify_ucode(struct iwl_priv *priv, | ||
328 | enum iwl_ucode_type ucode_type) | ||
329 | { | ||
330 | const struct fw_img *img = iwl_get_ucode_image(priv, ucode_type); | ||
331 | |||
332 | if (!img) { | ||
333 | IWL_ERR(priv, "Invalid ucode requested (%d)\n", ucode_type); | ||
334 | return -EINVAL; | ||
335 | } | ||
336 | |||
337 | if (!iwl_verify_sec_sparse(priv, &img->sec[IWL_UCODE_SECTION_INST])) { | ||
338 | IWL_DEBUG_FW(priv, "uCode is good in inst SRAM\n"); | ||
339 | return 0; | ||
340 | } | ||
341 | |||
342 | IWL_ERR(priv, "UCODE IMAGE IN INSTRUCTION SRAM NOT VALID!!\n"); | ||
343 | |||
344 | iwl_print_mismatch_sec(priv, &img->sec[IWL_UCODE_SECTION_INST]); | ||
345 | return -EIO; | ||
346 | } | ||
347 | |||
348 | struct iwl_alive_data { | ||
349 | bool valid; | ||
350 | u8 subtype; | ||
351 | }; | ||
352 | |||
353 | static bool iwl_alive_fn(struct iwl_notif_wait_data *notif_wait, | ||
354 | struct iwl_rx_packet *pkt, void *data) | ||
355 | { | ||
356 | struct iwl_priv *priv = | ||
357 | container_of(notif_wait, struct iwl_priv, notif_wait); | ||
358 | struct iwl_alive_data *alive_data = data; | ||
359 | struct iwl_alive_resp *palive; | ||
360 | |||
361 | palive = (void *)pkt->data; | ||
362 | |||
363 | IWL_DEBUG_FW(priv, "Alive ucode status 0x%08X revision " | ||
364 | "0x%01X 0x%01X\n", | ||
365 | palive->is_valid, palive->ver_type, | ||
366 | palive->ver_subtype); | ||
367 | |||
368 | priv->device_pointers.error_event_table = | ||
369 | le32_to_cpu(palive->error_event_table_ptr); | ||
370 | priv->device_pointers.log_event_table = | ||
371 | le32_to_cpu(palive->log_event_table_ptr); | ||
372 | |||
373 | alive_data->subtype = palive->ver_subtype; | ||
374 | alive_data->valid = palive->is_valid == UCODE_VALID_OK; | ||
375 | |||
376 | return true; | ||
377 | } | ||
378 | |||
379 | #define UCODE_ALIVE_TIMEOUT HZ | ||
380 | #define UCODE_CALIB_TIMEOUT (2*HZ) | ||
381 | |||
382 | int iwl_load_ucode_wait_alive(struct iwl_priv *priv, | ||
383 | enum iwl_ucode_type ucode_type) | ||
384 | { | ||
385 | struct iwl_notification_wait alive_wait; | ||
386 | struct iwl_alive_data alive_data; | ||
387 | const struct fw_img *fw; | ||
388 | int ret; | ||
389 | enum iwl_ucode_type old_type; | ||
390 | static const u8 alive_cmd[] = { REPLY_ALIVE }; | ||
391 | |||
392 | old_type = priv->cur_ucode; | ||
393 | priv->cur_ucode = ucode_type; | ||
394 | fw = iwl_get_ucode_image(priv, ucode_type); | ||
395 | |||
396 | priv->ucode_loaded = false; | ||
397 | |||
398 | if (!fw) | ||
399 | return -EINVAL; | ||
400 | |||
401 | iwl_init_notification_wait(&priv->notif_wait, &alive_wait, | ||
402 | alive_cmd, ARRAY_SIZE(alive_cmd), | ||
403 | iwl_alive_fn, &alive_data); | ||
404 | |||
405 | ret = iwl_trans_start_fw(priv->trans, fw); | ||
406 | if (ret) { | ||
407 | priv->cur_ucode = old_type; | ||
408 | iwl_remove_notification(&priv->notif_wait, &alive_wait); | ||
409 | return ret; | ||
410 | } | ||
411 | |||
412 | /* | ||
413 | * Some things may run in the background now, but we | ||
414 | * just wait for the ALIVE notification here. | ||
415 | */ | ||
416 | ret = iwl_wait_notification(&priv->notif_wait, &alive_wait, | ||
417 | UCODE_ALIVE_TIMEOUT); | ||
418 | if (ret) { | ||
419 | priv->cur_ucode = old_type; | ||
420 | return ret; | ||
421 | } | ||
422 | |||
423 | if (!alive_data.valid) { | ||
424 | IWL_ERR(priv, "Loaded ucode is not valid!\n"); | ||
425 | priv->cur_ucode = old_type; | ||
426 | return -EIO; | ||
427 | } | ||
428 | |||
429 | /* | ||
430 | * This step takes a long time (60-80ms!!) and | ||
431 | * WoWLAN image should be loaded quickly, so | ||
432 | * skip it for WoWLAN. | ||
433 | */ | ||
434 | if (ucode_type != IWL_UCODE_WOWLAN) { | ||
435 | ret = iwl_verify_ucode(priv, ucode_type); | ||
436 | if (ret) { | ||
437 | priv->cur_ucode = old_type; | ||
438 | return ret; | ||
439 | } | ||
440 | |||
441 | /* delay a bit to give rfkill time to run */ | ||
442 | msleep(5); | ||
443 | } | ||
444 | |||
445 | ret = iwl_alive_notify(priv); | ||
446 | if (ret) { | ||
447 | IWL_WARN(priv, | ||
448 | "Could not complete ALIVE transition: %d\n", ret); | ||
449 | priv->cur_ucode = old_type; | ||
450 | return ret; | ||
451 | } | ||
452 | |||
453 | priv->ucode_loaded = true; | ||
454 | |||
455 | return 0; | ||
456 | } | ||
457 | |||
458 | static bool iwlagn_wait_calib(struct iwl_notif_wait_data *notif_wait, | ||
459 | struct iwl_rx_packet *pkt, void *data) | ||
460 | { | ||
461 | struct iwl_priv *priv = data; | ||
462 | struct iwl_calib_hdr *hdr; | ||
463 | int len; | ||
464 | |||
465 | if (pkt->hdr.cmd != CALIBRATION_RES_NOTIFICATION) { | ||
466 | WARN_ON(pkt->hdr.cmd != CALIBRATION_COMPLETE_NOTIFICATION); | ||
467 | return true; | ||
468 | } | ||
469 | |||
470 | hdr = (struct iwl_calib_hdr *)pkt->data; | ||
471 | len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK; | ||
472 | |||
473 | /* reduce the size by the length field itself */ | ||
474 | len -= sizeof(__le32); | ||
475 | |||
476 | if (iwl_calib_set(priv, hdr, len)) | ||
477 | IWL_ERR(priv, "Failed to record calibration data %d\n", | ||
478 | hdr->op_code); | ||
479 | |||
480 | return false; | ||
481 | } | ||
482 | |||
483 | int iwl_run_init_ucode(struct iwl_priv *priv) | ||
484 | { | ||
485 | struct iwl_notification_wait calib_wait; | ||
486 | static const u8 calib_complete[] = { | ||
487 | CALIBRATION_RES_NOTIFICATION, | ||
488 | CALIBRATION_COMPLETE_NOTIFICATION | ||
489 | }; | ||
490 | int ret; | ||
491 | |||
492 | lockdep_assert_held(&priv->mutex); | ||
493 | |||
494 | /* No init ucode required? Curious, but maybe ok */ | ||
495 | if (!priv->fw->img[IWL_UCODE_INIT].sec[0].len) | ||
496 | return 0; | ||
497 | |||
498 | if (priv->init_ucode_run) | ||
499 | return 0; | ||
500 | |||
501 | iwl_init_notification_wait(&priv->notif_wait, &calib_wait, | ||
502 | calib_complete, ARRAY_SIZE(calib_complete), | ||
503 | iwlagn_wait_calib, priv); | ||
504 | |||
505 | /* Will also start the device */ | ||
506 | ret = iwl_load_ucode_wait_alive(priv, IWL_UCODE_INIT); | ||
507 | if (ret) | ||
508 | goto error; | ||
509 | |||
510 | ret = iwl_init_alive_start(priv); | ||
511 | if (ret) | ||
512 | goto error; | ||
513 | |||
514 | /* | ||
515 | * Some things may run in the background now, but we | ||
516 | * just wait for the calibration complete notification. | ||
517 | */ | ||
518 | ret = iwl_wait_notification(&priv->notif_wait, &calib_wait, | ||
519 | UCODE_CALIB_TIMEOUT); | ||
520 | if (!ret) | ||
521 | priv->init_ucode_run = true; | ||
522 | |||
523 | goto out; | ||
524 | |||
525 | error: | ||
526 | iwl_remove_notification(&priv->notif_wait, &calib_wait); | ||
527 | out: | ||
528 | /* Whatever happened, stop the device */ | ||
529 | iwl_trans_stop_device(priv->trans); | ||
530 | priv->ucode_loaded = false; | ||
531 | |||
532 | return ret; | ||
533 | } | ||