From patchwork Mon Nov 30 23:37:09 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alex Elder X-Patchwork-Id: 334727 Delivered-To: patch@linaro.org Received: by 2002:a92:5e16:0:0:0:0:0 with SMTP id s22csp5160070ilb; Mon, 30 Nov 2020 15:38:23 -0800 (PST) X-Google-Smtp-Source: ABdhPJwfxvIaY2i2A9IW3gTi/zr458Jr9dYuXQmrVVRiwIHFBmq+H0N1MTJlE/ia3KKjcJzX39DE X-Received: by 2002:aa7:c94b:: with SMTP id h11mr147886edt.322.1606779503652; Mon, 30 Nov 2020 15:38:23 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1606779503; cv=none; d=google.com; s=arc-20160816; b=roSeBb7NkPzJXJ6FuAaNXumPxt9qzeCbAc7XQTAfKa228J5ILuna5W/0Pcfz3ppTkK fkeOtutr6QJmZhTqa0lXy/0asd8MNmrEXvaHKq7Ns8E/9EDMLP1qjh5MbLCcg+xZUdvb kduI8xn2MIT9SaxhuCgMIyMGe3z4KcZIChvDpXSMR3QAtqKiv9ubSG0l9pH2WJhIBaSu f/aU2HEpDNP6xgQoCKKEIkhN+oZ8fAlr0zaoLaYFuUAs8w15hCFb5oFbofCxYZsEYFJA k2s9aqyor0Z/5EvoWUjpKW5UNbaikBRoymrEzZsclK8lh44UH87mLtHyCpAmoMBfZ3uo 0X3g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=ls6ZikrHvoiYVZgb6g/fijukDjRX3YaJwgzv63JXyJM=; b=P+I01LnX9VFfBIzKbiGUDe6amQ86Bw329rI/4khEIp7k1GHKUeUHCa1yoBoo6jYPp1 LkslXn0PWZQqNPm8jxa8LFdJrbdtcFijecNqN8h6I/RP1oVpE7QlKd6zUayIuJ8JSXRh k1NvVUT7I492tQiRG3Je43yVq8jqybZROV218NYQUpdam/5q0E049z/6k361oBM1r9Pw O7gtEbWh6jKsvemj3JqHuTpj4VKOpNtbc9lotJh74OQlBDijIzBmBmy98Xpasal6qfV6 g+VXy5c0cG0jkSMjFDsl/jBLMCSopSY0lNR2HU9ueWQzZJG7iy44UdodprI+D9utk0i0 roiQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=LKlfRNVr; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id w6si12427824edr.89.2020.11.30.15.38.23; Mon, 30 Nov 2020 15:38:23 -0800 (PST) Received-SPF: pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=LKlfRNVr; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388946AbgK3XiA (ORCPT + 8 others); Mon, 30 Nov 2020 18:38:00 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48482 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388860AbgK3Xh6 (ORCPT ); Mon, 30 Nov 2020 18:37:58 -0500 Received: from mail-io1-xd42.google.com (mail-io1-xd42.google.com [IPv6:2607:f8b0:4864:20::d42]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4299BC0613D3 for ; Mon, 30 Nov 2020 15:37:18 -0800 (PST) Received: by mail-io1-xd42.google.com with SMTP id d8so12510146ioc.13 for ; Mon, 30 Nov 2020 15:37:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ls6ZikrHvoiYVZgb6g/fijukDjRX3YaJwgzv63JXyJM=; b=LKlfRNVrjf+qN5ebEP0Kra+aVaFplw1DNo+iOV6rKxJch3b0PksxxI5OOQ9QcH3hFt lO+cIi3BQOARzccwYCX6i7OhCSrmnx2wKRYVgti7wqYuqdB2NTnEcJp0J5sZ0djUn5Qc 5dAjH6FJHt3QS56hKxNhAKxbUfT4NmP9SxIZPO/D0qbNcW+V4+6Abf8Ynxn1qXtx+8rT QRi9MKGw8ZYWDmlyTJ63pI33XE0Nu1XmyrzQbp0XMeRG94vfg1dy8H2p7h14YiAM/QAp 82ZKut169Dmv+iPq5+aICRnpyLzJ44spcSSFiLfbCqttsVMSEoXLal15QxDJOxesB+ar ehsQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ls6ZikrHvoiYVZgb6g/fijukDjRX3YaJwgzv63JXyJM=; b=MjwINJW0D5PpMgz2piaTh0DKl3rJvO7U30+tP/j6/KeQfhuwlT3+lDiy9Je6AlD40W p3/r03KDSeh6X6G8gNYkWj+9kT6cRQ6QWHxbAvdldFu/Ip2gOqOTnjjQnoP4qS+SIrbI dBTJiyz86q61gLh3FzdV/8d5TvJqFA1mTsD6emvVtDafR50ahjraq2S3LXhkT4e8ItBW U9+7oI99/YCYwWLAgVj0hZHWOdePb+P2NVQYkycTTlVVl6Incq2w3hhbjBQrWGUMgmE5 SuxMNJTAxkFHbWT8PXCJsnPuKotsBdWpXsZuTdQWxK252dU2ICT10XeWoBM6NF5801g+ muog== X-Gm-Message-State: AOAM532pSfpt8Ap4x6fNRzevAfTjOtFqBMA/8qMHoCNO+hAPT5otQmak U597Dp84y1IZyGgymWe95CaPblg8R/Zq+w== X-Received: by 2002:a02:a304:: with SMTP id q4mr172780jai.97.1606779437492; Mon, 30 Nov 2020 15:37:17 -0800 (PST) Received: from beast.localdomain (c-73-185-129-58.hsd1.mn.comcast.net. [73.185.129.58]) by smtp.gmail.com with ESMTPSA id o195sm62574ila.38.2020.11.30.15.37.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 30 Nov 2020 15:37:16 -0800 (PST) From: Alex Elder To: davem@davemloft.net, kuba@kernel.org Cc: evgreen@chromium.org, subashab@codeaurora.org, cpratapa@codeaurora.org, bjorn.andersson@linaro.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH net-next 1/4] net: ipa: update IPA aggregation registers for IPA v4.5 Date: Mon, 30 Nov 2020 17:37:09 -0600 Message-Id: <20201130233712.29113-2-elder@linaro.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20201130233712.29113-1-elder@linaro.org> References: <20201130233712.29113-1-elder@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org IPA v4.5 significantly changes the format of the configuration register used for endpoint aggregation. The AGGR_BYTE_LIMIT field is now larger, and the positions of other fields are shifted. This complicates the way we have to access this register because functions like u32_encode_bits() require their field mask argument to be constant. A further complication is that we want to know the maximum value representable by at least one of these fields, and that too requires a constant field mask. This patch adds support for IPA v4.5 endpoint aggregation registers in a way that continues to support "legacy" IPA hardware. It does so in a way that keeps field masks constant. First, for each variable field mask, we define an inline function whose return value is either the legacy value or the IPA v4.5 value. Second, we define functions for these fields that encode a value to use in each field based on the IPA version (this approach is already used elsewhere). The field mask provided is supplied by the function mentioned above. Finally, for the aggregation byte limit fields where we want to know the maximum representable value, we define a function that returns that maximum, computed from the appropriate field mask. We can no longer verify at build time that our buffer size is in the range that can be represented by the aggregation byte limit field. So remove the test done by a BUILD_BUG_ON() call in ipa_endpoint_validate_build(), and implement a comparable check at the top of ipa_endpoint_data_valid(). Doing that makes ipa_endpoint_validate_build() contain a single line BUILD_BUG_ON() call, so just remove that function and move the remaining line into ipa_endpoint_data_valid(). One final note: the aggregation time limit value for IPA v4.5 needs to be computed differently. That is handled in an upcoming patch. Signed-off-by: Alex Elder --- drivers/net/ipa/ipa_endpoint.c | 102 ++++++++++++++++++++++----------- drivers/net/ipa/ipa_reg.h | 38 ++++++++++-- 2 files changed, 101 insertions(+), 39 deletions(-) -- 2.20.1 diff --git a/drivers/net/ipa/ipa_endpoint.c b/drivers/net/ipa/ipa_endpoint.c index 27f543b6780b1..f260c80f50649 100644 --- a/drivers/net/ipa/ipa_endpoint.c +++ b/drivers/net/ipa/ipa_endpoint.c @@ -37,7 +37,7 @@ #define IPA_ENDPOINT_QMAP_METADATA_MASK 0x000000ff /* host byte order */ #define IPA_ENDPOINT_RESET_AGGR_RETRY_MAX 3 -#define IPA_AGGR_TIME_LIMIT_DEFAULT 500 /* microseconds */ +#define IPA_AGGR_TIME_LIMIT 500 /* microseconds */ /** enum ipa_status_opcode - status element opcode hardware values */ enum ipa_status_opcode { @@ -74,31 +74,6 @@ struct ipa_status { #ifdef IPA_VALIDATE -static void ipa_endpoint_validate_build(void) -{ - /* The aggregation byte limit defines the point at which an - * aggregation window will close. It is programmed into the - * IPA hardware as a number of KB. We don't use "hard byte - * limit" aggregation, which means that we need to supply - * enough space in a receive buffer to hold a complete MTU - * plus normal skb overhead *after* that aggregation byte - * limit has been crossed. - * - * This check just ensures we don't define a receive buffer - * size that would exceed what we can represent in the field - * that is used to program its size. - */ - BUILD_BUG_ON(IPA_RX_BUFFER_SIZE > - field_max(AGGR_BYTE_LIMIT_FMASK) * SZ_1K + - IPA_MTU + IPA_RX_BUFFER_OVERHEAD); - - /* I honestly don't know where this requirement comes from. But - * it holds, and if we someday need to loosen the constraint we - * can try to track it down. - */ - BUILD_BUG_ON(sizeof(struct ipa_status) % 4); -} - static bool ipa_endpoint_data_valid_one(struct ipa *ipa, u32 count, const struct ipa_gsi_endpoint_data *all_data, const struct ipa_gsi_endpoint_data *data) @@ -180,14 +155,24 @@ static bool ipa_endpoint_data_valid_one(struct ipa *ipa, u32 count, return true; } +static u32 aggr_byte_limit_max(enum ipa_version version) +{ + if (version < IPA_VERSION_4_5) + return field_max(aggr_byte_limit_fmask(true)); + + return field_max(aggr_byte_limit_fmask(false)); +} + static bool ipa_endpoint_data_valid(struct ipa *ipa, u32 count, const struct ipa_gsi_endpoint_data *data) { const struct ipa_gsi_endpoint_data *dp = data; struct device *dev = &ipa->pdev->dev; enum ipa_endpoint_name name; + u32 limit; - ipa_endpoint_validate_build(); + /* Not sure where this constraint come from... */ + BUILD_BUG_ON(sizeof(struct ipa_status) % 4); if (count > IPA_ENDPOINT_COUNT) { dev_err(dev, "too many endpoints specified (%u > %u)\n", @@ -195,6 +180,26 @@ static bool ipa_endpoint_data_valid(struct ipa *ipa, u32 count, return false; } + /* The aggregation byte limit defines the point at which an + * aggregation window will close. It is programmed into the + * IPA hardware as a number of KB. We don't use "hard byte + * limit" aggregation, which means that we need to supply + * enough space in a receive buffer to hold a complete MTU + * plus normal skb overhead *after* that aggregation byte + * limit has been crossed. + * + * This check ensures we don't define a receive buffer size + * that would exceed what we can represent in the field that + * is used to program its size. + */ + limit = aggr_byte_limit_max(ipa->version) * SZ_1K; + limit += IPA_MTU + IPA_RX_BUFFER_OVERHEAD; + if (limit < IPA_RX_BUFFER_SIZE) { + dev_err(dev, "buffer size too big for aggregation (%u > %u)\n", + IPA_RX_BUFFER_SIZE, limit); + return false; + } + /* Make sure needed endpoints have defined data */ if (ipa_gsi_endpoint_data_empty(&data[IPA_ENDPOINT_AP_COMMAND_TX])) { dev_err(dev, "command TX endpoint not defined\n"); @@ -624,29 +629,60 @@ static u32 ipa_aggr_size_kb(u32 rx_buffer_size) return rx_buffer_size / SZ_1K; } +/* Encoded values for AGGR endpoint register fields */ +static u32 aggr_byte_limit_encoded(enum ipa_version version, u32 limit) +{ + if (version < IPA_VERSION_4_5) + return u32_encode_bits(limit, aggr_byte_limit_fmask(true)); + + return u32_encode_bits(limit, aggr_byte_limit_fmask(false)); +} + +static u32 aggr_time_limit_encoded(enum ipa_version version, u32 limit) +{ + /* Convert limit (microseconds) to aggregation timer ticks */ + limit = DIV_ROUND_CLOSEST(limit, IPA_AGGR_GRANULARITY); + if (version < IPA_VERSION_4_5) + return u32_encode_bits(limit, aggr_time_limit_fmask(true)); + + return u32_encode_bits(limit, aggr_time_limit_fmask(false)); +} + +static u32 aggr_sw_eof_active_encoded(enum ipa_version version, bool enabled) +{ + u32 val = enabled ? 1 : 0; + + if (version < IPA_VERSION_4_5) + return u32_encode_bits(val, aggr_sw_eof_active_fmask(true)); + + return u32_encode_bits(val, aggr_sw_eof_active_fmask(false)); +} + static void ipa_endpoint_init_aggr(struct ipa_endpoint *endpoint) { u32 offset = IPA_REG_ENDP_INIT_AGGR_N_OFFSET(endpoint->endpoint_id); + enum ipa_version version = endpoint->ipa->version; u32 val = 0; if (endpoint->data->aggregation) { if (!endpoint->toward_ipa) { + bool close_eof; u32 limit; val |= u32_encode_bits(IPA_ENABLE_AGGR, AGGR_EN_FMASK); val |= u32_encode_bits(IPA_GENERIC, AGGR_TYPE_FMASK); limit = ipa_aggr_size_kb(IPA_RX_BUFFER_SIZE); - val |= u32_encode_bits(limit, AGGR_BYTE_LIMIT_FMASK); + val |= aggr_byte_limit_encoded(version, limit); - limit = IPA_AGGR_TIME_LIMIT_DEFAULT; - limit = DIV_ROUND_CLOSEST(limit, IPA_AGGR_GRANULARITY); - val |= u32_encode_bits(limit, AGGR_TIME_LIMIT_FMASK); + limit = IPA_AGGR_TIME_LIMIT; + val |= aggr_time_limit_encoded(version, limit); /* AGGR_PKT_LIMIT is 0 (unlimited) */ - if (endpoint->data->rx.aggr_close_eof) - val |= AGGR_SW_EOF_ACTIVE_FMASK; + close_eof = endpoint->data->rx.aggr_close_eof; + val |= aggr_sw_eof_active_encoded(version, close_eof); + /* AGGR_HARD_BYTE_LIMIT_ENABLE is 0 */ } else { val |= u32_encode_bits(IPA_ENABLE_DEAGGR, diff --git a/drivers/net/ipa/ipa_reg.h b/drivers/net/ipa/ipa_reg.h index 3fabafd7e32c6..09dcfa2998f04 100644 --- a/drivers/net/ipa/ipa_reg.h +++ b/drivers/net/ipa/ipa_reg.h @@ -450,12 +450,38 @@ enum ipa_mode { (0x00000824 + 0x0070 * (ep)) #define AGGR_EN_FMASK GENMASK(1, 0) #define AGGR_TYPE_FMASK GENMASK(4, 2) -#define AGGR_BYTE_LIMIT_FMASK GENMASK(9, 5) -#define AGGR_TIME_LIMIT_FMASK GENMASK(14, 10) -#define AGGR_PKT_LIMIT_FMASK GENMASK(20, 15) -#define AGGR_SW_EOF_ACTIVE_FMASK GENMASK(21, 21) -#define AGGR_FORCE_CLOSE_FMASK GENMASK(22, 22) -#define AGGR_HARD_BYTE_LIMIT_ENABLE_FMASK GENMASK(24, 24) +static inline u32 aggr_byte_limit_fmask(bool legacy) +{ + return legacy ? GENMASK(9, 5) : GENMASK(10, 5); +} + +static inline u32 aggr_time_limit_fmask(bool legacy) +{ + return legacy ? GENMASK(14, 10) : GENMASK(16, 12); +} + +static inline u32 aggr_pkt_limit_fmask(bool legacy) +{ + return legacy ? GENMASK(20, 15) : GENMASK(22, 17); +} + +static inline u32 aggr_sw_eof_active_fmask(bool legacy) +{ + return legacy ? GENMASK(21, 21) : GENMASK(23, 23); +} + +static inline u32 aggr_force_close_fmask(bool legacy) +{ + return legacy ? GENMASK(22, 22) : GENMASK(24, 24); +} + +static inline u32 aggr_hard_byte_limit_enable_fmask(bool legacy) +{ + return legacy ? GENMASK(24, 24) : GENMASK(26, 26); +} + +/* The next field is present for IPA v4.5 */ +#define AGGR_GRAN_SEL_FMASK GENMASK(27, 27) /** enum ipa_aggr_en - aggregation enable field in ENDP_INIT_AGGR_N */ enum ipa_aggr_en { From patchwork Mon Nov 30 23:37:10 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alex Elder X-Patchwork-Id: 334730 Delivered-To: patch@linaro.org Received: by 2002:a92:5e16:0:0:0:0:0 with SMTP id s22csp5161100ilb; Mon, 30 Nov 2020 15:40:10 -0800 (PST) X-Google-Smtp-Source: ABdhPJwhWGZv1GUjrZM0mXiABVTUN82WdUkI9vBLvUK1/n/8zHtDKArAYs7Kv5aH7ADpBV/ZFC3U X-Received: by 2002:aa7:c358:: with SMTP id j24mr115139edr.265.1606779610482; Mon, 30 Nov 2020 15:40:10 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1606779610; cv=none; d=google.com; s=arc-20160816; b=AzPE4FFYaG+/ib+iStzCW9/snrnCcA1ZXIRwtJpb32u+uj5kO05Odzx3Cr9DH37W51 A1WRZvVpUieA2tk1l7w+RX8Yn74XW/62nCqwkIr2jQ0l+rBNhyeTzd5GOPGBGCZUPZnF wZpExiuOcGHzOmaWoRLe8mURAtE+3siFgFsQc2cNMIXALMbZ6aWKA7/jFLFS8/+QLSjv INudKBQePdoJ9pyqL/AbLMyU3MJl7F50rqgixo7AdKh9RTGybyhnGp3K87fneWMLU3F+ EjI+IIIf1m5mMOQ2ECcXYbawTKmrsIrNqi5V9c5AGFaX+2MVr5Y4u5iYnv28luzgDQjW q0Jg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=9pzSYVU1xS021lAMo10yE/erRoJ8GUJHXYQ95VWiPx4=; b=y+5kI1V4yPDHSkbhcHWstlSwIJ5qQjh+9L8VeZbU8pPNZmk+y/DMfcHFWoZ3Zic/be Ds/UuzJKpjcRyTlWY+X77TDUZ/7HzMVmsoOI/LKgK7eSDt42gJKYLXiAP6kGsBA7xUk6 /OMpomCHYTyjdcDjnBcRny6TDlCiwt5OYbKlsU8AcHVDWHCTGmJR3XikE45NoPKgHxW4 qLMCteoIG0ouDh+dO8HaneSPkNSxpe5kODM0UqpVOo9QMfvrUtbDz/nmJ7c4y/k58xQG tzcJiB94Qujqvtd/8NVn3R98Z2qSSDhbiB7esxOdBzr99NvupNPN4U9CZosVXch6nC0N mixg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=x1MZk3eK; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id d10si11612458ejh.20.2020.11.30.15.40.10; Mon, 30 Nov 2020 15:40:10 -0800 (PST) Received-SPF: pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=x1MZk3eK; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2389076AbgK3Xio (ORCPT + 8 others); Mon, 30 Nov 2020 18:38:44 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48586 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387738AbgK3Xin (ORCPT ); Mon, 30 Nov 2020 18:38:43 -0500 Received: from mail-il1-x144.google.com (mail-il1-x144.google.com [IPv6:2607:f8b0:4864:20::144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 48BB1C0617A6 for ; Mon, 30 Nov 2020 15:37:19 -0800 (PST) Received: by mail-il1-x144.google.com with SMTP id q1so13094264ilt.6 for ; Mon, 30 Nov 2020 15:37:19 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=9pzSYVU1xS021lAMo10yE/erRoJ8GUJHXYQ95VWiPx4=; b=x1MZk3eKkbsYW58GubxIl14zzAAcUc32FIYDsVH7DuMSHuLuqysjAIsSPUfGyY8ZP6 kKEChsykQRc6/UOWSqv6vakEtwGgwjC0461xxaCe4i4edQGoVyK4GOJxt00Ff+QDWR3o ee3EsFFvkSw8gNTxL0ntymgTvdPN9N/QsILhGq+Bq4jUtNyHC6awzCINegdnToAdje9y vTq87QP+fYtHIeBYq5hqsP+dnrdbUPyWORl/FZft1YwksIR6kOBa6xdidZrtxOoP4ebe 6gbSq7sq8xfNCm9z61GXMl8L2/Mz+nNse8Y8NF5e8nyrFH/B3SJir/7hoHZHOayndRGS FhnA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=9pzSYVU1xS021lAMo10yE/erRoJ8GUJHXYQ95VWiPx4=; b=A9NmNp0A8Xv4z+4xn4cm/ii2VkJBe7NW01LDthjjT2LVzAP8InGpkJ4XCwkOmdspJK JUlIVhHylSmyY5G8x1VxznYxgKIdL1foU2LZYXUywdQSS2YbSsVRhT57wbJlHyoEO59W WXSYBYZNaX3qTNHr0Uz3bF2ckAQ7cB1WSdsIO4rMe6fOR7mFpy2hUp+LVE/N/cfPweaG HNCCDoy1jjLsN4KtGOnrwv7QNSA0Sw5JmWXPnnM8BZG/jICp+WH5PzJ/yQVzeWLMCDoi /IHaD2AGmRBbBDotq6DFVKn5Y9y8CwokoTPTNQUJ80379N/wjTrRV3PvegLafjrbzmIE REWg== X-Gm-Message-State: AOAM5331vQeZxQqdZ3UqT/MtC+xm6BW45nRAB9DchOc/iRtB/rmCaAMk qAtwSjyBzTDuidBUsogFMshM/w== X-Received: by 2002:a92:c70b:: with SMTP id a11mr95893ilp.151.1606779438640; Mon, 30 Nov 2020 15:37:18 -0800 (PST) Received: from beast.localdomain (c-73-185-129-58.hsd1.mn.comcast.net. [73.185.129.58]) by smtp.gmail.com with ESMTPSA id o195sm62574ila.38.2020.11.30.15.37.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 30 Nov 2020 15:37:18 -0800 (PST) From: Alex Elder To: davem@davemloft.net, kuba@kernel.org Cc: evgreen@chromium.org, subashab@codeaurora.org, cpratapa@codeaurora.org, bjorn.andersson@linaro.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH net-next 2/4] net: ipa: set up IPA v4.5 Qtime configuration Date: Mon, 30 Nov 2020 17:37:10 -0600 Message-Id: <20201130233712.29113-3-elder@linaro.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20201130233712.29113-1-elder@linaro.org> References: <20201130233712.29113-1-elder@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org IPA v4.5 introduces a new unified timer architecture driven on the 19.2 MHz SoC crystal oscillator (XO). It is independent of the IPA core clock and avoids some duplication. Lower-resolution time stamps are derived from this by using only the high-order bits of the 19.2 MHz Qtime clock. And timers are derived from this based on "pulse generators" configured to fire at a fixed rate based on the Qtime clock. This patch introduces ipa_qtime_config(), which configures the Qtime mechanism for use. It also adds to the IPA register definitions related to timers and time stamping. Signed-off-by: Alex Elder --- drivers/net/ipa/ipa_main.c | 67 +++++++++++++++++++++++++++++++++++--- drivers/net/ipa/ipa_reg.h | 30 +++++++++++++++++ 2 files changed, 93 insertions(+), 4 deletions(-) -- 2.20.1 diff --git a/drivers/net/ipa/ipa_main.c b/drivers/net/ipa/ipa_main.c index f25bcfe51dd4b..d0768452c15cf 100644 --- a/drivers/net/ipa/ipa_main.c +++ b/drivers/net/ipa/ipa_main.c @@ -70,6 +70,14 @@ #define IPA_FWS_PATH "ipa_fws.mdt" #define IPA_PAS_ID 15 +/* Shift of 19.2 MHz timestamp to achieve lower resolution timestamps */ +#define DPL_TIMESTAMP_SHIFT 14 /* ~1.172 kHz, ~853 usec per tick */ +#define TAG_TIMESTAMP_SHIFT 14 +#define NAT_TIMESTAMP_SHIFT 24 /* ~1.144 Hz, ~874 msec per tick */ + +/* Divider for 19.2 MHz crystal oscillator clock to get common timer clock */ +#define IPA_XO_CLOCK_DIVIDER 192 /* 1 is subtracted where used */ + /** * ipa_suspend_handler() - Handle the suspend IPA interrupt * @ipa: IPA pointer @@ -292,6 +300,53 @@ static void ipa_hardware_config_qsb(struct ipa *ipa) iowrite32(val, ipa->reg_virt + IPA_REG_QSB_MAX_READS_OFFSET); } +/* IPA uses unified Qtime starting at IPA v4.5, implementing various + * timestamps and timers independent of the IPA core clock rate. The + * Qtimer is based on a 56-bit timestamp incremented at each tick of + * a 19.2 MHz SoC crystal oscillator (XO clock). + * + * For IPA timestamps (tag, NAT, data path logging) a lower resolution + * timestamp is achieved by shifting the Qtimer timestamp value right + * some number of bits to produce the low-order bits of the coarser + * granularity timestamp. + * + * For timers, a common timer clock is derived from the XO clock using + * a divider (we use 192, to produce a 100kHz timer clock). From + * this common clock, three "pulse generators" are used to produce + * timer ticks at a configurable frequency. IPA timers (such as + * those used for aggregation or head-of-line block handling) now + * define their period based on one of these pulse generators. + */ +static void ipa_qtime_config(struct ipa *ipa) +{ + u32 val; + + /* Timer clock divider must be disabled when we change the rate */ + iowrite32(0, ipa->reg_virt + IPA_REG_TIMERS_XO_CLK_DIV_CFG_OFFSET); + + /* Set DPL time stamp resolution to use Qtime (instead of 1 msec) */ + val = u32_encode_bits(DPL_TIMESTAMP_SHIFT, DPL_TIMESTAMP_LSB_FMASK); + val |= u32_encode_bits(1, DPL_TIMESTAMP_SEL_FMASK); + /* Configure tag and NAT Qtime timestamp resolution as well */ + val |= u32_encode_bits(TAG_TIMESTAMP_SHIFT, TAG_TIMESTAMP_LSB_FMASK); + val |= u32_encode_bits(NAT_TIMESTAMP_SHIFT, NAT_TIMESTAMP_LSB_FMASK); + iowrite32(val, ipa->reg_virt + IPA_REG_QTIME_TIMESTAMP_CFG_OFFSET); + + /* Set granularity of pulse generators used for other timers */ + val = u32_encode_bits(IPA_GRAN_100_US, GRAN_0_FMASK); + val |= u32_encode_bits(IPA_GRAN_1_MS, GRAN_1_FMASK); + val |= u32_encode_bits(IPA_GRAN_1_MS, GRAN_2_FMASK); + iowrite32(val, ipa->reg_virt + IPA_REG_TIMERS_PULSE_GRAN_CFG_OFFSET); + + /* Actual divider is 1 more than value supplied here */ + val = u32_encode_bits(IPA_XO_CLOCK_DIVIDER - 1, DIV_VALUE_FMASK); + iowrite32(val, ipa->reg_virt + IPA_REG_TIMERS_XO_CLK_DIV_CFG_OFFSET); + + /* Divider value is set; re-enable the common timer clock divider */ + val |= u32_encode_bits(1, DIV_ENABLE_FMASK); + iowrite32(val, ipa->reg_virt + IPA_REG_TIMERS_XO_CLK_DIV_CFG_OFFSET); +} + static void ipa_idle_indication_cfg(struct ipa *ipa, u32 enter_idle_debounce_thresh, bool const_non_idle_enable) @@ -362,10 +417,14 @@ static void ipa_hardware_config(struct ipa *ipa) /* Configure system bus limits */ ipa_hardware_config_qsb(ipa); - /* Configure aggregation granularity */ - granularity = ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY); - val = u32_encode_bits(granularity, AGGR_GRANULARITY_FMASK); - iowrite32(val, ipa->reg_virt + IPA_REG_COUNTER_CFG_OFFSET); + if (version < IPA_VERSION_4_5) { + /* Configure aggregation timer granularity */ + granularity = ipa_aggr_granularity_val(IPA_AGGR_GRANULARITY); + val = u32_encode_bits(granularity, AGGR_GRANULARITY_FMASK); + iowrite32(val, ipa->reg_virt + IPA_REG_COUNTER_CFG_OFFSET); + } else { + ipa_qtime_config(ipa); + } /* IPA v4.2 does not support hashed tables, so disable them */ if (version == IPA_VERSION_4_2) { diff --git a/drivers/net/ipa/ipa_reg.h b/drivers/net/ipa/ipa_reg.h index 09dcfa2998f04..e6b0827a244ec 100644 --- a/drivers/net/ipa/ipa_reg.h +++ b/drivers/net/ipa/ipa_reg.h @@ -223,6 +223,7 @@ static inline u32 ipa_reg_bcr_val(enum ipa_version version) /* ipa->available defines the valid bits in the AGGR_FORCE_CLOSE register */ #define IPA_REG_AGGR_FORCE_CLOSE_OFFSET 0x000001ec +/* The next register is not present for IPA v4.5 */ #define IPA_REG_COUNTER_CFG_OFFSET 0x000001f0 #define AGGR_GRANULARITY_FMASK GENMASK(8, 4) @@ -274,6 +275,35 @@ static inline u32 ipa_reg_idle_indication_cfg_offset(enum ipa_version version) #define ENTER_IDLE_DEBOUNCE_THRESH_FMASK GENMASK(15, 0) #define CONST_NON_IDLE_ENABLE_FMASK GENMASK(16, 16) +/* The next register is present for IPA v4.5 */ +#define IPA_REG_QTIME_TIMESTAMP_CFG_OFFSET 0x0000024c +#define DPL_TIMESTAMP_LSB_FMASK GENMASK(4, 0) +#define DPL_TIMESTAMP_SEL_FMASK GENMASK(7, 7) +#define TAG_TIMESTAMP_LSB_FMASK GENMASK(12, 8) +#define NAT_TIMESTAMP_LSB_FMASK GENMASK(20, 16) + +/* The next register is present for IPA v4.5 */ +#define IPA_REG_TIMERS_XO_CLK_DIV_CFG_OFFSET 0x00000250 +#define DIV_VALUE_FMASK GENMASK(8, 0) +#define DIV_ENABLE_FMASK GENMASK(31, 31) + +/* The next register is present for IPA v4.5 */ +#define IPA_REG_TIMERS_PULSE_GRAN_CFG_OFFSET 0x00000254 +#define GRAN_0_FMASK GENMASK(2, 0) +#define GRAN_1_FMASK GENMASK(5, 3) +#define GRAN_2_FMASK GENMASK(8, 6) +/* Values for GRAN_x fields of TIMERS_PULSE_GRAN_CFG */ +enum ipa_pulse_gran { + IPA_GRAN_10_US = 0x0, + IPA_GRAN_20_US = 0x1, + IPA_GRAN_50_US = 0x2, + IPA_GRAN_100_US = 0x3, + IPA_GRAN_1_MS = 0x4, + IPA_GRAN_10_MS = 0x5, + IPA_GRAN_100_MS = 0x6, + IPA_GRAN_655350_US = 0x7, +}; + /* # IPA source resource groups available based on version */ static inline u32 ipa_resource_group_src_count(enum ipa_version version) { From patchwork Mon Nov 30 23:37:11 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alex Elder X-Patchwork-Id: 334728 Delivered-To: patch@linaro.org Received: by 2002:a92:5e16:0:0:0:0:0 with SMTP id s22csp5161097ilb; Mon, 30 Nov 2020 15:40:10 -0800 (PST) X-Google-Smtp-Source: ABdhPJxTJC4XRMmv+zxQYXSFd9qiyhQNzxR3/NNoRuPkUZNcJRVTO6Zk48knrV55WyoDuvLwlqq9 X-Received: by 2002:a17:906:b003:: with SMTP id v3mr258566ejy.290.1606779610127; Mon, 30 Nov 2020 15:40:10 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1606779610; cv=none; d=google.com; s=arc-20160816; b=wKgf/XioaaLM+KJ1QKkwYt0g2PXbs2NJx1DaKIrHglPxW1FgInQklOBQBA8QrKwj6I k8kVoldZYAF2Qw6Y7yUqbyQe5EJortxE6uKplhvCGeTlTVbdevzvVT9bUZfamLYox432 1e7e90SLHDMX5GzFfiKh5xZZgmCFrCuOmpPs9LqU0CzfXMPkRJyQyqME3njoS4XeBW51 noCaM8YtkdjfWGUF47qUn1IDjArv8pePm2cNGqCqAGh57l6bAUFYo4XueVvVrId3Nn8R mhNXjQ29GpV2HsaTqGxlaCK45xk5l62PlZJWAVsl0nMDnvqhsN0yuB2popyF41euRH2f Y3KQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=bsjXW+SLSKSrfHn1CqagqnbZw4XU3N/TAztNinypVjg=; b=ACE9ql+ykKIanFzl6GT4NQi+JhUVhrxDa54qubih20Ku3nHcGhFw89XwgTKryXSzZA tTyGdkVIy2306BOiHywZzjNDjsKSuu50fFTH1VvpokYzzNjBtRd6iiRl5MP9zeBsIrjy EfEvSI4yc7sRJRwhTTJMoizPJLbZ2tbQM4bTBKF0BgWZTwS5Yv5OXCJh++YFMioLEXR7 KNOn5JgyFo10eRl2Yi8wqdRcA1H15U2WCjJOUf36zQrJTpqmvbP+yIS5+dnsg5UJtJ8R Gm6JXMn/Cz9EvqVTr3fesvHTzPcjFkBcf8RIyhGskTMhU1v7pFO5FQbiXEIDGufNfyAb 7TEA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=hYy+DZEJ; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id d10si11612458ejh.20.2020.11.30.15.40.09; Mon, 30 Nov 2020 15:40:10 -0800 (PST) Received-SPF: pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=hYy+DZEJ; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388510AbgK3Xii (ORCPT + 8 others); Mon, 30 Nov 2020 18:38:38 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48588 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388895AbgK3Xih (ORCPT ); Mon, 30 Nov 2020 18:38:37 -0500 Received: from mail-io1-xd43.google.com (mail-io1-xd43.google.com [IPv6:2607:f8b0:4864:20::d43]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6A037C0617A7 for ; Mon, 30 Nov 2020 15:37:20 -0800 (PST) Received: by mail-io1-xd43.google.com with SMTP id r9so13688213ioo.7 for ; Mon, 30 Nov 2020 15:37:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=bsjXW+SLSKSrfHn1CqagqnbZw4XU3N/TAztNinypVjg=; b=hYy+DZEJyJzOHZoxoK+DNUyda5xJ2kazBTI9CY1dIXh22kg/6PL+5p6rgvtLDQ9MsL Gz8IvMelRpuZ1SLEAnDKNo9Qc/OLcI4xJXwM87F32ab6dZBM+nzUKa2TXAvvn+Aj2eBi US0xYm+99L2LlrZ8MSgsm28ryb9iD2p5tVz9JodIcXYWP2ZdnUOg1NOh5oGrgtqt+jKs 2IeUmR/F1tt+sby5YfTj8wLF2J3g5uvsP8WV3uPRnn8nlXI4q4dv+i3t6dB2A1DCbm8q pCV9dJfrnLZXB4Pw97Irq1EKCuKwy2NqFSXL0Z4N4Iwkf67hHrikOyapKPaV2lux/o02 bqwA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=bsjXW+SLSKSrfHn1CqagqnbZw4XU3N/TAztNinypVjg=; b=RVYoh2hiv7MuedJHM1pU4RC76mEWDpe6dpFRZh6UdwbkVFPcqdO1hJDbsFPmUS8Dh/ jLI6Nddqc3Yi6dUGibAHG2YHcgHB0dQrCJ5vVAEOK9KSTOdKw0QRlj7m6+EmBlN7BTkw 0dkrzMYB0uvK+iaX3I+mMtc62VBAVIYEjJRMxbTE/LDE04IABWBn7HGBtEQStmDXbcF8 vZ0tSdkeZi2R5W++XiM+uWp3hnNghf/I4iexvUoA5Cs028uVRUQzbVzwFVhUAs7Xyoo1 e4IMWtAIMElzaQbb+jEDJ0q1IUhsrtiKepxPPbAjpZ6LvUWICHS6CbznqcinC+VuEJ27 G65Q== X-Gm-Message-State: AOAM530umiC365tZIVi4uUHq/7yDGtWxfp+hKJ9GHZ3NhL3h9PyP9KAo +hoU8W2SJbDQv9Y8tqDMeCMFrg== X-Received: by 2002:a05:6602:2ac4:: with SMTP id m4mr156903iov.97.1606779439805; Mon, 30 Nov 2020 15:37:19 -0800 (PST) Received: from beast.localdomain (c-73-185-129-58.hsd1.mn.comcast.net. [73.185.129.58]) by smtp.gmail.com with ESMTPSA id o195sm62574ila.38.2020.11.30.15.37.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 30 Nov 2020 15:37:19 -0800 (PST) From: Alex Elder To: davem@davemloft.net, kuba@kernel.org Cc: evgreen@chromium.org, subashab@codeaurora.org, cpratapa@codeaurora.org, bjorn.andersson@linaro.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH net-next 3/4] net: ipa: use Qtime for IPA v4.5 aggregation time limit Date: Mon, 30 Nov 2020 17:37:11 -0600 Message-Id: <20201130233712.29113-4-elder@linaro.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20201130233712.29113-1-elder@linaro.org> References: <20201130233712.29113-1-elder@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Change aggr_time_limit_encoded() to properly calculate the aggregation time limit to use for IPA v4.5. Older IPA versions program the AGGR_GRANULARITY field of the of the COUNTER_CFG register to set the granularity of the aggregation timer, which we configure to be 500 microseconds. Instead, IPA v4.5 selects between two possible granularity values derived from the 19.2 MHz Qtime clock. These granularities are 100 microseconds or 1 millisecond per tick. We use the smaller granularity if possible, unless the desired period is too large to be specified that way. Signed-off-by: Alex Elder --- drivers/net/ipa/ipa_endpoint.c | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) -- 2.20.1 diff --git a/drivers/net/ipa/ipa_endpoint.c b/drivers/net/ipa/ipa_endpoint.c index f260c80f50649..b4c884ccb77d2 100644 --- a/drivers/net/ipa/ipa_endpoint.c +++ b/drivers/net/ipa/ipa_endpoint.c @@ -638,14 +638,38 @@ static u32 aggr_byte_limit_encoded(enum ipa_version version, u32 limit) return u32_encode_bits(limit, aggr_byte_limit_fmask(false)); } +/* Encode the aggregation timer limit (microseconds) based on IPA version */ static u32 aggr_time_limit_encoded(enum ipa_version version, u32 limit) { - /* Convert limit (microseconds) to aggregation timer ticks */ - limit = DIV_ROUND_CLOSEST(limit, IPA_AGGR_GRANULARITY); - if (version < IPA_VERSION_4_5) + u32 gran_sel; + u32 fmask; + u32 val; + + if (version < IPA_VERSION_4_5) { + /* We set aggregation granularity in ipa_hardware_config() */ + limit = DIV_ROUND_CLOSEST(limit, IPA_AGGR_GRANULARITY); + return u32_encode_bits(limit, aggr_time_limit_fmask(true)); + } - return u32_encode_bits(limit, aggr_time_limit_fmask(false)); + /* IPA v4.5 expresses the time limit using Qtime. The AP has + * pulse generators 0 and 1 available, which were configured + * in ipa_qtime_config() to have granularity 100 usec and + * 1 msec, respectively. Use pulse generator 0 if possible, + * otherwise fall back to pulse generator 1. + */ + fmask = aggr_time_limit_fmask(false); + val = DIV_ROUND_CLOSEST(limit, 100); + if (val > field_max(fmask)) { + /* Have to use pulse generator 1 (millisecond granularity) */ + gran_sel = AGGR_GRAN_SEL_FMASK; + val = DIV_ROUND_CLOSEST(limit, 1000); + } else { + /* We can use pulse generator 0 (100 usec granularity) */ + gran_sel = 0; + } + + return gran_sel | u32_encode_bits(val, fmask); } static u32 aggr_sw_eof_active_encoded(enum ipa_version version, bool enabled) From patchwork Mon Nov 30 23:37:12 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alex Elder X-Patchwork-Id: 334729 Delivered-To: patch@linaro.org Received: by 2002:a92:5e16:0:0:0:0:0 with SMTP id s22csp5161088ilb; Mon, 30 Nov 2020 15:40:09 -0800 (PST) X-Google-Smtp-Source: ABdhPJxpIlQmEXUUDqVkooKGHgM8njKhsk8WxHywR5uD6YwgQ0L/nspSI+J4nbVG9/ZqW6fKIlsM X-Received: by 2002:a17:906:a982:: with SMTP id jr2mr263170ejb.292.1606779609714; Mon, 30 Nov 2020 15:40:09 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1606779609; cv=none; d=google.com; s=arc-20160816; b=lKqsPmIohdlc3AFQgyK9ZqVWXRNGlT+QUHVmQEI4VvmHZkcaRVEJtw3c2CGLDayE+U PHDtG3IDEObsdcXfwJ9l9vLCFctegt4O30xxZDjtXehDO+O1svWptWoK720q2h9C6wue 4ZewWauGByNlLR/ZHCEX1xKzewrDH9UqEt20XuKGxigzq7mVpWCIf9nt4AtLlL7w/y4W JghP4CveFEZB+NBeM+4qwBAkq66CZ6E9muM2+TVcvGIW9KMbcbSYmMnHkZUfGsato7B3 y4G2uilRCPFSOdKcFP63HtXsniIvsstZGw6C7kroIFqQ6PRY4kbF3J1TyoeTu3x+YMiB pLwg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=owLQOsjd54lIVwCHCW8NL5nsggMxStD0VTTtJ4eXi54=; b=vLTvwgjo0fv9b2xh8m7I8KY48KKzGTUHpuxXBm/fg6yU12p+52dTE5Ylaie3La/Qxn C9/ULTAS5DWeievh4qfnHHAIPsj7Mw2bace6KLwC5zGtvCRvzMa+oP/y0MNrJH89WVxg iIkJvgHT9hBzZjZPzY8R0sRo/1WUlKzLaFTtyUyga9NiCUHxM5R2dUaJ9TP++lbjcOhW Y8yNXy4C4CN9vdAn6ZRs/RT/4QoCld0aob5tgRE54suN2+Cw3wUVtQdCX85uvSUELBXK f5gAIBupGVoG62xPw7gViV7P/Yv6pD5b7ShYSF2LHKDYmImiuRTLRlFVxTSQFrJ7HUTx 1Nrg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=v2RG9eLL; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id d10si11612458ejh.20.2020.11.30.15.40.09; Mon, 30 Nov 2020 15:40:09 -0800 (PST) Received-SPF: pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=v2RG9eLL; spf=pass (google.com: domain of netdev-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=netdev-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2389091AbgK3Xij (ORCPT + 8 others); Mon, 30 Nov 2020 18:38:39 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48598 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388929AbgK3Xij (ORCPT ); Mon, 30 Nov 2020 18:38:39 -0500 Received: from mail-il1-x141.google.com (mail-il1-x141.google.com [IPv6:2607:f8b0:4864:20::141]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6B0E2C061A48 for ; Mon, 30 Nov 2020 15:37:21 -0800 (PST) Received: by mail-il1-x141.google.com with SMTP id z10so4644771ilu.3 for ; Mon, 30 Nov 2020 15:37:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=owLQOsjd54lIVwCHCW8NL5nsggMxStD0VTTtJ4eXi54=; b=v2RG9eLLlUHmR3Qf00pGT9aBCtottVrk1hTmHKTcFObglnWHgqSUI4GVC1822x7y2O C3MngA0lHHlhqCnLWf/nzCTx81G/tXrlra5Jx5V91FEiIMOEAyA+1n9I7Caoch3fGYmM pHM2A4HCBwXWdd26vjGJhxR1kKGkWJU1RFYjQfSEZZ+DYD2UfcSp05Uwo5fCKy4a5VLk jSfK/A8sjZBeGJB3/KkDtKld2xS7+UMQ4wti8OLnM+h612hLrFCA0Tm8WrPgpCjlGQx1 qGkMg+JG17Em3HHD6OtruejQkSpookPg/1fcsSDgX5SfaajjRYyJXuPDJXBptC3f6cD4 EVXA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=owLQOsjd54lIVwCHCW8NL5nsggMxStD0VTTtJ4eXi54=; b=la0k9c0IBsjX4mEgNc+rHnwenqJazAG5gjuQAhi/3JVN+tAYdkS73Aqzho8zfBUh76 Qs3J3dczYgvCbT7a21avcccnXcNax8Z4RUvCuGc8pOPbtWa10ci+O8ceaXFEH6vtAN8G QdGplz2eTu39ERQcJ0QmyjuhRLFTnA6qIA7a2B98XzGnrFyQ5ksbnDDwdnRNQW+xEI9J oVGzw5GdZYV/QlBaPuuSFeMlDCz0OV1GALY4+1s2dDVjaBDa8Ok0PKT/1YtMQmzC3Z/f p9kgStjAU/VOHugyv++wyHEpFbanhzqqOYP0OGWlSwMMfxTQDZDTCSmvV0pSZZ8/X18o sWAw== X-Gm-Message-State: AOAM530qA8idnP063y6j+nobFRHMzSm1CarYFuCJ3MBjUVyxKDGd7ugR pSIp3WP0+mLz5ODYpltv04Bqng== X-Received: by 2002:a92:c08d:: with SMTP id h13mr142160ile.118.1606779440851; Mon, 30 Nov 2020 15:37:20 -0800 (PST) Received: from beast.localdomain (c-73-185-129-58.hsd1.mn.comcast.net. [73.185.129.58]) by smtp.gmail.com with ESMTPSA id o195sm62574ila.38.2020.11.30.15.37.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 30 Nov 2020 15:37:20 -0800 (PST) From: Alex Elder To: davem@davemloft.net, kuba@kernel.org Cc: evgreen@chromium.org, subashab@codeaurora.org, cpratapa@codeaurora.org, bjorn.andersson@linaro.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH net-next 4/4] net: ipa: use Qtime for IPA v4.5 head-of-line time limit Date: Mon, 30 Nov 2020 17:37:12 -0600 Message-Id: <20201130233712.29113-5-elder@linaro.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20201130233712.29113-1-elder@linaro.org> References: <20201130233712.29113-1-elder@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Extend ipa_reg_init_hol_block_timer_val() so it properly calculates the head-of-line block timeout to use for IPA v4.5. Introduce hol_block_timer_qtime_val() to compute the value to use for IPA v4.5, where Qtime is used as the basis of the timer. Call that function from hol_block_timer_val() for IPA v4.5. Both of these are private functions, so shorten their names a bit so they don't take up so much space on the line. Signed-off-by: Alex Elder --- drivers/net/ipa/ipa_endpoint.c | 48 +++++++++++++++++++++++++++++----- 1 file changed, 42 insertions(+), 6 deletions(-) -- 2.20.1 diff --git a/drivers/net/ipa/ipa_endpoint.c b/drivers/net/ipa/ipa_endpoint.c index b4c884ccb77d2..9f4be9812a1f3 100644 --- a/drivers/net/ipa/ipa_endpoint.c +++ b/drivers/net/ipa/ipa_endpoint.c @@ -724,12 +724,45 @@ static void ipa_endpoint_init_aggr(struct ipa_endpoint *endpoint) iowrite32(val, endpoint->ipa->reg_virt + offset); } -/* The head-of-line blocking timer is defined as a tick count, where each - * tick represents 128 cycles of the IPA core clock. Return the value - * that should be written to that register that represents the timeout - * period provided. +/* Return the Qtime-based head-of-line blocking timer value that + * represents the given number of microseconds. The result + * includes both the timer value and the selected timer granularity. */ -static u32 ipa_reg_init_hol_block_timer_val(struct ipa *ipa, u32 microseconds) +static u32 hol_block_timer_qtime_val(struct ipa *ipa, u32 microseconds) +{ + u32 gran_sel; + u32 val; + + /* IPA v4.5 expresses time limits using Qtime. The AP has + * pulse generators 0 and 1 available, which were configured + * in ipa_qtime_config() to have granularity 100 usec and + * 1 msec, respectively. Use pulse generator 0 if possible, + * otherwise fall back to pulse generator 1. + */ + val = DIV_ROUND_CLOSEST(microseconds, 100); + if (val > field_max(TIME_LIMIT_FMASK)) { + /* Have to use pulse generator 1 (millisecond granularity) */ + gran_sel = GRAN_SEL_FMASK; + val = DIV_ROUND_CLOSEST(microseconds, 1000); + } else { + /* We can use pulse generator 0 (100 usec granularity) */ + gran_sel = 0; + } + + return gran_sel | u32_encode_bits(val, TIME_LIMIT_FMASK); +} + +/* The head-of-line blocking timer is defined as a tick count. For + * IPA version 4.5 the tick count is based on the Qtimer, which is + * derived from the 19.2 MHz SoC XO clock. For older IPA versions + * each tick represents 128 cycles of the IPA core clock. + * + * Return the encoded value that should be written to that register + * that represents the timeout period provided. For IPA v4.2 this + * encodes a base and scale value, while for earlier versions the + * value is a simple tick count. + */ +static u32 hol_block_timer_val(struct ipa *ipa, u32 microseconds) { u32 width; u32 scale; @@ -741,6 +774,9 @@ static u32 ipa_reg_init_hol_block_timer_val(struct ipa *ipa, u32 microseconds) if (!microseconds) return 0; /* Nothing to compute if timer period is 0 */ + if (ipa->version == IPA_VERSION_4_5) + return hol_block_timer_qtime_val(ipa, microseconds); + /* Use 64 bit arithmetic to avoid overflow... */ rate = ipa_clock_rate(ipa); ticks = DIV_ROUND_CLOSEST(microseconds * rate, 128 * USEC_PER_SEC); @@ -786,7 +822,7 @@ static void ipa_endpoint_init_hol_block_timer(struct ipa_endpoint *endpoint, u32 val; offset = IPA_REG_ENDP_INIT_HOL_BLOCK_TIMER_N_OFFSET(endpoint_id); - val = ipa_reg_init_hol_block_timer_val(ipa, microseconds); + val = hol_block_timer_val(ipa, microseconds); iowrite32(val, ipa->reg_virt + offset); }