Hi Chris, Thank you for the patch! Yet something to improve: [auto build test ERROR on wireless-drivers/master] [also build test ERROR on v5.6 next-20200402] [cannot apply to wireless-drivers-next/master] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982] url: https://github.com/0day-ci/linux/commits/Chris-Rorvick/iwlwifi-actually-c... base: https://git.kernel.org/pub/scm/linux/kernel/git/kvalo/wireless-drivers.git master config: mips-ip27_defconfig (attached as .config) compiler: mips64-linux-gcc (GCC) 9.3.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree GCC_VERSION=9.3.0 make.cross ARCH=mips If you fix the issue, kindly add following tag Reported-by: kbuild test robot <lkp(a)intel.com&gt; All errors (new ones prefixed by >>): drivers/net/wireless/intel/iwlwifi/iwl-drv.c: In function 'iwl_req_fw_callback': 1470 | if (!drv->fw.dbg_conf_tlv[i]) | ^ vim +1470 drivers/net/wireless/intel/iwlwifi/iwl-drv.c 1323 1324 /** 1325 * iwl_req_fw_callback - callback when firmware was loaded 1326 * 1327 * If loaded successfully, copies the firmware into buffers 1328 * for the card to fetch (via DMA). 1329 */ 1330 static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context) 1331 { 1332 struct iwl_drv *drv = context; 1333 struct iwl_fw *fw = &drv->fw; 1334 struct iwl_ucode_header *ucode; 1335 struct iwlwifi_opmode_table *op; 1336 int err; 1337 struct iwl_firmware_pieces *pieces; 1338 const unsigned int api_max = drv->trans->cfg->ucode_api_max; 1339 const unsigned int api_min = drv->trans->cfg->ucode_api_min; 1340 size_t trigger_tlv_sz[FW_DBG_TRIGGER_MAX]; 1341 u32 api_ver; 1342 int i; 1343 bool load_module = false; 1344 bool usniffer_images = false; 1345 1346 fw->ucode_capa.max_probe_length = IWL_DEFAULT_MAX_PROBE_LENGTH; 1347 fw->ucode_capa.standard_phy_calibration_size = 1348 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE; 1349 fw->ucode_capa.n_scan_channels = IWL_DEFAULT_SCAN_CHANNELS; 1350 /* dump all fw memory areas by default */ 1351 fw->dbg.dump_mask = 0xffffffff; 1352 1353 pieces = kzalloc(sizeof(*pieces), GFP_KERNEL); 1354 if (!pieces) 1355 goto out_free_fw; 1356 1357 if (!ucode_raw) 1358 goto try_again; 1359 1360 IWL_DEBUG_FW_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n", 1361 drv->firmware_name, ucode_raw->size); 1362 1363 /* Make sure that we got at least the API version number */ 1364 if (ucode_raw->size < 4) { 1365 IWL_ERR(drv, "File size way too small!\n"); 1366 goto try_again; 1367 } 1368 1369 /* Data from ucode file: header followed by uCode images */ 1370 ucode = (struct iwl_ucode_header *)ucode_raw->data; 1371 1372 if (ucode->ver) 1373 err = iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces); 1374 else 1375 err = iwl_parse_tlv_firmware(drv, ucode_raw, pieces, 1376 &fw->ucode_capa, &usniffer_images); 1377 1378 if (err) 1379 goto try_again; 1380 1381 if (fw_has_api(&drv->fw.ucode_capa, IWL_UCODE_TLV_API_NEW_VERSION)) 1382 api_ver = drv->fw.ucode_ver; 1383 else 1384 api_ver = IWL_UCODE_API(drv->fw.ucode_ver); 1385 1386 /* 1387 * api_ver should match the api version forming part of the 1388 * firmware filename ... but we don't check for that and only rely 1389 * on the API version read from firmware header from here on forward 1390 */ 1391 if (api_ver < api_min || api_ver > api_max) { 1392 IWL_ERR(drv, 1393 "Driver unable to support your firmware API. " 1394 "Driver supports v%u, firmware is v%u.\n", 1395 api_max, api_ver); 1396 goto try_again; 1397 } 1398 1399 /* 1400 * In mvm uCode there is no difference between data and instructions 1401 * sections. 1402 */ 1403 if (fw->type == IWL_FW_DVM && validate_sec_sizes(drv, pieces, 1404 drv->trans->cfg)) 1405 goto try_again; 1406 1407 /* Allocate ucode buffers for card's bus-master loading ... */ 1408 1409 /* Runtime instructions and 2 copies of data: 1410 * 1) unmodified from disk 1411 * 2) backup cache for save/restore during power-downs 1412 */ 1413 for (i = 0; i < IWL_UCODE_TYPE_MAX; i++) 1414 if (iwl_alloc_ucode(drv, pieces, i)) 1415 goto out_free_fw; 1416 1417 if (pieces->dbg_dest_tlv_init) { 1418 size_t dbg_dest_size = sizeof(*drv->fw.dbg.dest_tlv) + 1419 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) * 1420 drv->fw.dbg.n_dest_reg; 1421 1422 drv->fw.dbg.dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL); 1423 1424 if (!drv->fw.dbg.dest_tlv) 1425 goto out_free_fw; 1426 1427 if (*pieces->dbg_dest_ver == 0) { 1428 memcpy(drv->fw.dbg.dest_tlv, pieces->dbg_dest_tlv_v1, 1429 dbg_dest_size); 1430 } else { 1431 struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv = 1432 drv->fw.dbg.dest_tlv; 1433 1434 dest_tlv->version = pieces->dbg_dest_tlv->version; 1435 dest_tlv->monitor_mode = 1436 pieces->dbg_dest_tlv->monitor_mode; 1437 dest_tlv->size_power = 1438 pieces->dbg_dest_tlv->size_power; 1439 dest_tlv->wrap_count = 1440 pieces->dbg_dest_tlv->wrap_count; 1441 dest_tlv->write_ptr_reg = 1442 pieces->dbg_dest_tlv->write_ptr_reg; 1443 dest_tlv->base_shift = 1444 pieces->dbg_dest_tlv->base_shift; 1445 memcpy(dest_tlv->reg_ops, 1446 pieces->dbg_dest_tlv->reg_ops, 1447 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) * 1448 drv->fw.dbg.n_dest_reg); 1449 1450 /* In version 1 of the destination tlv, which is 1451 * relevant for internal buffer exclusively, 1452 * the base address is part of given with the length 1453 * of the buffer, and the size shift is give instead of 1454 * end shift. We now store these values in base_reg, 1455 * and end shift, and when dumping the data we'll 1456 * manipulate it for extracting both the length and 1457 * base address */ 1458 dest_tlv->base_reg = pieces->dbg_dest_tlv->cfg_reg; 1459 dest_tlv->end_shift = 1460 pieces->dbg_dest_tlv->size_shift; 1461 } 1462 } 1463 1464 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) { 1465 if (pieces->dbg_conf_tlv[i]) { 1466 drv->fw.dbg.conf_tlv[i] = 1467 kmemdup(pieces->dbg_conf_tlv[i], 1468 pieces->dbg_conf_tlv_len[i], 1469 GFP_KERNEL); 1471 goto out_free_fw; 1472 } 1473 } 1474 1475 memset(&trigger_tlv_sz, 0xff, sizeof(trigger_tlv_sz)); 1476 1477 trigger_tlv_sz[FW_DBG_TRIGGER_MISSED_BEACONS] = 1478 sizeof(struct iwl_fw_dbg_trigger_missed_bcon); 1479 trigger_tlv_sz[FW_DBG_TRIGGER_CHANNEL_SWITCH] = 0; 1480 trigger_tlv_sz[FW_DBG_TRIGGER_FW_NOTIF] = 1481 sizeof(struct iwl_fw_dbg_trigger_cmd); 1482 trigger_tlv_sz[FW_DBG_TRIGGER_MLME] = 1483 sizeof(struct iwl_fw_dbg_trigger_mlme); 1484 trigger_tlv_sz[FW_DBG_TRIGGER_STATS] = 1485 sizeof(struct iwl_fw_dbg_trigger_stats); 1486 trigger_tlv_sz[FW_DBG_TRIGGER_RSSI] = 1487 sizeof(struct iwl_fw_dbg_trigger_low_rssi); 1488 trigger_tlv_sz[FW_DBG_TRIGGER_TXQ_TIMERS] = 1489 sizeof(struct iwl_fw_dbg_trigger_txq_timer); 1490 trigger_tlv_sz[FW_DBG_TRIGGER_TIME_EVENT] = 1491 sizeof(struct iwl_fw_dbg_trigger_time_event); 1492 trigger_tlv_sz[FW_DBG_TRIGGER_BA] = 1493 sizeof(struct iwl_fw_dbg_trigger_ba); 1494 trigger_tlv_sz[FW_DBG_TRIGGER_TDLS] = 1495 sizeof(struct iwl_fw_dbg_trigger_tdls); 1496 1497 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) { 1498 if (pieces->dbg_trigger_tlv[i]) { 1499 /* 1500 * If the trigger isn't long enough, WARN and exit. 1501 * Someone is trying to debug something and he won't 1502 * be able to catch the bug he is trying to chase. 1503 * We'd better be noisy to be sure he knows what's 1504 * going on. 1505 */ 1506 if (WARN_ON(pieces->dbg_trigger_tlv_len[i] < 1507 (trigger_tlv_sz[i] + 1508 sizeof(struct iwl_fw_dbg_trigger_tlv)))) 1509 goto out_free_fw; 1510 drv->fw.dbg.trigger_tlv_len[i] = 1511 pieces->dbg_trigger_tlv_len[i]; 1512 drv->fw.dbg.trigger_tlv[i] = 1513 kmemdup(pieces->dbg_trigger_tlv[i], 1514 drv->fw.dbg.trigger_tlv_len[i], 1515 GFP_KERNEL); 1516 if (!drv->fw.dbg.trigger_tlv[i]) 1517 goto out_free_fw; 1518 } 1519 } 1520 1521 /* Now that we can no longer fail, copy information */ 1522 1523 drv->fw.dbg.mem_tlv = pieces->dbg_mem_tlv; 1524 pieces->dbg_mem_tlv = NULL; 1525 drv->fw.dbg.n_mem_tlv = pieces->n_mem_tlv; 1526 1527 /* 1528 * The (size - 16) / 12 formula is based on the information recorded 1529 * for each event, which is of mode 1 (including timestamp) for all 1530 * new microcodes that include this information. 1531 */ 1532 fw->init_evtlog_ptr = pieces->init_evtlog_ptr; 1533 if (pieces->init_evtlog_size) 1534 fw->init_evtlog_size = (pieces->init_evtlog_size - 16)/12; 1535 else 1536 fw->init_evtlog_size = 1537 drv->trans->trans_cfg->base_params->max_event_log_size; 1538 fw->init_errlog_ptr = pieces->init_errlog_ptr; 1539 fw->inst_evtlog_ptr = pieces->inst_evtlog_ptr; 1540 if (pieces->inst_evtlog_size) 1541 fw->inst_evtlog_size = (pieces->inst_evtlog_size - 16)/12; 1542 else 1543 fw->inst_evtlog_size = 1544 drv->trans->trans_cfg->base_params->max_event_log_size; 1545 fw->inst_errlog_ptr = pieces->inst_errlog_ptr; 1546 1547 /* 1548 * figure out the offset of chain noise reset and gain commands 1549 * base on the size of standard phy calibration commands table size 1550 */ 1551 if (fw->ucode_capa.standard_phy_calibration_size > 1552 IWL_MAX_PHY_CALIBRATE_TBL_SIZE) 1553 fw->ucode_capa.standard_phy_calibration_size = 1554 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE; 1555 1556 /* We have our copies now, allow OS release its copies */ 1557 release_firmware(ucode_raw); 1558 1559 mutex_lock(&iwlwifi_opmode_table_mtx); 1560 switch (fw->type) { 1561 case IWL_FW_DVM: 1562 op = &iwlwifi_opmode_table[DVM_OP_MODE]; 1563 break; 1564 default: 1565 WARN(1, "Invalid fw type %d\n", fw->type); 1566 /* fall through */ 1567 case IWL_FW_MVM: 1568 op = &iwlwifi_opmode_table[MVM_OP_MODE]; 1569 break; 1570 } 1571 1572 IWL_INFO(drv, "loaded firmware version %s op_mode %s\n", 1573 drv->fw.fw_version, op->name); 1574 1575 iwl_dbg_tlv_load_bin(drv->trans->dev, drv->trans); 1576 1577 /* add this device to the list of devices using this op_mode */ 1578 list_add_tail(&drv->list, &op->drv); 1579 1580 if (op->ops) { 1581 drv->op_mode = _iwl_op_mode_start(drv, op); 1582 1583 if (!drv->op_mode) { 1584 mutex_unlock(&iwlwifi_opmode_table_mtx); 1585 goto out_unbind; 1586 } 1587 } else { 1588 load_module = true; 1589 } 1590 mutex_unlock(&iwlwifi_opmode_table_mtx); 1591 1592 /* 1593 * Complete the firmware request last so that 1594 * a driver unbind (stop) doesn't run while we 1595 * are doing the start() above. 1596 */ 1597 complete(&drv->request_firmware_complete); 1598 1599 /* 1600 * Load the module last so we don't block anything 1601 * else from proceeding if the module fails to load 1602 * or hangs loading. 1603 */ 1604 if (load_module) { 1605 request_module("%s", op->name); 1606 #ifdef CONFIG_IWLWIFI_OPMODE_MODULAR 1607 if (err) 1608 IWL_ERR(drv, 1609 "failed to load module %s (error %d), is dynamic loading enabled?\n", 1610 op->name, err); 1611 #endif 1612 } 1613 goto free; 1614 1615 try_again: 1616 /* try next, if any */ 1617 release_firmware(ucode_raw); 1618 if (iwl_request_firmware(drv, false)) 1619 goto out_unbind; 1620 goto free; 1621 1622 out_free_fw: 1623 release_firmware(ucode_raw); 1624 out_unbind: 1625 complete(&drv->request_firmware_complete); 1626 device_release_driver(drv->trans->dev); 1627 free: 1628 if (pieces) { 1629 for (i = 0; i < ARRAY_SIZE(pieces->img); i++) 1630 kfree(pieces->img[i].sec); 1631 kfree(pieces->dbg_mem_tlv); 1632 kfree(pieces); 1633 } 1634 } 1635 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org