Lines Matching refs:drv
16 #include "iwl-drv.h"
55 * struct iwl_drv - drv common data
56 * @list: list of drv structures using this opmode
96 /* Protects the table contents, i.e. the ops pointer & drv list */
101 struct list_head drv; /* list of devices using this op_mode */
119 static void iwl_free_fw_desc(struct iwl_drv *drv, struct fw_desc *desc)
126 static void iwl_free_fw_img(struct iwl_drv *drv, struct fw_img *img)
130 iwl_free_fw_desc(drv, &img->sec[i]);
134 static void iwl_dealloc_ucode(struct iwl_drv *drv)
138 kfree(drv->fw.dbg.dest_tlv);
139 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++)
140 kfree(drv->fw.dbg.conf_tlv[i]);
141 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++)
142 kfree(drv->fw.dbg.trigger_tlv[i]);
143 kfree(drv->fw.dbg.mem_tlv);
144 kfree(drv->fw.iml);
145 kfree(drv->fw.ucode_capa.cmd_versions);
146 kfree(drv->fw.phy_integration_ver);
147 kfree(drv->trans->dbg.pc_data);
150 iwl_free_fw_img(drv, drv->fw.img + i);
153 memset(&drv->fw, 0, sizeof(drv->fw));
156 static int iwl_alloc_fw_desc(struct iwl_drv *drv, struct fw_desc *desc,
238 static int iwl_request_firmware(struct iwl_drv *drv, bool first)
240 const struct iwl_cfg *cfg = drv->trans->cfg;
244 if (drv->trans->trans_cfg->device_family == IWL_DEVICE_FAMILY_9000 &&
245 (drv->trans->hw_rev_step != SILICON_B_STEP &&
246 drv->trans->hw_rev_step != SILICON_C_STEP)) {
247 IWL_ERR(drv,
249 drv->trans->hw_rev);
253 fw_name_pre = iwl_drv_get_fwname_pre(drv->trans, _fw_name_pre);
256 drv->fw_index = cfg->ucode_api_max;
258 drv->fw_index--;
260 if (drv->fw_index < cfg->ucode_api_min) {
261 IWL_ERR(drv, "no suitable firmware found!\n");
264 IWL_ERR(drv, "%s-%d is required\n", fw_name_pre,
267 IWL_ERR(drv, "minimum version required: %s-%d\n",
269 IWL_ERR(drv, "maximum version supported: %s-%d\n",
273 IWL_ERR(drv,
278 snprintf(drv->firmware_name, sizeof(drv->firmware_name), "%s-%d.ucode",
279 fw_name_pre, drv->fw_index);
281 IWL_DEBUG_FW_INFO(drv, "attempting to load firmware '%s'\n",
282 drv->firmware_name);
284 return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
285 drv->trans->dev,
286 GFP_KERNEL, drv, iwl_req_fw_callback);
438 static int iwl_set_default_calib(struct iwl_drv *drv, const u8 *data)
444 IWL_ERR(drv, "Wrong ucode_type %u for default calibration.\n",
448 drv->fw.default_calib[ucode_type].flow_trigger =
450 drv->fw.default_calib[ucode_type].event_trigger =
456 static void iwl_set_ucode_api_flags(struct iwl_drv *drv, const u8 *data,
465 IWL_WARN(drv,
477 static void iwl_set_ucode_capabilities(struct iwl_drv *drv, const u8 *data,
486 IWL_WARN(drv,
498 static const char *iwl_reduced_fw_name(struct iwl_drv *drv)
500 const char *name = drv->firmware_name;
508 static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
517 drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
518 api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
524 IWL_ERR(drv, "File size too small!\n");
543 IWL_ERR(drv, "File size too small!\n");
564 snprintf(drv->fw.fw_version,
565 sizeof(drv->fw.fw_version),
567 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
568 IWL_UCODE_MINOR(drv->fw.ucode_ver),
569 IWL_UCODE_API(drv->fw.ucode_ver),
570 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
571 buildstr, iwl_reduced_fw_name(drv));
581 IWL_ERR(drv,
607 static void iwl_drv_set_dump_exclude(struct iwl_drv *drv,
618 excl = &drv->fw.dump_excl[0];
622 excl = &drv->fw.dump_excl_wowlan[0];
623 } else if (fw_has_capa(&drv->fw.ucode_capa,
626 excl = &drv->fw.dump_excl[0];
629 excl = &drv->fw.dump_excl_wowlan[0];
636 IWL_DEBUG_FW_INFO(drv, "found too many excludes in fw file\n");
644 static void iwl_parse_dbg_tlv_assert_tables(struct iwl_drv *drv,
665 drv->trans->dbg.umac_error_event_table = addr;
666 drv->trans->dbg.error_event_table_tlv_status |=
670 drv->trans->dbg.lmac_error_event_table[0] = addr;
671 drv->trans->dbg.error_event_table_tlv_status |=
675 drv->trans->dbg.lmac_error_event_table[1] = addr;
676 drv->trans->dbg.error_event_table_tlv_status |=
680 drv->trans->dbg.tcm_error_event_table[0] = addr;
681 drv->trans->dbg.error_event_table_tlv_status |=
685 drv->trans->dbg.tcm_error_event_table[1] = addr;
686 drv->trans->dbg.error_event_table_tlv_status |=
690 drv->trans->dbg.rcm_error_event_table[0] = addr;
691 drv->trans->dbg.error_event_table_tlv_status |=
695 drv->trans->dbg.rcm_error_event_table[1] = addr;
696 drv->trans->dbg.error_event_table_tlv_status |=
704 static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
724 IWL_ERR(drv, "uCode has invalid length: %zd\n", len);
729 IWL_ERR(drv, "invalid uCode magic: 0X%x\n",
734 drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
735 memcpy(drv->fw.human_readable, ucode->human_readable,
736 sizeof(drv->fw.human_readable));
744 snprintf(drv->fw.fw_version,
745 sizeof(drv->fw.fw_version),
747 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
748 IWL_UCODE_MINOR(drv->fw.ucode_ver),
749 IWL_UCODE_API(drv->fw.ucode_ver),
750 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
751 buildstr, iwl_reduced_fw_name(drv));
766 IWL_ERR(drv, "invalid TLV len: %zd/%u\n",
811 IWL_ERR(drv, "Found unexpected BOOT ucode\n");
843 iwl_set_ucode_api_flags(drv, tlv_data, capa);
848 iwl_set_ucode_capabilities(drv, tlv_data, capa);
889 drv->fw.enhance_sensitivity_table = true;
918 drv->fw.type = IWL_FW_MVM;
923 drv->fw.type = IWL_FW_MVM;
928 drv->fw.type = IWL_FW_MVM;
933 if (iwl_set_default_calib(drv, tlv_data))
939 drv->fw.phy_config = le32_to_cpup((const __le32 *)tlv_data);
940 drv->fw.valid_tx_ant = (drv->fw.phy_config &
943 drv->fw.valid_rx_ant = (drv->fw.phy_config &
950 drv->fw.type = IWL_FW_MVM;
955 drv->fw.type = IWL_FW_MVM;
960 drv->fw.type = IWL_FW_MVM;
969 drv->fw.img[IWL_UCODE_REGULAR].is_dual_cpus =
971 drv->fw.img[IWL_UCODE_INIT].is_dual_cpus =
973 drv->fw.img[IWL_UCODE_WOWLAN].is_dual_cpus =
976 IWL_ERR(drv, "Driver support up to 2 CPUs\n");
999 snprintf(drv->fw.fw_version,
1000 sizeof(drv->fw.fw_version),
1002 local_comp, iwl_reduced_fw_name(drv));
1004 snprintf(drv->fw.fw_version,
1005 sizeof(drv->fw.fw_version),
1007 local_comp, iwl_reduced_fw_name(drv));
1021 IWL_ERR(drv,
1028 IWL_ERR(drv,
1043 IWL_INFO(drv, "Found debug destination: %s\n",
1046 drv->fw.dbg.n_dest_reg = (dest_v1) ?
1054 drv->fw.dbg.n_dest_reg /=
1055 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]);
1064 IWL_ERR(drv,
1070 if (conf->id >= ARRAY_SIZE(drv->fw.dbg.conf_tlv)) {
1071 IWL_ERR(drv,
1078 IWL_ERR(drv,
1087 IWL_INFO(drv, "Found debug configuration: %d\n",
1099 if (trigger_id >= ARRAY_SIZE(drv->fw.dbg.trigger_tlv)) {
1100 IWL_ERR(drv,
1107 IWL_ERR(drv,
1113 IWL_INFO(drv, "Found debug trigger: %u\n", trigger->id);
1121 IWL_ERR(drv,
1126 drv->fw.dbg.dump_mask =
1141 IWL_DEBUG_FW(drv,
1146 IWL_ERR(drv,
1153 IWL_ERR(drv,
1159 drv->fw.img[IWL_UCODE_REGULAR].paging_mem_size =
1162 drv->fw.img[usniffer_img].paging_mem_size =
1177 IWL_DEBUG_INFO(drv, "Found debug memory segment: %u\n",
1191 drv->fw.iml_len = tlv_len;
1192 drv->fw.iml = kmemdup(tlv_data, tlv_len, GFP_KERNEL);
1193 if (!drv->fw.iml)
1219 IWL_INFO(drv, "TLV_FW_FSEQ_VERSION: %s\n",
1228 IWL_ERR(drv,
1248 if (drv->trans->trans_cfg->device_family <
1251 drv->trans->dbg.umac_error_event_table =
1254 drv->trans->dbg.error_event_table_tlv_status |=
1264 if (drv->trans->trans_cfg->device_family <
1267 drv->trans->dbg.lmac_error_event_table[0] =
1270 drv->trans->dbg.error_event_table_tlv_status |=
1275 iwl_parse_dbg_tlv_assert_tables(drv, tlv);
1283 iwl_dbg_tlv_alloc(drv->trans, tlv, false);
1287 IWL_ERR(drv,
1303 if (drv->fw.phy_integration_ver) {
1304 IWL_ERR(drv,
1309 drv->fw.phy_integration_ver =
1311 if (!drv->fw.phy_integration_ver)
1313 drv->fw.phy_integration_ver_len = tlv_len;
1317 iwl_drv_set_dump_exclude(drv, tlv_type,
1323 drv->trans->dbg.num_pc =
1325 drv->trans->dbg.pc_data =
1329 IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
1336 IWL_ERR(drv,
1342 IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len);
1344 iwl_print_hex_dump(drv, IWL_DL_FW, data, len);
1347 iwl_print_hex_dump(drv, IWL_DL_FW, "TLV ", data, len);
1356 IWL_ERR(drv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
1359 iwl_print_hex_dump(drv, IWL_DL_FW, tlv_data, tlv_len);
1362 iwl_print_hex_dump(drv, IWL_DL_FW, "TLV ", tlv_data, tlv_len);
1369 static int iwl_alloc_ucode(struct iwl_drv *drv,
1379 drv->fw.img[type].sec = sec;
1380 drv->fw.img[type].num_sec = pieces->img[type].sec_counter;
1383 if (iwl_alloc_fw_desc(drv, &sec[i], get_sec(pieces, type, i)))
1389 static int validate_sec_sizes(struct iwl_drv *drv,
1393 IWL_DEBUG_INFO(drv, "f/w package hdr runtime inst size = %zd\n",
1396 IWL_DEBUG_INFO(drv, "f/w package hdr runtime data size = %zd\n",
1399 IWL_DEBUG_INFO(drv, "f/w package hdr init inst size = %zd\n",
1401 IWL_DEBUG_INFO(drv, "f/w package hdr init data size = %zd\n",
1407 IWL_ERR(drv, "uCode instr len %zd too large to fit in\n",
1415 IWL_ERR(drv, "uCode data len %zd too large to fit in\n",
1423 IWL_ERR(drv, "uCode init instr len %zd too large to fit in\n",
1431 IWL_ERR(drv, "uCode init data len %zd too large to fit in\n",
1440 _iwl_op_mode_start(struct iwl_drv *drv, struct iwlwifi_opmode_table *op)
1450 drv->dbgfs_op_mode = debugfs_create_dir(op->name,
1451 drv->dbgfs_drv);
1452 dbgfs_dir = drv->dbgfs_op_mode;
1455 op_mode = ops->start(drv->trans, drv->trans->cfg,
1456 &drv->fw, dbgfs_dir);
1461 IWL_ERR(drv, "retry init count %d\n", retry);
1464 debugfs_remove_recursive(drv->dbgfs_op_mode);
1465 drv->dbgfs_op_mode = NULL;
1472 static void _iwl_op_mode_stop(struct iwl_drv *drv)
1475 if (drv->op_mode) {
1476 iwl_op_mode_stop(drv->op_mode);
1477 drv->op_mode = NULL;
1480 debugfs_remove_recursive(drv->dbgfs_op_mode);
1481 drv->dbgfs_op_mode = NULL;
1494 struct iwl_drv *drv = context;
1495 struct iwl_fw *fw = &drv->fw;
1500 const unsigned int api_max = drv->trans->cfg->ucode_api_max;
1501 const unsigned int api_min = drv->trans->cfg->ucode_api_min;
1525 IWL_DEBUG_FW_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
1526 drv->firmware_name, ucode_raw->size);
1530 IWL_ERR(drv, "File size way too small!\n");
1538 err = iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces);
1540 err = iwl_parse_tlv_firmware(drv, ucode_raw, pieces,
1546 if (fw_has_api(&drv->fw.ucode_capa, IWL_UCODE_TLV_API_NEW_VERSION))
1547 api_ver = drv->fw.ucode_ver;
1549 api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
1557 IWL_ERR(drv,
1568 if (fw->type == IWL_FW_DVM && validate_sec_sizes(drv, pieces,
1569 drv->trans->cfg))
1579 if (iwl_alloc_ucode(drv, pieces, i))
1583 size_t dbg_dest_size = sizeof(*drv->fw.dbg.dest_tlv) +
1584 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
1585 drv->fw.dbg.n_dest_reg;
1587 drv->fw.dbg.dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL);
1589 if (!drv->fw.dbg.dest_tlv)
1593 memcpy(drv->fw.dbg.dest_tlv, pieces->dbg_dest_tlv_v1,
1597 drv->fw.dbg.dest_tlv;
1612 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
1613 drv->fw.dbg.n_dest_reg);
1629 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) {
1631 drv->fw.dbg.conf_tlv[i] =
1635 if (!drv->fw.dbg.conf_tlv[i])
1662 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) {
1675 drv->fw.dbg.trigger_tlv_len[i] =
1677 drv->fw.dbg.trigger_tlv[i] =
1679 drv->fw.dbg.trigger_tlv_len[i],
1681 if (!drv->fw.dbg.trigger_tlv[i])
1688 drv->fw.dbg.mem_tlv = pieces->dbg_mem_tlv;
1690 drv->fw.dbg.n_mem_tlv = pieces->n_mem_tlv;
1702 drv->trans->trans_cfg->base_params->max_event_log_size;
1709 drv->trans->trans_cfg->base_params->max_event_log_size;
1724 iwl_dbg_tlv_load_bin(drv->trans->dev, drv->trans);
1739 IWL_INFO(drv, "loaded firmware version %s op_mode %s\n",
1740 drv->fw.fw_version, op->name);
1743 list_add_tail(&drv->list, &op->drv);
1746 drv->op_mode = _iwl_op_mode_start(drv, op);
1748 if (!drv->op_mode) {
1762 complete(&drv->request_firmware_complete);
1777 if (iwl_request_firmware(drv, false))
1784 complete(&drv->request_firmware_complete);
1785 device_release_driver(drv->trans->dev);
1786 /* drv has just been freed by the release */
1790 iwl_dealloc_ucode(drv);
1802 struct iwl_drv *drv;
1805 drv = kzalloc(sizeof(*drv), GFP_KERNEL);
1806 if (!drv) {
1811 drv->trans = trans;
1812 drv->dev = trans->dev;
1814 init_completion(&drv->request_firmware_complete);
1816 init_completion(&drv->drv_start_complete);
1818 INIT_LIST_HEAD(&drv->list);
1822 drv->dbgfs_drv = debugfs_create_dir(dev_name(trans->dev),
1826 drv->trans->dbgfs_dir = debugfs_create_dir("trans", drv->dbgfs_drv);
1829 drv->trans->dbg.domains_bitmap = IWL_TRANS_FW_DBG_DOMAIN(drv->trans);
1831 ret = iwl_request_firmware(drv, true);
1844 wait_for_completion(&drv->request_firmware_complete);
1845 complete(&drv->drv_start_complete);
1848 return drv;
1852 debugfs_remove_recursive(drv->dbgfs_drv);
1853 iwl_dbg_tlv_free(drv->trans);
1855 kfree(drv);
1860 void iwl_drv_stop(struct iwl_drv *drv)
1863 wait_for_completion(&drv->request_firmware_complete);
1865 wait_for_completion(&drv->drv_start_complete);
1868 _iwl_op_mode_stop(drv);
1870 iwl_dealloc_ucode(drv);
1878 if (!list_empty(&drv->list))
1879 list_del(&drv->list);
1883 drv->trans->ops->debugfs_cleanup(drv->trans);
1885 debugfs_remove_recursive(drv->dbgfs_drv);
1888 iwl_dbg_tlv_free(drv->trans);
1890 kfree(drv);
1915 struct iwl_drv *drv;
1925 list_for_each_entry(drv, &op->drv, list)
1926 drv->op_mode = _iwl_op_mode_start(drv, op);
1939 struct iwl_drv *drv;
1948 list_for_each_entry(drv, &iwlwifi_opmode_table[i].drv, list)
1949 _iwl_op_mode_stop(drv);
1963 INIT_LIST_HEAD(&iwlwifi_opmode_table[i].drv);