From patchwork Mon May 23 06:49:28 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: 9131195 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 527DC60761 for ; Mon, 23 May 2016 06:55:28 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 48D3A281F6 for ; Mon, 23 May 2016 06:55:28 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 3C279281FF; Mon, 23 May 2016 06:55:28 +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 C0A0E281F6 for ; Mon, 23 May 2016 06:55:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752948AbcEWGz1 (ORCPT ); Mon, 23 May 2016 02:55:27 -0400 Received: from mail-pf0-f182.google.com ([209.85.192.182]:33253 "EHLO mail-pf0-f182.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752936AbcEWGz0 (ORCPT ); Mon, 23 May 2016 02:55:26 -0400 Received: by mail-pf0-f182.google.com with SMTP id b124so4761585pfb.0 for ; Sun, 22 May 2016 23:55:26 -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=KyXdWwC6eARd4gIJnmQsznsBmN2TzRNqkVX3Hh5mhvE=; b=jowC7fyFSgt7qfuGGaFbxhPzo1KmtA0nQ2KfhvNn7ICcgLbcc0pWVWLlbXLANqn38e x16Slcqswg4HzYvq+D+tR6bKUhP/f1dQBeo+opU5zhm8/vtYI52ycMfOxyehH0ardjKr 9C/Adggnm7Wejd/Z5kODpFdZVJzp4XaN/a1xc= 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=KyXdWwC6eARd4gIJnmQsznsBmN2TzRNqkVX3Hh5mhvE=; b=ObpHtHuT9q/PzuVmVzwaY3zDfy+W5EFnXVYn2k1YoeaBtCgqyptme5VWGpaT6ldRK4 zBgxnej8HZoa2/zmORty4EPHFIc2Y8LtyWj1Gge4HfQEFBwcVRP7UEiBkW4rrpjtMedY 3CnwvUr32PPiVc4QMRI/t/972mLf6Rd8urpmwyqpSVEgrM2rJOWZ8w0f1S9XK3Fsq8GY mRU6s2iNVzNG7pzybXrxT2QLCxuuLyHFMvg1Dg3gXeLtEo2VF3pO5khB+j0I+cqQyG7F AzqqU05X9WT16prFKWhmCLDtHnPFOeQM5LOl3IyeUurausllKpTPy9BLj3N/M6117imF vUdQ== X-Gm-Message-State: ALyK8tLWQru2U1+uhbRLJ1ffat27cFbrLvDuk3cXPEqovLuO7J7+7SgoPgcwXJfJP0NCOMk/ X-Received: by 10.98.35.93 with SMTP id j90mr6899367pfj.10.1463986190929; Sun, 22 May 2016 23:49:50 -0700 (PDT) Received: from baolinwangubtpc.spreadtrum.com ([175.111.195.49]) by smtp.gmail.com with ESMTPSA id 141sm6568378pfx.68.2016.05.22.23.49.46 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 22 May 2016 23:49:50 -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, 23 May 2016 14:49:28 +0800 Message-Id: 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 99275e4..0df40fa 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;