From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.5 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D6F81C433DF for ; Fri, 10 Jul 2020 09:08:10 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id AB25B207BC for ; Fri, 10 Jul 2020 09:08:10 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mg.codeaurora.org header.i=@mg.codeaurora.org header.b="j/YQCiv/" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726820AbgGJJIJ (ORCPT ); Fri, 10 Jul 2020 05:08:09 -0400 Received: from m43-7.mailgun.net ([69.72.43.7]:26859 "EHLO m43-7.mailgun.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726615AbgGJJIJ (ORCPT ); Fri, 10 Jul 2020 05:08:09 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1594372088; h=Content-Transfer-Encoding: Content-Type: MIME-Version: Message-Id: Date: Subject: Cc: To: From: Sender; bh=8LDVfV3bZSofZGY4D1A3bTSsKduJbRin/6eEA9yrVnU=; b=j/YQCiv/O7faR17xGfbOhlyv8Tkkw1bvCXagIN36u7yrltc6G9uJ+MdVWEpxmmIimh1NaSKC 1IavI4K9SU1dv8kxXoi4h3M7QaMVy64XQxuFbJjMMe+ncXIsxonT/CWlLfahqX6xYBdNCPWb IFy4N5eeNzDu4A4N3MTdAYyigfU= X-Mailgun-Sending-Ip: 69.72.43.7 X-Mailgun-Sid: WyI3YTAwOSIsICJsaW51eC13aXJlbGVzc0B2Z2VyLmtlcm5lbC5vcmciLCAiYmU5ZTRhIl0= Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n05.prod.us-east-1.postgun.com with SMTP id 5f082ff419b27ae9ce44dcb2 (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Fri, 10 Jul 2020 09:08:04 GMT Received: by smtp.codeaurora.org (Postfix, from userid 1001) id AA280C433C8; Fri, 10 Jul 2020 09:08:03 +0000 (UTC) Received: from ssreeela-linux.qualcomm.com (blr-c-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.19.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: ssreeela) by smtp.codeaurora.org (Postfix) with ESMTPSA id AE021C433C6; Fri, 10 Jul 2020 09:08:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org AE021C433C6 Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; spf=none smtp.mailfrom=ssreeela@codeaurora.org From: Sowmiya Sree Elavalagan To: ath11k@lists.infradead.org Cc: linux-wireless@vger.kernel.org, Govindaraj Saminathan , Sowmiya Sree Elavalagan Subject: [PATCH v2] ath11k: cold boot calibration support Date: Fri, 10 Jul 2020 14:37:29 +0530 Message-Id: <1594372049-31480-1-git-send-email-ssreeela@codeaurora.org> X-Mailer: git-send-email 2.7.4 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-wireless-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-wireless@vger.kernel.org From: Govindaraj Saminathan cold boot calibration is the process to calibrate all the channels during the boot-up to avoid the calibration delay during the channel change. During the boot-up, firmware started with mode “cold_boot_calibration” Firmware calibrate all channels and generate CalDb(DDR). Subsequent WIFI ON will reuse the same CalDb. Firmware restarted with Mission mode to continue the normal operation. caldb memory address send to firmware through the QMI message.Firmware use this address to store the caldb data and use it until next reboot. This will give the improvement during the channel change. But it is increasing the boot-up time(up to 15sec depend on number of radios). So if the user want to reduce the boot-up time and accepting for channel change delay, user can disable this feature using the module param cold_boot_cal =0. Signed-off-by: Govindaraj Saminathan Co-developed-by: Sowmiya Sree Elavalagan Signed-off-by: Sowmiya Sree Elavalagan --- v2: - Fixed compilations warnings Reported-by: kernel test robot --- drivers/net/wireless/ath/ath11k/ahb.c | 26 ++++++++++++++ drivers/net/wireless/ath/ath11k/core.c | 1 + drivers/net/wireless/ath/ath11k/core.h | 5 +++ drivers/net/wireless/ath/ath11k/qmi.c | 66 ++++++++++++++++++++++++++++++---- drivers/net/wireless/ath/ath11k/qmi.h | 3 ++ 5 files changed, 94 insertions(+), 7 deletions(-) diff --git a/drivers/net/wireless/ath/ath11k/ahb.c b/drivers/net/wireless/ath/ath11k/ahb.c index 7e9bfea..2e0d61d 100644 --- a/drivers/net/wireless/ath/ath11k/ahb.c +++ b/drivers/net/wireless/ath/ath11k/ahb.c @@ -638,6 +638,30 @@ static void ath11k_ahb_power_down(struct ath11k_base *ab) rproc_shutdown(ab->tgt_rproc); } +static int ath11k_ahb_fwreset_from_cold_boot(struct ath11k_base *ab) +{ + int timeout; + + if (ath11k_cold_boot_cal == 0 || ab->qmi.cal_done) + return 0; + + ath11k_dbg(ab, ATH11K_DBG_AHB, "wait for cold boot done\n"); + timeout = wait_event_timeout(ab->qmi.cold_boot_waitq, + (ab->qmi.cal_done == 1), + ATH11K_COLD_BOOT_FW_RESET_DELAY); + if (timeout <= 0) { + ath11k_warn(ab, "Coldboot Calibration timed out\n"); + return -ETIMEDOUT; + } + + /* reset the firmware */ + ath11k_ahb_power_down(ab); + ath11k_ahb_power_up(ab); + + ath11k_dbg(ab, ATH11K_DBG_AHB, "exit wait for cold boot done\n"); + return 0; +} + static void ath11k_ahb_init_qmi_ce_config(struct ath11k_base *ab) { struct ath11k_qmi_ce_cfg *cfg = &ab->qmi.ce_cfg; @@ -964,6 +988,8 @@ static int ath11k_ahb_probe(struct platform_device *pdev) goto err_ce_free; } + ath11k_ahb_fwreset_from_cold_boot(ab); + return 0; err_ce_free: diff --git a/drivers/net/wireless/ath/ath11k/core.c b/drivers/net/wireless/ath/ath11k/core.c index 38e830a..533c7b2 100644 --- a/drivers/net/wireless/ath/ath11k/core.c +++ b/drivers/net/wireless/ath/ath11k/core.c @@ -801,6 +801,7 @@ struct ath11k_base *ath11k_core_alloc(struct device *dev, size_t priv_size, INIT_LIST_HEAD(&ab->peers); init_waitqueue_head(&ab->peer_mapping_wq); init_waitqueue_head(&ab->wmi_ab.tx_credits_wq); + init_waitqueue_head(&ab->qmi.cold_boot_waitq); INIT_WORK(&ab->restart_work, ath11k_core_restart); timer_setup(&ab->rx_replenish_retry, ath11k_ce_rx_replenish_retry, 0); ab->dev = dev; diff --git a/drivers/net/wireless/ath/ath11k/core.h b/drivers/net/wireless/ath/ath11k/core.h index b6ccd9f..d736fb0 100644 --- a/drivers/net/wireless/ath/ath11k/core.h +++ b/drivers/net/wireless/ath/ath11k/core.h @@ -98,8 +98,13 @@ enum ath11k_firmware_mode { /* factory tests etc */ ATH11K_FIRMWARE_MODE_FTM, + + /* Cold boot calibration */ + ATH11K_FIRMWARE_MODE_COLD_BOOT = 7, }; +extern bool ath11k_cold_boot_cal; + #define ATH11K_IRQ_NUM_MAX 52 #define ATH11K_EXT_IRQ_GRP_NUM_MAX 11 #define ATH11K_EXT_IRQ_NUM_MAX 16 diff --git a/drivers/net/wireless/ath/ath11k/qmi.c b/drivers/net/wireless/ath/ath11k/qmi.c index 50812df..f9df3fd 100644 --- a/drivers/net/wireless/ath/ath11k/qmi.c +++ b/drivers/net/wireless/ath/ath11k/qmi.c @@ -9,6 +9,12 @@ #include #include +bool ath11k_cold_boot_cal = 1; +module_param_named(cold_boot_cal, ath11k_cold_boot_cal, bool, 0644); +MODULE_PARM_DESC(cold_boot_cal, + "Cold boot will bring down the channel switch time but " + "it will increase the driver load time (enable:1, disable:0)"); + static struct qmi_elem_info qmi_wlanfw_host_cap_req_msg_v01_ei[] = { { .data_type = QMI_OPT_FLAG, @@ -1692,9 +1698,16 @@ static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab) ath11k_warn(ab, "qmi mem size is low to load caldata\n"); return -EINVAL; } - /* TODO ath11k does not support cold boot calibration */ - ab->qmi.target_mem[idx].paddr = 0; - ab->qmi.target_mem[idx].vaddr = 0; + + if (ath11k_cold_boot_cal) { + ab->qmi.target_mem[idx].paddr = + ATH11K_QMI_CALDB_ADDRESS; + ab->qmi.target_mem[idx].vaddr = + ATH11K_QMI_CALDB_ADDRESS; + } else { + ab->qmi.target_mem[idx].paddr = 0; + ab->qmi.target_mem[idx].vaddr = 0; + } ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size; ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type; idx++; @@ -2111,6 +2124,32 @@ int ath11k_qmi_firmware_start(struct ath11k_base *ab, return 0; } +static int ath11k_qmi_process_coldboot_calibration(struct ath11k_base *ab) +{ + int timeout; + int ret; + + ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_COLD_BOOT); + if (ret < 0) { + ath11k_warn(ab, "qmi failed to send wlan fw mode:%d\n", ret); + return ret; + } + + ath11k_warn(ab, "Coldboot calibration wait started\n"); + + timeout = wait_event_timeout(ab->qmi.cold_boot_waitq, + (ab->qmi.cal_done == 1), + ATH11K_COLD_BOOT_FW_RESET_DELAY); + if (timeout <= 0) { + ath11k_warn(ab, "Coldboot Calibration timed out\n"); + return -ETIMEDOUT; + } + + ath11k_warn(ab, "Coldboot calibration wait ended\n"); + + return 0; +} + static int ath11k_qmi_driver_event_post(struct ath11k_qmi *qmi, enum ath11k_qmi_event_type type, @@ -2247,11 +2286,18 @@ static void ath11k_qmi_msg_fw_ready_cb(struct qmi_handle *qmi_hdl, ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_READY, NULL); } -static void ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle *qmi, +static void ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle *qmi_hdl, struct sockaddr_qrtr *sq, struct qmi_txn *txn, const void *decoded) { + struct ath11k_qmi *qmi = container_of(qmi_hdl, + struct ath11k_qmi, handle); + struct ath11k_base *ab = qmi->ab; + + ab->qmi.cal_done = 1; + wake_up(&ab->qmi.cold_boot_waitq); + ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi cold boot calibration done\n"); } static const struct qmi_msg_handler ath11k_qmi_msg_handlers[] = { @@ -2364,9 +2410,15 @@ static void ath11k_qmi_driver_event_work(struct work_struct *work) break; } - ath11k_core_qmi_firmware_ready(ab); - ab->qmi.cal_done = 1; - set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags); + if (ath11k_cold_boot_cal && ab->qmi.cal_done == 0) { + ath11k_qmi_process_coldboot_calibration(ab); + } else { + clear_bit(ATH11K_FLAG_CRASH_FLUSH, + &ab->dev_flags); + clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags); + ath11k_core_qmi_firmware_ready(ab); + set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags); + } break; case ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE: diff --git a/drivers/net/wireless/ath/ath11k/qmi.h b/drivers/net/wireless/ath/ath11k/qmi.h index 3307be5..02c05cc 100644 --- a/drivers/net/wireless/ath/ath11k/qmi.h +++ b/drivers/net/wireless/ath/ath11k/qmi.h @@ -12,6 +12,7 @@ #define ATH11K_HOST_VERSION_STRING "WIN" #define ATH11K_QMI_WLANFW_TIMEOUT_MS 5000 #define ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE 64 +#define ATH11K_QMI_CALDB_ADDRESS 0x4BA00000 #define ATH11K_QMI_BDF_MAX_SIZE (256 * 1024) #define ATH11K_QMI_CALDATA_OFFSET (128 * 1024) #define ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 128 @@ -31,6 +32,7 @@ #define QMI_WLANFW_MAX_DATA_SIZE_V01 6144 #define ATH11K_FIRMWARE_MODE_OFF 4 #define ATH11K_QMI_TARGET_MEM_MODE_DEFAULT 0 +#define ATH11K_COLD_BOOT_FW_RESET_DELAY (40 * HZ) struct ath11k_base; @@ -110,6 +112,7 @@ struct ath11k_qmi { u32 target_mem_mode; u8 cal_done; struct target_info target; + wait_queue_head_t cold_boot_waitq; }; #define QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN 189 -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail29.static.mailgun.info ([104.130.122.29]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jtp11-0000YV-7Y for ath11k@lists.infradead.org; Fri, 10 Jul 2020 09:08:20 +0000 From: Sowmiya Sree Elavalagan Subject: [PATCH v2] ath11k: cold boot calibration support Date: Fri, 10 Jul 2020 14:37:29 +0530 Message-Id: <1594372049-31480-1-git-send-email-ssreeela@codeaurora.org> MIME-Version: 1.0 List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "ath11k" Errors-To: ath11k-bounces+kvalo=adurom.com@lists.infradead.org To: ath11k@lists.infradead.org Cc: Govindaraj Saminathan , Sowmiya Sree Elavalagan , linux-wireless@vger.kernel.org RnJvbTogR292aW5kYXJhaiBTYW1pbmF0aGFuIDxnc2FtaW5AY29kZWF1cm9yYS5vcmc+Cgpjb2xk IGJvb3QgY2FsaWJyYXRpb24gaXMgdGhlIHByb2Nlc3MgdG8gY2FsaWJyYXRlIGFsbCB0aGUgY2hh bm5lbHMKZHVyaW5nIHRoZSBib290LXVwIHRvIGF2b2lkIHRoZSBjYWxpYnJhdGlvbiBkZWxheSBk dXJpbmcgdGhlCmNoYW5uZWwgY2hhbmdlLgpEdXJpbmcgdGhlIGJvb3QtdXAsIGZpcm13YXJlIHN0 YXJ0ZWQgd2l0aCBtb2RlIOKAnGNvbGRfYm9vdF9jYWxpYnJhdGlvbuKAnQpGaXJtd2FyZSBjYWxp YnJhdGUgYWxsIGNoYW5uZWxzIGFuZCBnZW5lcmF0ZSBDYWxEYihERFIpLgpTdWJzZXF1ZW50IFdJ RkkgT04gd2lsbCByZXVzZSB0aGUgc2FtZSBDYWxEYi4KRmlybXdhcmUgcmVzdGFydGVkIHdpdGgg TWlzc2lvbiBtb2RlIHRvIGNvbnRpbnVlIHRoZSBub3JtYWwgb3BlcmF0aW9uLgoKY2FsZGIgbWVt b3J5IGFkZHJlc3Mgc2VuZCB0byBmaXJtd2FyZSB0aHJvdWdoIHRoZSBRTUkgbWVzc2FnZS5GaXJt d2FyZQp1c2UgdGhpcyBhZGRyZXNzIHRvIHN0b3JlIHRoZSBjYWxkYiBkYXRhIGFuZCB1c2UgaXQg dW50aWwgbmV4dCByZWJvb3QuCgpUaGlzIHdpbGwgZ2l2ZSB0aGUgaW1wcm92ZW1lbnQgZHVyaW5n IHRoZSBjaGFubmVsIGNoYW5nZS4gQnV0IGl0IGlzCmluY3JlYXNpbmcgdGhlIGJvb3QtdXAgdGlt ZSh1cCB0byAxNXNlYyBkZXBlbmQgb24gbnVtYmVyIG9mIHJhZGlvcykuClNvIGlmIHRoZSB1c2Vy IHdhbnQgdG8gcmVkdWNlIHRoZSBib290LXVwIHRpbWUgYW5kIGFjY2VwdGluZyBmb3IgY2hhbm5l bApjaGFuZ2UgZGVsYXksIHVzZXIgY2FuIGRpc2FibGUgdGhpcyBmZWF0dXJlIHVzaW5nIHRoZSBt b2R1bGUgcGFyYW0KY29sZF9ib290X2NhbCA9MC4KClNpZ25lZC1vZmYtYnk6IEdvdmluZGFyYWog U2FtaW5hdGhhbiA8Z3NhbWluQGNvZGVhdXJvcmEub3JnPgpDby1kZXZlbG9wZWQtYnk6IFNvd21p eWEgU3JlZSBFbGF2YWxhZ2FuIDxzc3JlZWVsYUBjb2RlYXVyb3JhLm9yZz4KU2lnbmVkLW9mZi1i eTogU293bWl5YSBTcmVlIEVsYXZhbGFnYW4gPHNzcmVlZWxhQGNvZGVhdXJvcmEub3JnPgotLS0K djI6CiAgIC0gRml4ZWQgY29tcGlsYXRpb25zIHdhcm5pbmdzCiAgICAgUmVwb3J0ZWQtYnk6IGtl cm5lbCB0ZXN0IHJvYm90IDxsa3BAaW50ZWwuY29tPgotLS0KIGRyaXZlcnMvbmV0L3dpcmVsZXNz L2F0aC9hdGgxMWsvYWhiLmMgIHwgMjYgKysrKysrKysrKysrKysKIGRyaXZlcnMvbmV0L3dpcmVs ZXNzL2F0aC9hdGgxMWsvY29yZS5jIHwgIDEgKwogZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0 aDExay9jb3JlLmggfCAgNSArKysKIGRyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMWsvcW1p LmMgIHwgNjYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLQogZHJpdmVycy9uZXQv d2lyZWxlc3MvYXRoL2F0aDExay9xbWkuaCAgfCAgMyArKwogNSBmaWxlcyBjaGFuZ2VkLCA5NCBp bnNlcnRpb25zKCspLCA3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dp cmVsZXNzL2F0aC9hdGgxMWsvYWhiLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFr L2FoYi5jCmluZGV4IDdlOWJmZWEuLjJlMGQ2MWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dp cmVsZXNzL2F0aC9hdGgxMWsvYWhiLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0 aDExay9haGIuYwpAQCAtNjM4LDYgKzYzOCwzMCBAQCBzdGF0aWMgdm9pZCBhdGgxMWtfYWhiX3Bv d2VyX2Rvd24oc3RydWN0IGF0aDExa19iYXNlICphYikKIAlycHJvY19zaHV0ZG93bihhYi0+dGd0 X3Jwcm9jKTsKIH0KIAorc3RhdGljIGludCBhdGgxMWtfYWhiX2Z3cmVzZXRfZnJvbV9jb2xkX2Jv b3Qoc3RydWN0IGF0aDExa19iYXNlICphYikKK3sKKwlpbnQgdGltZW91dDsKKworCWlmIChhdGgx MWtfY29sZF9ib290X2NhbCA9PSAwIHx8IGFiLT5xbWkuY2FsX2RvbmUpCisJCXJldHVybiAwOwor CisJYXRoMTFrX2RiZyhhYiwgQVRIMTFLX0RCR19BSEIsICJ3YWl0IGZvciBjb2xkIGJvb3QgZG9u ZVxuIik7CisJdGltZW91dCA9IHdhaXRfZXZlbnRfdGltZW91dChhYi0+cW1pLmNvbGRfYm9vdF93 YWl0cSwKKwkJCQkgICAgIChhYi0+cW1pLmNhbF9kb25lICA9PSAxKSwKKwkJCQkgICAgIEFUSDEx S19DT0xEX0JPT1RfRldfUkVTRVRfREVMQVkpOworCWlmICh0aW1lb3V0IDw9IDApIHsKKwkJYXRo MTFrX3dhcm4oYWIsICJDb2xkYm9vdCBDYWxpYnJhdGlvbiB0aW1lZCBvdXRcbiIpOworCQlyZXR1 cm4gLUVUSU1FRE9VVDsKKwl9CisKKwkvKiByZXNldCB0aGUgZmlybXdhcmUgKi8KKwlhdGgxMWtf YWhiX3Bvd2VyX2Rvd24oYWIpOworCWF0aDExa19haGJfcG93ZXJfdXAoYWIpOworCisJYXRoMTFr X2RiZyhhYiwgQVRIMTFLX0RCR19BSEIsICJleGl0IHdhaXQgZm9yIGNvbGQgYm9vdCBkb25lXG4i KTsKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIHZvaWQgYXRoMTFrX2FoYl9pbml0X3FtaV9jZV9j b25maWcoc3RydWN0IGF0aDExa19iYXNlICphYikKIHsKIAlzdHJ1Y3QgYXRoMTFrX3FtaV9jZV9j ZmcgKmNmZyA9ICZhYi0+cW1pLmNlX2NmZzsKQEAgLTk2NCw2ICs5ODgsOCBAQCBzdGF0aWMgaW50 IGF0aDExa19haGJfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJZ290byBl cnJfY2VfZnJlZTsKIAl9CiAKKwlhdGgxMWtfYWhiX2Z3cmVzZXRfZnJvbV9jb2xkX2Jvb3QoYWIp OworCiAJcmV0dXJuIDA7CiAKIGVycl9jZV9mcmVlOgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQv d2lyZWxlc3MvYXRoL2F0aDExay9jb3JlLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRo MTFrL2NvcmUuYwppbmRleCAzOGU4MzBhLi41MzNjN2IyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25l dC93aXJlbGVzcy9hdGgvYXRoMTFrL2NvcmUuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9h dGgvYXRoMTFrL2NvcmUuYwpAQCAtODAxLDYgKzgwMSw3IEBAIHN0cnVjdCBhdGgxMWtfYmFzZSAq YXRoMTFrX2NvcmVfYWxsb2Moc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3QgcHJpdl9zaXplLAog CUlOSVRfTElTVF9IRUFEKCZhYi0+cGVlcnMpOwogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmFiLT5w ZWVyX21hcHBpbmdfd3EpOwogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmFiLT53bWlfYWIudHhfY3Jl ZGl0c193cSk7CisJaW5pdF93YWl0cXVldWVfaGVhZCgmYWItPnFtaS5jb2xkX2Jvb3Rfd2FpdHEp OwogCUlOSVRfV09SSygmYWItPnJlc3RhcnRfd29yaywgYXRoMTFrX2NvcmVfcmVzdGFydCk7CiAJ dGltZXJfc2V0dXAoJmFiLT5yeF9yZXBsZW5pc2hfcmV0cnksIGF0aDExa19jZV9yeF9yZXBsZW5p c2hfcmV0cnksIDApOwogCWFiLT5kZXYgPSBkZXY7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93 aXJlbGVzcy9hdGgvYXRoMTFrL2NvcmUuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgx MWsvY29yZS5oCmluZGV4IGI2Y2NkOWYuLmQ3MzZmYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0 L3dpcmVsZXNzL2F0aC9hdGgxMWsvY29yZS5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0 aC9hdGgxMWsvY29yZS5oCkBAIC05OCw4ICs5OCwxMyBAQCBlbnVtIGF0aDExa19maXJtd2FyZV9t b2RlIHsKIAogCS8qIGZhY3RvcnkgdGVzdHMgZXRjICovCiAJQVRIMTFLX0ZJUk1XQVJFX01PREVf RlRNLAorCisJLyogQ29sZCBib290IGNhbGlicmF0aW9uICovCisJQVRIMTFLX0ZJUk1XQVJFX01P REVfQ09MRF9CT09UID0gNywKIH07CiAKK2V4dGVybiBib29sIGF0aDExa19jb2xkX2Jvb3RfY2Fs OworCiAjZGVmaW5lIEFUSDExS19JUlFfTlVNX01BWCA1MgogI2RlZmluZSBBVEgxMUtfRVhUX0lS UV9HUlBfTlVNX01BWCAxMQogI2RlZmluZSBBVEgxMUtfRVhUX0lSUV9OVU1fTUFYCTE2CmRpZmYg LS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL3FtaS5jIGIvZHJpdmVycy9u ZXQvd2lyZWxlc3MvYXRoL2F0aDExay9xbWkuYwppbmRleCA1MDgxMmRmLi5mOWRmM2ZkIDEwMDY0 NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL3FtaS5jCisrKyBiL2RyaXZl cnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMWsvcW1pLmMKQEAgLTksNiArOSwxMiBAQAogI2luY2x1 ZGUgPGxpbnV4L29mLmg+CiAjaW5jbHVkZSA8bGludXgvZmlybXdhcmUuaD4KIAorYm9vbCBhdGgx MWtfY29sZF9ib290X2NhbCA9IDE7Cittb2R1bGVfcGFyYW1fbmFtZWQoY29sZF9ib290X2NhbCwg YXRoMTFrX2NvbGRfYm9vdF9jYWwsIGJvb2wsIDA2NDQpOworTU9EVUxFX1BBUk1fREVTQyhjb2xk X2Jvb3RfY2FsLAorCQkgIkNvbGQgYm9vdCB3aWxsIGJyaW5nIGRvd24gdGhlIGNoYW5uZWwgc3dp dGNoIHRpbWUgYnV0ICIKKwkJICJpdCB3aWxsIGluY3JlYXNlIHRoZSBkcml2ZXIgbG9hZCB0aW1l IChlbmFibGU6MSwgZGlzYWJsZTowKSIpOworCiBzdGF0aWMgc3RydWN0IHFtaV9lbGVtX2luZm8g cW1pX3dsYW5md19ob3N0X2NhcF9yZXFfbXNnX3YwMV9laVtdID0gewogCXsKIAkJLmRhdGFfdHlw ZQk9IFFNSV9PUFRfRkxBRywKQEAgLTE2OTIsOSArMTY5OCwxNiBAQCBzdGF0aWMgaW50IGF0aDEx a19xbWlfYWxsb2NfdGFyZ2V0X21lbV9jaHVuayhzdHJ1Y3QgYXRoMTFrX2Jhc2UgKmFiKQogCQkJ CWF0aDExa193YXJuKGFiLCAicW1pIG1lbSBzaXplIGlzIGxvdyB0byBsb2FkIGNhbGRhdGFcbiIp OwogCQkJCXJldHVybiAtRUlOVkFMOwogCQkJfQotCQkJLyogVE9ETyBhdGgxMWsgZG9lcyBub3Qg c3VwcG9ydCBjb2xkIGJvb3QgY2FsaWJyYXRpb24gKi8KLQkJCWFiLT5xbWkudGFyZ2V0X21lbVtp ZHhdLnBhZGRyID0gMDsKLQkJCWFiLT5xbWkudGFyZ2V0X21lbVtpZHhdLnZhZGRyID0gMDsKKwor CQkJaWYgKGF0aDExa19jb2xkX2Jvb3RfY2FsKSB7CisJCQkJYWItPnFtaS50YXJnZXRfbWVtW2lk eF0ucGFkZHIgPQorCQkJCQkJICAgICBBVEgxMUtfUU1JX0NBTERCX0FERFJFU1M7CisJCQkJYWIt PnFtaS50YXJnZXRfbWVtW2lkeF0udmFkZHIgPQorCQkJCQkJICAgICBBVEgxMUtfUU1JX0NBTERC X0FERFJFU1M7CisJCQl9IGVsc2UgeworCQkJCWFiLT5xbWkudGFyZ2V0X21lbVtpZHhdLnBhZGRy ID0gMDsKKwkJCQlhYi0+cW1pLnRhcmdldF9tZW1baWR4XS52YWRkciA9IDA7CisJCQl9CiAJCQlh Yi0+cW1pLnRhcmdldF9tZW1baWR4XS5zaXplID0gYWItPnFtaS50YXJnZXRfbWVtW2ldLnNpemU7 CiAJCQlhYi0+cW1pLnRhcmdldF9tZW1baWR4XS50eXBlID0gYWItPnFtaS50YXJnZXRfbWVtW2ld LnR5cGU7CiAJCQlpZHgrKzsKQEAgLTIxMTEsNiArMjEyNCwzMiBAQCBpbnQgYXRoMTFrX3FtaV9m aXJtd2FyZV9zdGFydChzdHJ1Y3QgYXRoMTFrX2Jhc2UgKmFiLAogCXJldHVybiAwOwogfQogCitz dGF0aWMgaW50IGF0aDExa19xbWlfcHJvY2Vzc19jb2xkYm9vdF9jYWxpYnJhdGlvbihzdHJ1Y3Qg YXRoMTFrX2Jhc2UgKmFiKQoreworCWludCB0aW1lb3V0OworCWludCByZXQ7CisKKwlyZXQgPSBh dGgxMWtfcW1pX3dsYW5md19tb2RlX3NlbmQoYWIsIEFUSDExS19GSVJNV0FSRV9NT0RFX0NPTERf Qk9PVCk7CisJaWYgKHJldCA8IDApIHsKKwkJYXRoMTFrX3dhcm4oYWIsICJxbWkgZmFpbGVkIHRv IHNlbmQgd2xhbiBmdyBtb2RlOiVkXG4iLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKworCWF0 aDExa193YXJuKGFiLCAiQ29sZGJvb3QgY2FsaWJyYXRpb24gd2FpdCBzdGFydGVkXG4iKTsKKwor CXRpbWVvdXQgPSB3YWl0X2V2ZW50X3RpbWVvdXQoYWItPnFtaS5jb2xkX2Jvb3Rfd2FpdHEsCisJ CQkJICAgICAoYWItPnFtaS5jYWxfZG9uZSAgPT0gMSksCisJCQkJICAgICBBVEgxMUtfQ09MRF9C T09UX0ZXX1JFU0VUX0RFTEFZKTsKKwlpZiAodGltZW91dCA8PSAwKSB7CisJCWF0aDExa193YXJu KGFiLCAiQ29sZGJvb3QgQ2FsaWJyYXRpb24gdGltZWQgb3V0XG4iKTsKKwkJcmV0dXJuIC1FVElN RURPVVQ7CisJfQorCisJYXRoMTFrX3dhcm4oYWIsICJDb2xkYm9vdCBjYWxpYnJhdGlvbiB3YWl0 IGVuZGVkXG4iKTsKKworCXJldHVybiAwOworfQorCiBzdGF0aWMgaW50CiBhdGgxMWtfcW1pX2Ry aXZlcl9ldmVudF9wb3N0KHN0cnVjdCBhdGgxMWtfcW1pICpxbWksCiAJCQkgICAgIGVudW0gYXRo MTFrX3FtaV9ldmVudF90eXBlIHR5cGUsCkBAIC0yMjQ3LDExICsyMjg2LDE4IEBAIHN0YXRpYyB2 b2lkIGF0aDExa19xbWlfbXNnX2Z3X3JlYWR5X2NiKHN0cnVjdCBxbWlfaGFuZGxlICpxbWlfaGRs LAogCWF0aDExa19xbWlfZHJpdmVyX2V2ZW50X3Bvc3QocW1pLCBBVEgxMUtfUU1JX0VWRU5UX0ZX X1JFQURZLCBOVUxMKTsKIH0KIAotc3RhdGljIHZvaWQgYXRoMTFrX3FtaV9tc2dfY29sZF9ib290 X2NhbF9kb25lX2NiKHN0cnVjdCBxbWlfaGFuZGxlICpxbWksCitzdGF0aWMgdm9pZCBhdGgxMWtf cW1pX21zZ19jb2xkX2Jvb3RfY2FsX2RvbmVfY2Ioc3RydWN0IHFtaV9oYW5kbGUgKnFtaV9oZGws CiAJCQkJCQkgc3RydWN0IHNvY2thZGRyX3FydHIgKnNxLAogCQkJCQkJIHN0cnVjdCBxbWlfdHhu ICp0eG4sCiAJCQkJCQkgY29uc3Qgdm9pZCAqZGVjb2RlZCkKIHsKKwlzdHJ1Y3QgYXRoMTFrX3Ft aSAqcW1pID0gY29udGFpbmVyX29mKHFtaV9oZGwsCisJCQkJCSAgICAgIHN0cnVjdCBhdGgxMWtf cW1pLCBoYW5kbGUpOworCXN0cnVjdCBhdGgxMWtfYmFzZSAqYWIgPSBxbWktPmFiOworCisJYWIt PnFtaS5jYWxfZG9uZSA9IDE7CisJd2FrZV91cCgmYWItPnFtaS5jb2xkX2Jvb3Rfd2FpdHEpOwor CWF0aDExa19kYmcoYWIsIEFUSDExS19EQkdfUU1JLCAicW1pIGNvbGQgYm9vdCBjYWxpYnJhdGlv biBkb25lXG4iKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBxbWlfbXNnX2hhbmRsZXIgYXRo MTFrX3FtaV9tc2dfaGFuZGxlcnNbXSA9IHsKQEAgLTIzNjQsOSArMjQxMCwxNSBAQCBzdGF0aWMg dm9pZCBhdGgxMWtfcW1pX2RyaXZlcl9ldmVudF93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29y aykKIAkJCQlicmVhazsKIAkJCX0KIAotCQkJYXRoMTFrX2NvcmVfcW1pX2Zpcm13YXJlX3JlYWR5 KGFiKTsKLQkJCWFiLT5xbWkuY2FsX2RvbmUgPSAxOwotCQkJc2V0X2JpdChBVEgxMUtfRkxBR19S RUdJU1RFUkVELCAmYWItPmRldl9mbGFncyk7CisJCQlpZiAoYXRoMTFrX2NvbGRfYm9vdF9jYWwg JiYgYWItPnFtaS5jYWxfZG9uZSA9PSAwKSB7CisJCQkJYXRoMTFrX3FtaV9wcm9jZXNzX2NvbGRi b290X2NhbGlicmF0aW9uKGFiKTsKKwkJCX0gZWxzZSB7CisJCQkJY2xlYXJfYml0KEFUSDExS19G TEFHX0NSQVNIX0ZMVVNILAorCQkJCQkgICZhYi0+ZGV2X2ZsYWdzKTsKKwkJCQljbGVhcl9iaXQo QVRIMTFLX0ZMQUdfUkVDT1ZFUlksICZhYi0+ZGV2X2ZsYWdzKTsKKwkJCQlhdGgxMWtfY29yZV9x bWlfZmlybXdhcmVfcmVhZHkoYWIpOworCQkJCXNldF9iaXQoQVRIMTFLX0ZMQUdfUkVHSVNURVJF RCwgJmFiLT5kZXZfZmxhZ3MpOworCQkJfQogCiAJCQlicmVhazsKIAkJY2FzZSBBVEgxMUtfUU1J X0VWRU5UX0NPTERfQk9PVF9DQUxfRE9ORToKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVs ZXNzL2F0aC9hdGgxMWsvcW1pLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL3Ft aS5oCmluZGV4IDMzMDdiZTUuLjAyYzA1Y2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVs ZXNzL2F0aC9hdGgxMWsvcW1pLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDEx ay9xbWkuaApAQCAtMTIsNiArMTIsNyBAQAogI2RlZmluZSBBVEgxMUtfSE9TVF9WRVJTSU9OX1NU UklORwkJIldJTiIKICNkZWZpbmUgQVRIMTFLX1FNSV9XTEFORldfVElNRU9VVF9NUwkJNTAwMAog I2RlZmluZSBBVEgxMUtfUU1JX01BWF9CREZfRklMRV9OQU1FX1NJWkUJNjQKKyNkZWZpbmUgQVRI MTFLX1FNSV9DQUxEQl9BRERSRVNTCQkweDRCQTAwMDAwCiAjZGVmaW5lIEFUSDExS19RTUlfQkRG X01BWF9TSVpFCQkJKDI1NiAqIDEwMjQpCiAjZGVmaW5lIEFUSDExS19RTUlfQ0FMREFUQV9PRkZT RVQJCSgxMjggKiAxMDI0KQogI2RlZmluZSBBVEgxMUtfUU1JX1dMQU5GV19NQVhfQlVJTERfSURf TEVOX1YwMQkxMjgKQEAgLTMxLDYgKzMyLDcgQEAKICNkZWZpbmUgUU1JX1dMQU5GV19NQVhfREFU QV9TSVpFX1YwMQkJNjE0NAogI2RlZmluZSBBVEgxMUtfRklSTVdBUkVfTU9ERV9PRkYJCTQKICNk ZWZpbmUgQVRIMTFLX1FNSV9UQVJHRVRfTUVNX01PREVfREVGQVVMVAkwCisjZGVmaW5lIEFUSDEx S19DT0xEX0JPT1RfRldfUkVTRVRfREVMQVkJCSg0MCAqIEhaKQogCiBzdHJ1Y3QgYXRoMTFrX2Jh c2U7CiAKQEAgLTExMCw2ICsxMTIsNyBAQCBzdHJ1Y3QgYXRoMTFrX3FtaSB7CiAJdTMyIHRhcmdl dF9tZW1fbW9kZTsKIAl1OCBjYWxfZG9uZTsKIAlzdHJ1Y3QgdGFyZ2V0X2luZm8gdGFyZ2V0Owor CXdhaXRfcXVldWVfaGVhZF90IGNvbGRfYm9vdF93YWl0cTsKIH07CiAKICNkZWZpbmUgUU1JX1dM QU5GV19IT1NUX0NBUF9SRVFfTVNHX1YwMV9NQVhfTEVOCQkxODkKLS0gCjIuNy40CgoKLS0gCmF0 aDExayBtYWlsaW5nIGxpc3QKYXRoMTFrQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3Rz LmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9hdGgxMWsK