From patchwork Mon Jun 13 08:54:43 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "(Exiting) Baolin Wang" X-Patchwork-Id: 9172383 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id E78FC60573 for ; Mon, 13 Jun 2016 08:55:53 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id DAED920223 for ; Mon, 13 Jun 2016 08:55:53 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id CFB7C27AC2; Mon, 13 Jun 2016 08:55:53 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_HI,T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 6DBD720223 for ; Mon, 13 Jun 2016 08:55:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1422646AbcFMIzj (ORCPT ); Mon, 13 Jun 2016 04:55:39 -0400 Received: from mail-pf0-f170.google.com ([209.85.192.170]:34414 "EHLO mail-pf0-f170.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1161200AbcFMIzh (ORCPT ); Mon, 13 Jun 2016 04:55:37 -0400 Received: by mail-pf0-f170.google.com with SMTP id 62so44306824pfd.1 for ; Mon, 13 Jun 2016 01:55:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id; bh=S5cTdLeDL6qJXjS8awjcSMQ7+2hWZbuINBj2hFh0vpw=; b=JXCtHrqcCYYds0yDmZQQkf4jx2HX5Je5aO9KCIIkrusxOJULXnsrOd2Hxa0d6Gtkqa JQGyi5bavLam8Y1ybL172BOfWrThOlbcXLPqN/WWkZaaKGbzNBJkHeejvqYeds7RMjuI 5PpiqVDU6/coJGHf0Lfm+hUiEKLafGVtrzwwM= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id; bh=S5cTdLeDL6qJXjS8awjcSMQ7+2hWZbuINBj2hFh0vpw=; b=L2esS40+p/0NZDWpadXiqpywkbvPHv5i/wTHRgWcdh+YL5o+MZj2kZKJaSw7iqkTKp lE/HHsScmx8WldKISbXTNHOjJYuv0TGVWmB0lMcTzC1AFJDqPg8VyQHxudamUBFzyi9P FVm0CrBen21uRS6oxhonkWO7F9CVFBS2IXlZ9t/PtMJrzML1F6DJBVVnida1UKGnVCVL MrjVR3iXH9oALj5KrF9XsAICHtlZHEnqSxvMeVbcgBI+5eW1TKC/TvVxn6Tb+9HEQ7CX POYXMcIVYTKsVWm5lu+4EyUaqOXtHYZMWBIOa/60oVxO9dSzJgzxQ07QRUWsZssO0+Xe pDkg== X-Gm-Message-State: ALyK8tKLn4e6OC6ojAn7iSPmHDBLAmOubW7+sSN5BS8P2ewCtZ+toh2jnmSSk3tORmZi/HXP X-Received: by 10.98.32.15 with SMTP id g15mr20311997pfg.67.1465808136445; Mon, 13 Jun 2016 01:55:36 -0700 (PDT) Received: from baolinwangubtpc.spreadtrum.com ([175.111.195.49]) by smtp.gmail.com with ESMTPSA id y10sm17449746pas.24.2016.06.13.01.55.33 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 13 Jun 2016 01:55:36 -0700 (PDT) From: Baolin Wang To: ulf.hansson@linaro.org Cc: adrian.hunter@intel.com, rmk+kernel@arm.linux.org.uk, shawn.lin@rock-chips.com, dianders@chromium.org, heiko@sntech.de, linux-mmc@vger.kernel.org, linux-kernel@vger.kernel.org, broonie@kernel.org, linus.walleij@linaro.org, baolin.wang@linaro.org Subject: [RESEND RFC v2] mmc: Change the max discard sectors and erase response if mmc host supports busy signalling Date: Mon, 13 Jun 2016 16:54:43 +0800 Message-Id: <54f75bccac6e6e49d87a5122ea670038b508b33c.1465808036.git.baolin.wang@linaro.org> X-Mailer: git-send-email 1.7.9.5 Sender: linux-mmc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-mmc@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP When mmc host HW supports busy signalling (using R1B as response), We shouldn't use 'host->max_busy_timeout' as the limitation when deciding the max discard sectors that we tell the generic BLOCK layer about. Instead, we should pick one preferred erase size as the max discard sectors. If the host controller supports busy signalling and the timeout for the erase operation does not exceed the max_busy_timeout, we should use R1B response. Or we need to prevent the host from doing hw busy detection, which is done by converting to a R1 response instead. Changes since v1: - Remove the 'MMC_CAP_WAIT_WHILE_BUSY' flag checking when deciding the max discard sectors. Signed-off-by: Baolin Wang --- drivers/mmc/core/core.c | 47 +++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 39 insertions(+), 8 deletions(-) diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c index 8b4dfd4..edd43b1 100644 --- a/drivers/mmc/core/core.c +++ b/drivers/mmc/core/core.c @@ -2060,7 +2060,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from, unsigned int to, unsigned int arg) { struct mmc_command cmd = {0}; - unsigned int qty = 0; + unsigned int qty = 0, busy_timeout = 0; unsigned long timeout; int err; @@ -2128,8 +2128,23 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from, memset(&cmd, 0, sizeof(struct mmc_command)); cmd.opcode = MMC_ERASE; cmd.arg = arg; - cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; - cmd.busy_timeout = mmc_erase_timeout(card, arg, qty); + busy_timeout = mmc_erase_timeout(card, arg, qty); + /* + * If the host controller supports busy signalling and the timeout for + * the erase operation does not exceed the max_busy_timeout, we should + * use R1B response. Or we need to prevent the host from doing hw busy + * detection, which is done by converting to a R1 response instead. + */ + if ((card->host->max_busy_timeout && + busy_timeout > card->host->max_busy_timeout) || + !(card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)) { + cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; + cmd.busy_timeout = 0; + } else { + cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; + cmd.busy_timeout = busy_timeout; + } + err = mmc_wait_for_cmd(card->host, &cmd, 0); if (err) { pr_err("mmc_erase: erase error %d, status %#x\n", @@ -2321,23 +2336,39 @@ static unsigned int mmc_do_calc_max_discard(struct mmc_card *card, unsigned int arg) { struct mmc_host *host = card->host; - unsigned int max_discard, x, y, qty = 0, max_qty, timeout; + unsigned int max_discard, x, y, qty = 0, max_qty, min_qty, timeout; unsigned int last_timeout = 0; - if (card->erase_shift) + if (card->erase_shift) { max_qty = UINT_MAX >> card->erase_shift; - else if (mmc_card_sd(card)) + min_qty = card->pref_erase >> card->erase_shift; + } else if (mmc_card_sd(card)) { max_qty = UINT_MAX; - else + min_qty = card->pref_erase; + } else { max_qty = UINT_MAX / card->erase_size; + min_qty = card->pref_erase / card->erase_size; + } /* Find the largest qty with an OK timeout */ do { y = 0; for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) { timeout = mmc_erase_timeout(card, arg, qty + x); - if (timeout > host->max_busy_timeout) + /* + * We should not only use 'host->max_busy_timeout' as + * the limitation when deciding the max discard sectors. + * We should set a balance value to improve the erase + * speed, and it can not get too long timeout at the + * same time. + * + * Here we set 'card->pref_erase' as the minimal discard + * sectors when deciding the max discard sectors. + */ + if (qty + x > min_qty && + timeout > host->max_busy_timeout) break; + if (timeout < last_timeout) break; last_timeout = timeout;