[RFC/PATCH] mmc: core: Add support for idle time BKOPs

[RFC/PATCH] mmc: core: Add support for idle time BKOPs

[Maya Erez]

When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPs. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPs is required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPs completion and prevent
suspend that will interrupt the BKOPs.
If the card raised an exception, the need for urgent BKOPs (level 2/3)
will be checked immediately and if needed, the BKOPs will be performed
without waiting for the next idle time.

Signed-off-by: Maya Erez <merez@codeaurora.org>
Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
---
This patch depends on the following patch:
  [PATCH v11] mmc: support BKOPS feature for eMMC

This patch is based on the periodic BKOPs implementation in version 8 of "support BKOPS feature for eMMC" patch.
The patch was modified to answer the following issues:
- In order to prevent a race condition between going into suspend and starting BKOPs, 
  the suspend timeout of the host controller is taking into accound in determination of the start time 
  of the delayed work
- Since mmc_start_bkops is called from two contexts now, mmc_claim_host was moved to the beginning of the function
- Also, the check of doing_bkops should be protected when determing if an HPI is needed due to the same reason.
- Starting and canceling the delayed work in each idle caused degradation of iozone performance. Therefore,
  the delayed work is not started on each idle. Currently the number of issued requests from the last delayed work 
  is the trigger. We still investigate the best trigger for starting the delayed work.
- To prevent degaradtion of iozone performance we also moved the call to mmc_claim_host outside of mmc_stop_bkops  
  and its release is done after issue_fn. This prevents an addition of a full claim and release, that is also done 
  in issue_fn for the first request after idle time.
---
 drivers/mmc/card/block.c |    3 +
 drivers/mmc/card/queue.c |   20 +++++
 drivers/mmc/core/core.c  |  188 +++++++++++++++++++++++++++++++++++++++++++---
 drivers/mmc/core/host.c  |   24 ++++++
 include/linux/mmc/card.h |    3 +
 include/linux/mmc/core.h |    3 +
 include/linux/mmc/host.h |   25 ++++++
 7 files changed, 256 insertions(+), 10 deletions(-)

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index f1c84de..4519271 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -1268,6 +1268,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
 	if (!rqc && !mq->mqrq_prev->req)
 		return 0;
 
+	if (rqc)
+		card->idle_bkops_rw_reqs_nr++;
+
 	do {
 		if (rqc) {
 			/*
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index e360a97..c9e1cee 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
 {
 	struct mmc_queue *mq = d;
 	struct request_queue *q = mq->queue;
+	bool release_host = false;
 
 	current->flags |= PF_MEMALLOC;
 
@@ -66,13 +67,32 @@ static int mmc_queue_thread(void *d)
 		spin_unlock_irq(q->queue_lock);
 
 		if (req || mq->mqrq_prev->req) {
+			/*
+			 * If this is the first request, BKOPs might be in
+			 * progress and needs to be stopped before issuing the
+			 * request
+			 * */
+			if (!mq->mqrq_prev->req &&
+			    mq->card->ext_csd.bkops_en &&
+			    mq->card->idle_bkops_rw_reqs_nr == 0) {
+				release_host = true;
+				mmc_claim_host(mq->card->host);
+				mmc_stop_bkops(mq->card);
+			}
+
 			set_current_state(TASK_RUNNING);
 			mq->issue_fn(mq, req);
+			if (release_host) {
+				release_host = false;
+				mmc_release_host(mq->card->host);
+			}
 		} else {
 			if (kthread_should_stop()) {
 				set_current_state(TASK_RUNNING);
 				break;
 			}
+
+			mmc_start_delayed_bkops(mq->card);
 			up(&mq->thread_sem);
 			schedule();
 			down(&mq->thread_sem);
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index ed2cc93..14830d4 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -46,6 +46,15 @@
  * operations the card has to peform
  */
 #define MMC_BKOPS_MAX_TIMEOUT	(4 * 60 * 1000) /* max time to wait in ms */
+/* Polling timeout and interval for waiting on non-blocking BKOPs completion */
+#define BKOPS_COMPLETION_POLLING_TIMEOUT 10000 /* in ms */
+#define BKOPS_COMPLETION_POLLING_INTERVAL 1000 /* in ms */
+/*
+ * Since canceling the delayed work might have significant effect on the
+ * performance of small requests we won't queue the delayed work every time
+ * mmcqd thread is idle
+ */
+#define BKOPS_MIN_REQS_TO_QUEUE_DELAYED_WORK 1000
 
 static struct workqueue_struct *workqueue;
 static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
@@ -252,6 +261,37 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 }
 
 /**
+ *      mmc_start_delayed_bkops() - Start a delayed work to check for the need
+ *      of non urgent BKOPs
+ *
+ *      @card: MMC card to start BKOPS
+ */
+void mmc_start_delayed_bkops(struct mmc_card *card)
+{
+	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+		return;
+
+	if (card->idle_bkops_rw_reqs_nr < BKOPS_MIN_REQS_TO_QUEUE_DELAYED_WORK)
+		return;
+
+	pr_debug("%s: %s: queueing delayed_bkops_work", __func__,
+		 mmc_hostname(card->host));
+
+	card->idle_bkops_rw_reqs_nr = 0;
+
+	/*
+	 * cancel_delayed_bkops_work will prevent a race condition between
+	 * fetching a request by the queue_thread and the delayed work
+	 */
+	card->host->bkops_info.cancel_delayed_work = false;
+	queue_delayed_work(card->host->bkops_info. wq,
+			   &card->host->bkops_info.idle_time_dw,
+		   msecs_to_jiffies(
+			   card->host->bkops_info.time_to_start_bkops_ms));
+}
+EXPORT_SYMBOL(mmc_start_delayed_bkops);
+
+/**
  *	mmc_start_bkops - start BKOPS for supported cards
  *	@card: MMC card to start BKOPS
  *	@form_exception: A flags to indicate if this function was
@@ -268,23 +308,47 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
 	bool use_busy_signal;
 
 	BUG_ON(!card);
-
-	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+	if (!card->ext_csd.bkops_en)
 		return;
 
+	mmc_claim_host(card->host);
+
+	if ((card->host->bkops_info.cancel_delayed_work) && !from_exception) {
+		pr_debug("%s: %s: cancel_delayed_work was set, exit",
+			 __func__, mmc_hostname(card->host));
+		card->host->bkops_info.cancel_delayed_work = false;
+		goto out;
+	}
+
+	if (mmc_card_doing_bkops(card)) {
+		pr_debug("%s: %s: already doing bkops, exit", __func__,
+			 mmc_hostname(card->host));
+		goto out;
+	}
+
 	err = mmc_read_bkops_status(card);
 	if (err) {
-		pr_err("%s: Didn't read bkops status : %d\n",
+		pr_err("%s: Error %d while reading bkops status\n",
 		       mmc_hostname(card->host), err);
-		return;
+		goto out;
 	}
-
 	if (!card->ext_csd.raw_bkops_status)
-		return;
+		goto out;
 
-	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2
-	    && (from_exception))
-		return;
+	pr_info("%s: %s: card->ext_csd.raw_bkops_status = %d", __func__,
+		mmc_hostname(card->host), card->ext_csd.raw_bkops_status);
+
+	/*
+	 * If the function was called due to exception but there is no need
+	 * for urgent BKOPs, BKOPs will be performed by the delayed BKOPs
+	 * work, before going to suspend
+	 */
+	if ((card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2)
+	    && (from_exception)) {
+		pr_debug("%s: %s: Level 1 from exception, exit", __func__,
+			 mmc_hostname(card->host));
+		goto out;
+	}
 
 	mmc_claim_host(card->host);
 	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
@@ -308,13 +372,101 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
 	 * bkops executed synchronously, otherwise
 	 * the operation is in progress
 	 */
-	if (!use_busy_signal)
+	if (!use_busy_signal) {
 		mmc_card_set_doing_bkops(card);
+		pr_debug("%s: %s: starting the polling thread", __func__,
+			 mmc_hostname(card->host));
+		card->host->bkops_info.exit_wait_on_completion = false;
+		queue_work(system_nrt_wq,
+			   &card->host->bkops_info.completion_polling);
+	}
 out:
 	mmc_release_host(card->host);
+
 }
 EXPORT_SYMBOL(mmc_start_bkops);
 
+/**
+ * mmc_bkops_completion_polling() - Poll on the card status to
+ * wait for the non-blocking BKOPs completion
+ * @work:	The completion polling work
+ *
+ * The on-going reading of the card status will prevent the card
+ * from getting into suspend while it is in the middle of
+ * performing BKOPs.
+ * Since the non blocking BKOPs can be interrupted by a fetched
+ * request we also check exit_wait_on_completion.
+ */
+void mmc_bkops_completion_polling(struct work_struct *work)
+{
+	struct mmc_host *host = container_of(work, struct mmc_host,
+			bkops_info.completion_polling);
+	unsigned long timeout_jiffies = jiffies +
+		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT);
+	u32 status;
+	int err;
+
+	/*
+	 * Wait for the BKOPs to complete. Keep reading the status to prevent
+	 * the host from getting into suspend
+	 */
+	do {
+		mmc_claim_host(host);
+
+		if (host->bkops_info.exit_wait_on_completion ||
+			(!mmc_card_doing_bkops(host->card))) {
+			goto out;
+		}
+
+		err = mmc_send_status(host->card, &status);
+		if (err) {
+			pr_err("%s: error %d requesting status\n",
+			       mmc_hostname(host), err);
+			goto out;
+		}
+
+		/*
+		 * Some cards mishandle the status bits, so make sure to check
+		 * both the busy indication and the card state.
+		 */
+		if ((status & R1_READY_FOR_DATA) &&
+		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
+			pr_debug("%s: completed BKOPs, exit polling", __func__);
+			mmc_card_clr_doing_bkops(host->card);
+			goto out;
+		}
+
+		mmc_release_host(host);
+
+		/*
+		 * Sleep before checking the card status again to allow the
+		 * card to complete the BKOPs operation
+		 */
+		msleep(BKOPS_COMPLETION_POLLING_INTERVAL);
+	} while (time_before(jiffies, timeout_jiffies));
+
+	pr_debug("%s: exit polling due to timeout", __func__);
+
+	return;
+out:
+	mmc_release_host(host);
+}
+
+/**
+ * mmc_start_idle_time_bkops() - check if a non urgent BKOPs is
+ * needed
+ * @work:	The idle time BKOPs work
+ */
+void mmc_start_idle_time_bkops(struct work_struct *work)
+{
+	struct mmc_host *host = container_of(work, struct mmc_host,
+			bkops_info.idle_time_dw.work);
+
+	mmc_start_bkops(host->card, false);
+
+}
+EXPORT_SYMBOL(mmc_start_idle_time_bkops);
+
 static void mmc_wait_done(struct mmc_request *mrq)
 {
 	complete(&mrq->completion);
@@ -574,12 +726,28 @@ EXPORT_SYMBOL(mmc_wait_for_cmd);
  *	to allow rapid servicing of foreground operations,e.g. read/
  *	writes. Wait until the card comes out of the programming state
  *	to avoid errors in servicing read/write requests.
+ *
+ *      This function should be called when the host is claimed
  */
 int mmc_stop_bkops(struct mmc_card *card)
 {
 	int err = 0;
 
 	BUG_ON(!card);
+
+	if (delayed_work_pending(&card->host->bkops_info.idle_time_dw))
+		cancel_delayed_work_sync(&card->host->bkops_info.idle_time_dw);
+
+	/*
+	 * Notify the delayed work to be cancelled, in case it was already
+	 * removed from the queue, but was not started yet
+	 */
+	card->host->bkops_info.cancel_delayed_work = true;
+
+	if (!mmc_card_doing_bkops(card))
+		return err;
+
+	card->host->bkops_info.exit_wait_on_completion = true;
 	err = mmc_interrupt_hpi(card);
 
 	/*
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 597f189..d328191 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -27,6 +27,11 @@
 #include "core.h"
 #include "host.h"
 
+/*
+ * A default time for checking the need for non urgent BKOPs once MMC thread
+ * is idle.
+ */
+#define MMC_IDLE_BKOPS_TIME_MS 2000
 #define cls_dev_to_mmc_host(d)	container_of(d, struct mmc_host, class_dev)
 
 static void mmc_host_classdev_release(struct device *dev)
@@ -336,6 +341,11 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
 	spin_lock_init(&host->lock);
 	init_waitqueue_head(&host->wq);
 	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
+	host->bkops_info. wq = create_singlethread_workqueue("bkops_wq");
+	INIT_DELAYED_WORK(&host->bkops_info.idle_time_dw,
+			  mmc_start_idle_time_bkops);
+	INIT_WORK(&host->bkops_info.completion_polling,
+		  mmc_bkops_completion_polling);
 #ifdef CONFIG_PM
 	host->pm_notify.notifier_call = mmc_pm_notify;
 #endif
@@ -386,6 +396,20 @@ int mmc_add_host(struct mmc_host *host)
 #endif
 	mmc_host_clk_sysfs_init(host);
 
+	/*
+	 * Calculate the time to start the BKOPs checking.
+	 * The idle time of the host controller should be taken into account
+	 * in order to prevent a race condition before starting BKOPs and
+	 * going into suspend.
+	 * If the host controller didn't set its idle time, a default value is
+	 * used.
+	 */
+	host->bkops_info.time_to_start_bkops_ms = MMC_IDLE_BKOPS_TIME_MS;
+	if (host->bkops_info.host_suspend_tout_ms)
+		host->bkops_info.time_to_start_bkops_ms = min(
+			host->bkops_info.time_to_start_bkops_ms,
+			host->bkops_info.host_suspend_tout_ms/2);
+
 	mmc_start_host(host);
 	register_pm_notifier(&host->pm_notify);
 
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 342fe84..835d6c8 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -280,6 +280,9 @@ struct mmc_card {
 	struct dentry		*debugfs_root;
 	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
 	unsigned int    nr_parts;
+
+	/* num of read/write reqs since last BKOPs delayed work was queued */
+	unsigned int idle_bkops_rw_reqs_nr;
 };
 
 /*
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 9b9cdaf..665d345 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
 extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
 	struct mmc_command *, int);
 extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
+extern void mmc_start_delayed_bkops(struct mmc_card *card);
+extern void mmc_start_idle_time_bkops(struct work_struct *work);
+extern void mmc_bkops_completion_polling(struct work_struct *work);
 extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
 extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
 
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index f578a71..8aaaf1d 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -176,6 +176,29 @@ struct mmc_supply {
 	struct regulator *vqmmc;	/* Optional Vccq supply */
 };
 
+/**
+ * struct mmc_bkops_info - BKOPs data
+ * @wq:			workqueue
+ * @idle_time_dw:	Idle time bkops delayed work
+ * @host_suspend_tout_ms:	The host controller idle time,
+ *         before getting into suspend
+ * @time_to_start_bkops_ms:	The time to start the BKOPs
+ *		  delayed work once MMC thread is idle
+ * @completion_polling:	Poll on BKOPs completion
+ * @cancel_delayed_work: A flag to indicate if the delayed work
+ *	       should be cancelled
+ * @exit_wait_on_completion:  Exit flag for non blocking BKOPs
+ */
+struct mmc_bkops_info {
+	struct workqueue_struct *wq;
+	struct delayed_work	idle_time_dw;
+	unsigned int		host_suspend_tout_ms;
+	unsigned int		time_to_start_bkops_ms;
+	struct work_struct	completion_polling;
+	bool			cancel_delayed_work;
+	bool			exit_wait_on_completion;
+};
+
 struct mmc_host {
 	struct device		*parent;
 	struct device		class_dev;
@@ -340,6 +363,8 @@ struct mmc_host {
 
 	unsigned int		actual_clock;	/* Actual HC clock rate */
 
+	struct mmc_bkops_info	bkops_info;
+
 	unsigned long		private[0] ____cacheline_aligned;
 };
 
-- 
1.7.3.3
-- 
Sent by a consultant of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.

Re: [RFC/PATCH] mmc: core: Add support for idle time BKOPs

[Jaehoon Chung]

On 08/05/2012 10:08 PM, Maya Erez wrote:
> When the mmcqd thread is idle, a delayed work is created to check the
> need for BKOPs. The time to start the delayed work is calculated based
> on the host controller suspend timeout, in case it was set. If not, a
> default time is used.
> If BKOPs is required in level 1, which is non-blocking, there will be
> polling of the card status to wait for the BKOPs completion and prevent
> suspend that will interrupt the BKOPs.
> If the card raised an exception, the need for urgent BKOPs (level 2/3)
> will be checked immediately and if needed, the BKOPs will be performed
> without waiting for the next idle time.
> 
> Signed-off-by: Maya Erez <merez@codeaurora.org>
> Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
> ---
> This patch depends on the following patch:
>   [PATCH v11] mmc: support BKOPS feature for eMMC
> 
> This patch is based on the periodic BKOPs implementation in version 8 of "support BKOPS feature for eMMC" patch.
> The patch was modified to answer the following issues:
> - In order to prevent a race condition between going into suspend and starting BKOPs, 
>   the suspend timeout of the host controller is taking into accound in determination of the start time 
>   of the delayed work
> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host was moved to the beginning of the function
> - Also, the check of doing_bkops should be protected when determing if an HPI is needed due to the same reason.
> - Starting and canceling the delayed work in each idle caused degradation of iozone performance. Therefore,
>   the delayed work is not started on each idle. Currently the number of issued requests from the last delayed work 
>   is the trigger. We still investigate the best trigger for starting the delayed work.
> - To prevent degaradtion of iozone performance we also moved the call to mmc_claim_host outside of mmc_stop_bkops  
>   and its release is done after issue_fn. This prevents an addition of a full claim and release, that is also done 
>   in issue_fn for the first request after idle time.
> ---
>  drivers/mmc/card/block.c |    3 +
>  drivers/mmc/card/queue.c |   20 +++++
>  drivers/mmc/core/core.c  |  188 +++++++++++++++++++++++++++++++++++++++++++---
>  drivers/mmc/core/host.c  |   24 ++++++
>  include/linux/mmc/card.h |    3 +
>  include/linux/mmc/core.h |    3 +
>  include/linux/mmc/host.h |   25 ++++++
>  7 files changed, 256 insertions(+), 10 deletions(-)
> 
> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
> index f1c84de..4519271 100644
> --- a/drivers/mmc/card/block.c
> +++ b/drivers/mmc/card/block.c
> @@ -1268,6 +1268,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
>  	if (!rqc && !mq->mqrq_prev->req)
>  		return 0;
>  
> +	if (rqc)
> +		card->idle_bkops_rw_reqs_nr++;
> +
>  	do {
>  		if (rqc) {
>  			/*
> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
> index e360a97..c9e1cee 100644
> --- a/drivers/mmc/card/queue.c
> +++ b/drivers/mmc/card/queue.c
> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>  {
>  	struct mmc_queue *mq = d;
>  	struct request_queue *q = mq->queue;
> +	bool release_host = false;
>  
>  	current->flags |= PF_MEMALLOC;
>  
> @@ -66,13 +67,32 @@ static int mmc_queue_thread(void *d)
>  		spin_unlock_irq(q->queue_lock);
>  
>  		if (req || mq->mqrq_prev->req) {
> +			/*
> +			 * If this is the first request, BKOPs might be in
> +			 * progress and needs to be stopped before issuing the
> +			 * request
> +			 * */
> +			if (!mq->mqrq_prev->req &&
> +			    mq->card->ext_csd.bkops_en &&
> +			    mq->card->idle_bkops_rw_reqs_nr == 0) {
> +				release_host = true;
> +				mmc_claim_host(mq->card->host);
> +				mmc_stop_bkops(mq->card);
> +			}
> +
>  			set_current_state(TASK_RUNNING);
>  			mq->issue_fn(mq, req);
> +			if (release_host) {
> +				release_host = false;
> +				mmc_release_host(mq->card->host);
> +			}
>  		} else {
>  			if (kthread_should_stop()) {
>  				set_current_state(TASK_RUNNING);
>  				break;
>  			}
> +
> +			mmc_start_delayed_bkops(mq->card);
>  			up(&mq->thread_sem);
>  			schedule();
>  			down(&mq->thread_sem);
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index ed2cc93..14830d4 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -46,6 +46,15 @@
>   * operations the card has to perform
>   */
>  #define MMC_BKOPS_MAX_TIMEOUT	(4 * 60 * 1000) /* max time to wait in ms */
> +/* Polling timeout and interval for waiting on non-blocking BKOPs completion */
> +#define BKOPS_COMPLETION_POLLING_TIMEOUT 10000 /* in ms */
> +#define BKOPS_COMPLETION_POLLING_INTERVAL 1000 /* in ms */
> +/*
> + * Since canceling the delayed work might have significant effect on the
> + * performance of small requests we won't queue the delayed work every time
> + * mmcqd thread is idle
> + */
> +#define BKOPS_MIN_REQS_TO_QUEUE_DELAYED_WORK 1000
How did you get the minimum request number "1000"?
Is this tunable value?
>  
>  static struct workqueue_struct *workqueue;
>  static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
> @@ -252,6 +261,37 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
>  }
>  
>  /**
> + *      mmc_start_delayed_bkops() - Start a delayed work to check for the need
> + *      of non urgent BKOPs
> + *
> + *      @card: MMC card to start BKOPS
> + */
> +void mmc_start_delayed_bkops(struct mmc_card *card)
> +{
> +	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +		return;
if mmc_card_doing_bkops or didn't support bkops, idle_bkops_rw_reqs_nr need to reset?
> +
> +	if (card->idle_bkops_rw_reqs_nr < BKOPS_MIN_REQS_TO_QUEUE_DELAYED_WORK)
> +		return;
> +
> +	pr_debug("%s: %s: queueing delayed_bkops_work", __func__,
> +		 mmc_hostname(card->host));
missed "\n"..almost missed the new line("\n") at pr_debug.
> +
> +	card->idle_bkops_rw_reqs_nr = 0;
> +
> +	/*
> +	 * cancel_delayed_bkops_work will prevent a race condition between
> +	 * fetching a request by the queue_thread and the delayed work
> +	 */
> +	card->host->bkops_info.cancel_delayed_work = false;
> +	queue_delayed_work(card->host->bkops_info. wq,
> +			   &card->host->bkops_info.idle_time_dw,
> +		   msecs_to_jiffies(
> +			   card->host->bkops_info.time_to_start_bkops_ms));
> +}
> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
> +
> +/**
>   *	mmc_start_bkops - start BKOPS for supported cards
>   *	@card: MMC card to start BKOPS
>   *	@form_exception: A flags to indicate if this function was
> @@ -268,23 +308,47 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>  	bool use_busy_signal;
>  
>  	BUG_ON(!card);
> -
> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +	if (!card->ext_csd.bkops_en)
>  		return;
>  
> +	mmc_claim_host(card->host);
> +
> +	if ((card->host->bkops_info.cancel_delayed_work) && !from_exception) {
> +		pr_debug("%s: %s: cancel_delayed_work was set, exit",
> +			 __func__, mmc_hostname(card->host));
> +		card->host->bkops_info.cancel_delayed_work = false;
> +		goto out;
> +	}
> +
> +	if (mmc_card_doing_bkops(card)) {
> +		pr_debug("%s: %s: already doing bkops, exit", __func__,
> +			 mmc_hostname(card->host));
> +		goto out;
> +	}
> +
>  	err = mmc_read_bkops_status(card);
>  	if (err) {
> -		pr_err("%s: Didn't read bkops status : %d\n",
> +		pr_err("%s: Error %d while reading bkops status\n",
>  		       mmc_hostname(card->host), err);
> -		return;
> +		goto out;
>  	}
> -
>  	if (!card->ext_csd.raw_bkops_status)
> -		return;
> +		goto out;
>  
> -	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2
> -	    && (from_exception))
> -		return;
> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = %d", __func__,
> +		mmc_hostname(card->host), card->ext_csd.raw_bkops_status);
> +
> +	/*
> +	 * If the function was called due to exception but there is no need
> +	 * for urgent BKOPs, BKOPs will be performed by the delayed BKOPs
> +	 * work, before going to suspend
> +	 */
> +	if ((card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2)
> +	    && (from_exception)) {
> +		pr_debug("%s: %s: Level 1 from exception, exit", __func__,
> +			 mmc_hostname(card->host));
> +		goto out;
> +	}
>  
>  	mmc_claim_host(card->host);
>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
> @@ -308,13 +372,101 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>  	 * bkops executed synchronously, otherwise
>  	 * the operation is in progress
>  	 */
> -	if (!use_busy_signal)
> +	if (!use_busy_signal) {
>  		mmc_card_set_doing_bkops(card);
> +		pr_debug("%s: %s: starting the polling thread", __func__,
> +			 mmc_hostname(card->host));
> +		card->host->bkops_info.exit_wait_on_completion = false;
> +		queue_work(system_nrt_wq,
> +			   &card->host->bkops_info.completion_polling);
> +	}
>  out:
>  	mmc_release_host(card->host);
> +
>  }
>  EXPORT_SYMBOL(mmc_start_bkops);
>  
> +/**
> + * mmc_bkops_completion_polling() - Poll on the card status to
> + * wait for the non-blocking BKOPs completion
> + * @work:	The completion polling work
> + *
> + * The on-going reading of the card status will prevent the card
> + * from getting into suspend while it is in the middle of
> + * performing BKOPs.
> + * Since the non blocking BKOPs can be interrupted by a fetched
> + * request we also check exit_wait_on_completion.
> + */
> +void mmc_bkops_completion_polling(struct work_struct *work)
> +{
> +	struct mmc_host *host = container_of(work, struct mmc_host,
> +			bkops_info.completion_polling);
> +	unsigned long timeout_jiffies = jiffies +
> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT);
> +	u32 status;
> +	int err;
> +
> +	/*
> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
> +	 * the host from getting into suspend
> +	 */
> +	do {
> +		mmc_claim_host(host);
> +
> +		if (host->bkops_info.exit_wait_on_completion ||
> +			(!mmc_card_doing_bkops(host->card))) {
> +			goto out;
> +		}
> +
> +		err = mmc_send_status(host->card, &status);
> +		if (err) {
> +			pr_err("%s: error %d requesting status\n",
> +			       mmc_hostname(host), err);
> +			goto out;
> +		}
> +
> +		/*
> +		 * Some cards mishandle the status bits, so make sure to check
> +		 * both the busy indication and the card state.
> +		 */
> +		if ((status & R1_READY_FOR_DATA) &&
> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
> +			pr_debug("%s: completed BKOPs, exit polling", __func__);
missing "..\n". other pr_debug also missed.
> +			mmc_card_clr_doing_bkops(host->card);
> +			goto out;
> +		}
> +
> +		mmc_release_host(host);
> +
> +		/*
> +		 * Sleep before checking the card status again to allow the
> +		 * card to complete the BKOPs operation
> +		 */
> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL);
> +	} while (time_before(jiffies, timeout_jiffies));
> +
> +	pr_debug("%s: exit polling due to timeout", __func__);
> +
> +	return;
> +out:
> +	mmc_release_host(host);
> +}
> +
> +/**
> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPs is
> + * needed
> + * @work:	The idle time BKOPs work
> + */
> +void mmc_start_idle_time_bkops(struct work_struct *work)
> +{
> +	struct mmc_host *host = container_of(work, struct mmc_host,
> +			bkops_info.idle_time_dw.work);
> +
> +	mmc_start_bkops(host->card, false);
> +
> +}
> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
> +
>  static void mmc_wait_done(struct mmc_request *mrq)
>  {
>  	complete(&mrq->completion);
> @@ -574,12 +726,28 @@ EXPORT_SYMBOL(mmc_wait_for_cmd);
>   *	to allow rapid servicing of foreground operations,e.g. read/
>   *	writes. Wait until the card comes out of the programming state
>   *	to avoid errors in servicing read/write requests.
> + *
> + *      This function should be called when the host is claimed
>   */
>  int mmc_stop_bkops(struct mmc_card *card)
>  {
>  	int err = 0;
>  
>  	BUG_ON(!card);
> +
> +	if (delayed_work_pending(&card->host->bkops_info.idle_time_dw))
> +		cancel_delayed_work_sync(&card->host->bkops_info.idle_time_dw);
> +
> +	/*
> +	 * Notify the delayed work to be cancelled, in case it was already
> +	 * removed from the queue, but was not started yet
> +	 */
> +	card->host->bkops_info.cancel_delayed_work = true;
> +
> +	if (!mmc_card_doing_bkops(card))
> +		return err;
> +
> +	card->host->bkops_info.exit_wait_on_completion = true;
>  	err = mmc_interrupt_hpi(card);
>  
>  	/*
> diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
> index 597f189..d328191 100644
> --- a/drivers/mmc/core/host.c
> +++ b/drivers/mmc/core/host.c
> @@ -27,6 +27,11 @@
>  #include "core.h"
>  #include "host.h"
>  
> +/*
> + * A default time for checking the need for non urgent BKOPs once MMC thread
> + * is idle.
> + */
> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>  #define cls_dev_to_mmc_host(d)	container_of(d, struct mmc_host, class_dev)
>  
>  static void mmc_host_classdev_release(struct device *dev)
> @@ -336,6 +341,11 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
>  	spin_lock_init(&host->lock);
>  	init_waitqueue_head(&host->wq);
>  	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
> +	host->bkops_info. wq = create_singlethread_workqueue("bkops_wq");
> +	INIT_DELAYED_WORK(&host->bkops_info.idle_time_dw,
> +			  mmc_start_idle_time_bkops);
> +	INIT_WORK(&host->bkops_info.completion_polling,
> +		  mmc_bkops_completion_polling);
>  #ifdef CONFIG_PM
>  	host->pm_notify.notifier_call = mmc_pm_notify;
>  #endif
> @@ -386,6 +396,20 @@ int mmc_add_host(struct mmc_host *host)
>  #endif
>  	mmc_host_clk_sysfs_init(host);
>  
> +	/*
> +	 * Calculate the time to start the BKOPs checking.
> +	 * The idle time of the host controller should be taken into account
> +	 * in order to prevent a race condition before starting BKOPs and
> +	 * going into suspend.
> +	 * If the host controller didn't set its idle time, a default value is
> +	 * used.
> +	 */
> +	host->bkops_info.time_to_start_bkops_ms = MMC_IDLE_BKOPS_TIME_MS;
> +	if (host->bkops_info.host_suspend_tout_ms)
> +		host->bkops_info.time_to_start_bkops_ms = min(
> +			host->bkops_info.time_to_start_bkops_ms,
> +			host->bkops_info.host_suspend_tout_ms/2);
> +
>  	mmc_start_host(host);
>  	register_pm_notifier(&host->pm_notify);
>  
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index 342fe84..835d6c8 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -280,6 +280,9 @@ struct mmc_card {
>  	struct dentry		*debugfs_root;
>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>  	unsigned int    nr_parts;
> +
> +	/* num of read/write reqs since last BKOPs delayed work was queued */
> +	unsigned int idle_bkops_rw_reqs_nr;
>  };
>  
>  /*
> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
> index 9b9cdaf..665d345 100644
> --- a/include/linux/mmc/core.h
> +++ b/include/linux/mmc/core.h
> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>  	struct mmc_command *, int);
>  extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>  
> diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
> index f578a71..8aaaf1d 100644
> --- a/include/linux/mmc/host.h
> +++ b/include/linux/mmc/host.h
> @@ -176,6 +176,29 @@ struct mmc_supply {
>  	struct regulator *vqmmc;	/* Optional Vccq supply */
>  };
>  
> +/**
> + * struct mmc_bkops_info - BKOPs data
> + * @wq:			workqueue
> + * @idle_time_dw:	Idle time bkops delayed work
> + * @host_suspend_tout_ms:	The host controller idle time,
> + *         before getting into suspend
> + * @time_to_start_bkops_ms:	The time to start the BKOPs
> + *		  delayed work once MMC thread is idle
> + * @completion_polling:	Poll on BKOPs completion
> + * @cancel_delayed_work: A flag to indicate if the delayed work
> + *	       should be cancelled
> + * @exit_wait_on_completion:  Exit flag for non blocking BKOPs
> + */
> +struct mmc_bkops_info {
> +	struct workqueue_struct *wq;
> +	struct delayed_work	idle_time_dw;
> +	unsigned int		host_suspend_tout_ms;
> +	unsigned int		time_to_start_bkops_ms;
> +	struct work_struct	completion_polling;
> +	bool			cancel_delayed_work;
> +	bool			exit_wait_on_completion;
> +};
> +
>  struct mmc_host {
>  	struct device		*parent;
>  	struct device		class_dev;
> @@ -340,6 +363,8 @@ struct mmc_host {
>  
>  	unsigned int		actual_clock;	/* Actual HC clock rate */
>  
> +	struct mmc_bkops_info	bkops_info;
> +
>  	unsigned long		private[0] ____cacheline_aligned;
>  };
>  
> 

Re: [RFC/PATCH] mmc: core: Add support for idle time BKOPs

[merez]

On Thu, August 30, 2012 12:36 am, Jaehoon Chung wrote:
> On 08/05/2012 10:08 PM, Maya Erez wrote:
>> When the mmcqd thread is idle, a delayed work is created to check the
>> need for BKOPs. The time to start the delayed work is calculated based
>> on the host controller suspend timeout, in case it was set. If not, a
>> default time is used.
>> If BKOPs is required in level 1, which is non-blocking, there will be
>> polling of the card status to wait for the BKOPs completion and prevent
>> suspend that will interrupt the BKOPs.
>> If the card raised an exception, the need for urgent BKOPs (level 2/3)
>> will be checked immediately and if needed, the BKOPs will be performed
>> without waiting for the next idle time.
>>
>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>> Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
>> ---
>> This patch depends on the following patch:
>>   [PATCH v11] mmc: support BKOPS feature for eMMC
>>
>> This patch is based on the periodic BKOPs implementation in version 8 of
>> "support BKOPS feature for eMMC" patch.
>> The patch was modified to answer the following issues:
>> - In order to prevent a race condition between going into suspend and
>> starting BKOPs,
>>   the suspend timeout of the host controller is taking into accound in
>> determination of the start time
>>   of the delayed work
>> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host
>> was moved to the beginning of the function
>> - Also, the check of doing_bkops should be protected when determing if
>> an HPI is needed due to the same reason.
>> - Starting and canceling the delayed work in each idle caused
>> degradation of iozone performance. Therefore,
>>   the delayed work is not started on each idle. Currently the number of
>> issued requests from the last delayed work
>>   is the trigger. We still investigate the best trigger for starting the
>> delayed work.
>> - To prevent degaradtion of iozone performance we also moved the call to
>> mmc_claim_host outside of mmc_stop_bkops
>>   and its release is done after issue_fn. This prevents an addition of a
>> full claim and release, that is also done
>>   in issue_fn for the first request after idle time.
>> ---
>>  drivers/mmc/card/block.c |    3 +
>>  drivers/mmc/card/queue.c |   20 +++++
>>  drivers/mmc/core/core.c  |  188
>> +++++++++++++++++++++++++++++++++++++++++++---
>>  drivers/mmc/core/host.c  |   24 ++++++
>>  include/linux/mmc/card.h |    3 +
>>  include/linux/mmc/core.h |    3 +
>>  include/linux/mmc/host.h |   25 ++++++
>>  7 files changed, 256 insertions(+), 10 deletions(-)
>>
>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>> index f1c84de..4519271 100644
>> --- a/drivers/mmc/card/block.c
>> +++ b/drivers/mmc/card/block.c
>> @@ -1268,6 +1268,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue
>> *mq, struct request *rqc)
>>  	if (!rqc && !mq->mqrq_prev->req)
>>  		return 0;
>>
>> +	if (rqc)
>> +		card->idle_bkops_rw_reqs_nr++;
>> +
>>  	do {
>>  		if (rqc) {
>>  			/*
>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>> index e360a97..c9e1cee 100644
>> --- a/drivers/mmc/card/queue.c
>> +++ b/drivers/mmc/card/queue.c
>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>  {
>>  	struct mmc_queue *mq = d;
>>  	struct request_queue *q = mq->queue;
>> +	bool release_host = false;
>>
>>  	current->flags |= PF_MEMALLOC;
>>
>> @@ -66,13 +67,32 @@ static int mmc_queue_thread(void *d)
>>  		spin_unlock_irq(q->queue_lock);
>>
>>  		if (req || mq->mqrq_prev->req) {
>> +			/*
>> +			 * If this is the first request, BKOPs might be in
>> +			 * progress and needs to be stopped before issuing the
>> +			 * request
>> +			 * */
>> +			if (!mq->mqrq_prev->req &&
>> +			    mq->card->ext_csd.bkops_en &&
>> +			    mq->card->idle_bkops_rw_reqs_nr == 0) {
>> +				release_host = true;
>> +				mmc_claim_host(mq->card->host);
>> +				mmc_stop_bkops(mq->card);
>> +			}
>> +
>>  			set_current_state(TASK_RUNNING);
>>  			mq->issue_fn(mq, req);
>> +			if (release_host) {
>> +				release_host = false;
>> +				mmc_release_host(mq->card->host);
>> +			}
>>  		} else {
>>  			if (kthread_should_stop()) {
>>  				set_current_state(TASK_RUNNING);
>>  				break;
>>  			}
>> +
>> +			mmc_start_delayed_bkops(mq->card);
>>  			up(&mq->thread_sem);
>>  			schedule();
>>  			down(&mq->thread_sem);
>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>> index ed2cc93..14830d4 100644
>> --- a/drivers/mmc/core/core.c
>> +++ b/drivers/mmc/core/core.c
>> @@ -46,6 +46,15 @@
>>   * operations the card has to perform
>>   */
>>  #define MMC_BKOPS_MAX_TIMEOUT	(4 * 60 * 1000) /* max time to wait in ms
>> */
>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>> completion */
>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT 10000 /* in ms */
>> +#define BKOPS_COMPLETION_POLLING_INTERVAL 1000 /* in ms */
>> +/*
>> + * Since canceling the delayed work might have significant effect on
>> the
>> + * performance of small requests we won't queue the delayed work every
>> time
>> + * mmcqd thread is idle
>> + */
>> +#define BKOPS_MIN_REQS_TO_QUEUE_DELAYED_WORK 1000
> How did you get the minimum request number "1000"?
> Is this tunable value?
We tried several values to prevent degradation of iozone results and this
gave the best results.
We are still tuning this value and one of the options is to count the
number of write requests only (since read activity on the card won't
change the need for BKOPs).
>>
>>  static struct workqueue_struct *workqueue;
>>  static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
>> @@ -252,6 +261,37 @@ mmc_start_request(struct mmc_host *host, struct
>> mmc_request *mrq)
>>  }
>>
>>  /**
>> + *      mmc_start_delayed_bkops() - Start a delayed work to check for
>> the need
>> + *      of non urgent BKOPs
>> + *
>> + *      @card: MMC card to start BKOPS
>> + */
>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>> +{
>> +	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>> +		return;
> if mmc_card_doing_bkops or didn't support bkops, idle_bkops_rw_reqs_nr
> need to reset?
>> +
>> +	if (card->idle_bkops_rw_reqs_nr <
>> BKOPS_MIN_REQS_TO_QUEUE_DELAYED_WORK)
>> +		return;
>> +
>> +	pr_debug("%s: %s: queueing delayed_bkops_work", __func__,
>> +		 mmc_hostname(card->host));
> missed "\n"..almost missed the new line("\n") at pr_debug.
Will fix that.
>> +
>> +	card->idle_bkops_rw_reqs_nr = 0;
>> +
>> +	/*
>> +	 * cancel_delayed_bkops_work will prevent a race condition between
>> +	 * fetching a request by the queue_thread and the delayed work
>> +	 */
>> +	card->host->bkops_info.cancel_delayed_work = false;
>> +	queue_delayed_work(card->host->bkops_info. wq,
>> +			   &card->host->bkops_info.idle_time_dw,
>> +		   msecs_to_jiffies(
>> +			   card->host->bkops_info.time_to_start_bkops_ms));
>> +}
>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>> +
>> +/**
>>   *	mmc_start_bkops - start BKOPS for supported cards
>>   *	@card: MMC card to start BKOPS
>>   *	@form_exception: A flags to indicate if this function was
>> @@ -268,23 +308,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception)
>>  	bool use_busy_signal;
>>
>>  	BUG_ON(!card);
>> -
>> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>> +	if (!card->ext_csd.bkops_en)
>>  		return;
>>
>> +	mmc_claim_host(card->host);
>> +
>> +	if ((card->host->bkops_info.cancel_delayed_work) && !from_exception) {
>> +		pr_debug("%s: %s: cancel_delayed_work was set, exit",
>> +			 __func__, mmc_hostname(card->host));
>> +		card->host->bkops_info.cancel_delayed_work = false;
>> +		goto out;
>> +	}
>> +
>> +	if (mmc_card_doing_bkops(card)) {
>> +		pr_debug("%s: %s: already doing bkops, exit", __func__,
>> +			 mmc_hostname(card->host));
>> +		goto out;
>> +	}
>> +
>>  	err = mmc_read_bkops_status(card);
>>  	if (err) {
>> -		pr_err("%s: Didn't read bkops status : %d\n",
>> +		pr_err("%s: Error %d while reading bkops status\n",
>>  		       mmc_hostname(card->host), err);
>> -		return;
>> +		goto out;
>>  	}
>> -
>>  	if (!card->ext_csd.raw_bkops_status)
>> -		return;
>> +		goto out;
>>
>> -	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2
>> -	    && (from_exception))
>> -		return;
>> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = %d", __func__,
>> +		mmc_hostname(card->host), card->ext_csd.raw_bkops_status);
>> +
>> +	/*
>> +	 * If the function was called due to exception but there is no need
>> +	 * for urgent BKOPs, BKOPs will be performed by the delayed BKOPs
>> +	 * work, before going to suspend
>> +	 */
>> +	if ((card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2)
>> +	    && (from_exception)) {
>> +		pr_debug("%s: %s: Level 1 from exception, exit", __func__,
>> +			 mmc_hostname(card->host));
>> +		goto out;
>> +	}
>>
>>  	mmc_claim_host(card->host);
>>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>> @@ -308,13 +372,101 @@ void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception)
>>  	 * bkops executed synchronously, otherwise
>>  	 * the operation is in progress
>>  	 */
>> -	if (!use_busy_signal)
>> +	if (!use_busy_signal) {
>>  		mmc_card_set_doing_bkops(card);
>> +		pr_debug("%s: %s: starting the polling thread", __func__,
>> +			 mmc_hostname(card->host));
>> +		card->host->bkops_info.exit_wait_on_completion = false;
>> +		queue_work(system_nrt_wq,
>> +			   &card->host->bkops_info.completion_polling);
>> +	}
>>  out:
>>  	mmc_release_host(card->host);
>> +
>>  }
>>  EXPORT_SYMBOL(mmc_start_bkops);
>>
>> +/**
>> + * mmc_bkops_completion_polling() - Poll on the card status to
>> + * wait for the non-blocking BKOPs completion
>> + * @work:	The completion polling work
>> + *
>> + * The on-going reading of the card status will prevent the card
>> + * from getting into suspend while it is in the middle of
>> + * performing BKOPs.
>> + * Since the non blocking BKOPs can be interrupted by a fetched
>> + * request we also check exit_wait_on_completion.
>> + */
>> +void mmc_bkops_completion_polling(struct work_struct *work)
>> +{
>> +	struct mmc_host *host = container_of(work, struct mmc_host,
>> +			bkops_info.completion_polling);
>> +	unsigned long timeout_jiffies = jiffies +
>> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT);
>> +	u32 status;
>> +	int err;
>> +
>> +	/*
>> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
>> +	 * the host from getting into suspend
>> +	 */
>> +	do {
>> +		mmc_claim_host(host);
>> +
>> +		if (host->bkops_info.exit_wait_on_completion ||
>> +			(!mmc_card_doing_bkops(host->card))) {
>> +			goto out;
>> +		}
>> +
>> +		err = mmc_send_status(host->card, &status);
>> +		if (err) {
>> +			pr_err("%s: error %d requesting status\n",
>> +			       mmc_hostname(host), err);
>> +			goto out;
>> +		}
>> +
>> +		/*
>> +		 * Some cards mishandle the status bits, so make sure to check
>> +		 * both the busy indication and the card state.
>> +		 */
>> +		if ((status & R1_READY_FOR_DATA) &&
>> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>> +			pr_debug("%s: completed BKOPs, exit polling", __func__);
> missing "..\n". other pr_debug also missed.
Will fix that.
>> +			mmc_card_clr_doing_bkops(host->card);
>> +			goto out;
>> +		}
>> +
>> +		mmc_release_host(host);
>> +
>> +		/*
>> +		 * Sleep before checking the card status again to allow the
>> +		 * card to complete the BKOPs operation
>> +		 */
>> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL);
>> +	} while (time_before(jiffies, timeout_jiffies));
>> +
>> +	pr_debug("%s: exit polling due to timeout", __func__);
>> +
>> +	return;
>> +out:
>> +	mmc_release_host(host);
>> +}
>> +
>> +/**
>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPs is
>> + * needed
>> + * @work:	The idle time BKOPs work
>> + */
>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>> +{
>> +	struct mmc_host *host = container_of(work, struct mmc_host,
>> +			bkops_info.idle_time_dw.work);
>> +
>> +	mmc_start_bkops(host->card, false);
>> +
>> +}
>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>> +
>>  static void mmc_wait_done(struct mmc_request *mrq)
>>  {
>>  	complete(&mrq->completion);
>> @@ -574,12 +726,28 @@ EXPORT_SYMBOL(mmc_wait_for_cmd);
>>   *	to allow rapid servicing of foreground operations,e.g. read/
>>   *	writes. Wait until the card comes out of the programming state
>>   *	to avoid errors in servicing read/write requests.
>> + *
>> + *      This function should be called when the host is claimed
>>   */
>>  int mmc_stop_bkops(struct mmc_card *card)
>>  {
>>  	int err = 0;
>>
>>  	BUG_ON(!card);
>> +
>> +	if (delayed_work_pending(&card->host->bkops_info.idle_time_dw))
>> +		cancel_delayed_work_sync(&card->host->bkops_info.idle_time_dw);
>> +
>> +	/*
>> +	 * Notify the delayed work to be cancelled, in case it was already
>> +	 * removed from the queue, but was not started yet
>> +	 */
>> +	card->host->bkops_info.cancel_delayed_work = true;
>> +
>> +	if (!mmc_card_doing_bkops(card))
>> +		return err;
>> +
>> +	card->host->bkops_info.exit_wait_on_completion = true;
>>  	err = mmc_interrupt_hpi(card);
>>
>>  	/*
>> diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
>> index 597f189..d328191 100644
>> --- a/drivers/mmc/core/host.c
>> +++ b/drivers/mmc/core/host.c
>> @@ -27,6 +27,11 @@
>>  #include "core.h"
>>  #include "host.h"
>>
>> +/*
>> + * A default time for checking the need for non urgent BKOPs once MMC
>> thread
>> + * is idle.
>> + */
>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>  #define cls_dev_to_mmc_host(d)	container_of(d, struct mmc_host,
>> class_dev)
>>
>>  static void mmc_host_classdev_release(struct device *dev)
>> @@ -336,6 +341,11 @@ struct mmc_host *mmc_alloc_host(int extra, struct
>> device *dev)
>>  	spin_lock_init(&host->lock);
>>  	init_waitqueue_head(&host->wq);
>>  	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
>> +	host->bkops_info. wq = create_singlethread_workqueue("bkops_wq");
>> +	INIT_DELAYED_WORK(&host->bkops_info.idle_time_dw,
>> +			  mmc_start_idle_time_bkops);
>> +	INIT_WORK(&host->bkops_info.completion_polling,
>> +		  mmc_bkops_completion_polling);
>>  #ifdef CONFIG_PM
>>  	host->pm_notify.notifier_call = mmc_pm_notify;
>>  #endif
>> @@ -386,6 +396,20 @@ int mmc_add_host(struct mmc_host *host)
>>  #endif
>>  	mmc_host_clk_sysfs_init(host);
>>
>> +	/*
>> +	 * Calculate the time to start the BKOPs checking.
>> +	 * The idle time of the host controller should be taken into account
>> +	 * in order to prevent a race condition before starting BKOPs and
>> +	 * going into suspend.
>> +	 * If the host controller didn't set its idle time, a default value is
>> +	 * used.
>> +	 */
>> +	host->bkops_info.time_to_start_bkops_ms = MMC_IDLE_BKOPS_TIME_MS;
>> +	if (host->bkops_info.host_suspend_tout_ms)
>> +		host->bkops_info.time_to_start_bkops_ms = min(
>> +			host->bkops_info.time_to_start_bkops_ms,
>> +			host->bkops_info.host_suspend_tout_ms/2);
>> +
>>  	mmc_start_host(host);
>>  	register_pm_notifier(&host->pm_notify);
>>
>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>> index 342fe84..835d6c8 100644
>> --- a/include/linux/mmc/card.h
>> +++ b/include/linux/mmc/card.h
>> @@ -280,6 +280,9 @@ struct mmc_card {
>>  	struct dentry		*debugfs_root;
>>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>>  	unsigned int    nr_parts;
>> +
>> +	/* num of read/write reqs since last BKOPs delayed work was queued */
>> +	unsigned int idle_bkops_rw_reqs_nr;
>>  };
>>
>>  /*
>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>> index 9b9cdaf..665d345 100644
>> --- a/include/linux/mmc/core.h
>> +++ b/include/linux/mmc/core.h
>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>> mmc_card *);
>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>>  	struct mmc_command *, int);
>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception);
>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
>> bool);
>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>
>> diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
>> index f578a71..8aaaf1d 100644
>> --- a/include/linux/mmc/host.h
>> +++ b/include/linux/mmc/host.h
>> @@ -176,6 +176,29 @@ struct mmc_supply {
>>  	struct regulator *vqmmc;	/* Optional Vccq supply */
>>  };
>>
>> +/**
>> + * struct mmc_bkops_info - BKOPs data
>> + * @wq:			workqueue
>> + * @idle_time_dw:	Idle time bkops delayed work
>> + * @host_suspend_tout_ms:	The host controller idle time,
>> + *         before getting into suspend
>> + * @time_to_start_bkops_ms:	The time to start the BKOPs
>> + *		  delayed work once MMC thread is idle
>> + * @completion_polling:	Poll on BKOPs completion
>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>> + *	       should be cancelled
>> + * @exit_wait_on_completion:  Exit flag for non blocking BKOPs
>> + */
>> +struct mmc_bkops_info {
>> +	struct workqueue_struct *wq;
>> +	struct delayed_work	idle_time_dw;
>> +	unsigned int		host_suspend_tout_ms;
>> +	unsigned int		time_to_start_bkops_ms;
>> +	struct work_struct	completion_polling;
>> +	bool			cancel_delayed_work;
>> +	bool			exit_wait_on_completion;
>> +};
>> +
>>  struct mmc_host {
>>  	struct device		*parent;
>>  	struct device		class_dev;
>> @@ -340,6 +363,8 @@ struct mmc_host {
>>
>>  	unsigned int		actual_clock;	/* Actual HC clock rate */
>>
>> +	struct mmc_bkops_info	bkops_info;
>> +
>>  	unsigned long		private[0] ____cacheline_aligned;
>>  };
>>
>>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>
Thanks,
Maya

-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

[PATCH v2] mmc: core: Add support for idle time BKOPS

[Maya Erez]

Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).

According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.

This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.

When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.

Signed-off-by: Maya Erez <merez@codeaurora.org>
Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
---
This patch is based on the periodic BKOPS implementation in version 8 of "support BKOPS feature for eMMC" patch.
The patch was modified to answer the following issues:
- In order to prevent a race condition between going into suspend and starting BKOPS, 
  the suspend timeout of the host controller is taking into accound in determination of the start time 
  of the delayed work
- Since mmc_start_bkops is called from two contexts now, mmc_claim_host was moved to the beginning of the function
- Also, the check of doing_bkops should be protected when determing if an HPI is needed due to the same reason.
- Starting and canceling the delayed work in each idle caused degradation of iozone performance. Therefore,
  the delayed work is not started on each idle. The amount of sectors changed (written or discard) from the last 
  delayed work is the trigger for starting the delayed BKOPS work.
---
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 172a768..ed040d5 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -827,6 +827,9 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
 	from = blk_rq_pos(req);
 	nr = blk_rq_sectors(req);
 
+	if (card->ext_csd.bkops_en)
+		card->bkops_info.sectors_changed += blk_rq_sectors(req);
+
 	if (mmc_can_discard(card))
 		arg = MMC_DISCARD_ARG;
 	else if (mmc_can_trim(card))
@@ -1268,6 +1271,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
 	if (!rqc && !mq->mqrq_prev->req)
 		return 0;
 
+	if (rqc && (card->ext_csd.bkops_en) && (rq_data_dir(rqc) == WRITE))
+			card->bkops_info.sectors_changed += blk_rq_sectors(rqc);
+
 	do {
 		if (rqc) {
 			/*
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index e360a97..e96f5cf 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
 {
 	struct mmc_queue *mq = d;
 	struct request_queue *q = mq->queue;
+	struct mmc_card *card = mq->card;
 
 	current->flags |= PF_MEMALLOC;
 
@@ -66,6 +67,17 @@ static int mmc_queue_thread(void *d)
 		spin_unlock_irq(q->queue_lock);
 
 		if (req || mq->mqrq_prev->req) {
+			/*
+			 * If this is the first request, BKOPs might be in
+			 * progress and needs to be stopped before issuing the
+			 * request
+			 */
+			if (card->ext_csd.bkops_en &&
+			    card->bkops_info.started_delayed_bkops) {
+				card->bkops_info.started_delayed_bkops = false;
+				mmc_stop_bkops(card);
+			}
+
 			set_current_state(TASK_RUNNING);
 			mq->issue_fn(mq, req);
 		} else {
@@ -73,6 +85,7 @@ static int mmc_queue_thread(void *d)
 				set_current_state(TASK_RUNNING);
 				break;
 			}
+			mmc_start_delayed_bkops(card);
 			up(&mq->thread_sem);
 			schedule();
 			down(&mq->thread_sem);
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 6612163..fd8783d 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -253,9 +253,42 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 }
 
 /**
+ * mmc_start_delayed_bkops() - Start a delayed work to check for
+ *      the need of non urgent BKOPS
+ *
+ * @card: MMC card to start BKOPS on
+ */
+void mmc_start_delayed_bkops(struct mmc_card *card)
+{
+	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+		return;
+
+	if (card->bkops_info.sectors_changed <
+	    BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK)
+		return;
+
+	pr_debug("%s: %s: queueing delayed_bkops_work\n",
+		 mmc_hostname(card->host), __func__);
+
+	card->bkops_info.sectors_changed = 0;
+
+	/*
+	 * cancel_delayed_bkops_work will prevent a race condition between
+	 * fetching a request by the mmcqd and the delayed work, in case
+	 * it was removed from the queue work but not started yet
+	 */
+	card->bkops_info.cancel_delayed_work = false;
+	card->bkops_info.started_delayed_bkops = true;
+	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
+			   msecs_to_jiffies(
+				   card->bkops_info.delay_ms));
+}
+EXPORT_SYMBOL(mmc_start_delayed_bkops);
+
+/**
  *	mmc_start_bkops - start BKOPS for supported cards
  *	@card: MMC card to start BKOPS
- *	@form_exception: A flag to indicate if this function was
+ *	@from_exception: A flag to indicate if this function was
  *			 called due to an exception raised by the card
  *
  *	Start background operations whenever requested.
@@ -269,25 +302,47 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
 	bool use_busy_signal;
 
 	BUG_ON(!card);
-
-	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+	if (!card->ext_csd.bkops_en)
 		return;
 
+	mmc_claim_host(card->host);
+
+	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
+		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
+			 mmc_hostname(card->host), __func__);
+		card->bkops_info.cancel_delayed_work = false;
+		goto out;
+	}
+
+	if (mmc_card_doing_bkops(card)) {
+		pr_debug("%s: %s: already doing bkops, exit\n",
+			 mmc_hostname(card->host), __func__);
+		goto out;
+	}
+
 	err = mmc_read_bkops_status(card);
 	if (err) {
 		pr_err("%s: Failed to read bkops status: %d\n",
 		       mmc_hostname(card->host), err);
-		return;
+		goto out;
 	}
 
 	if (!card->ext_csd.raw_bkops_status)
-		return;
+		goto out;
+
+	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
+		mmc_hostname(card->host), __func__,
+		card->ext_csd.raw_bkops_status);
 
+	/*
+	 * If the function was called due to exception but there is no need
+	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
+	 * work, before going to suspend
+	 */
 	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
 	    from_exception)
-		return;
+		goto out;
 
-	mmc_claim_host(card->host);
 	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
 		timeout = MMC_BKOPS_MAX_TIMEOUT;
 		use_busy_signal = true;
@@ -309,13 +364,108 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
 	 * bkops executed synchronously, otherwise
 	 * the operation is in progress
 	 */
-	if (!use_busy_signal)
+	if (!use_busy_signal) {
 		mmc_card_set_doing_bkops(card);
+		pr_debug("%s: %s: starting the polling thread\n",
+			 mmc_hostname(card->host), __func__);
+		queue_work(system_nrt_wq,
+			   &card->bkops_info.poll_for_completion);
+	}
+
 out:
 	mmc_release_host(card->host);
 }
 EXPORT_SYMBOL(mmc_start_bkops);
 
+/**
+ * mmc_bkops_completion_polling() - Poll on the card status to
+ * wait for the non-blocking BKOPS completion
+ * @work:	The completion polling work
+ *
+ * The on-going reading of the card status will prevent the card
+ * from getting into suspend while it is in the middle of
+ * performing BKOPS.
+ * Since the non blocking BKOPS can be interrupted by a fetched
+ * request we also check IF mmc_card_doing_bkops in each
+ * iteration.
+ */
+void mmc_bkops_completion_polling(struct work_struct *work)
+{
+	struct mmc_card *card = container_of(work, struct mmc_card,
+			bkops_info.poll_for_completion);
+	unsigned long timeout_jiffies = jiffies +
+		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
+	u32 status;
+	int err;
+
+	/*
+	 * Wait for the BKOPs to complete. Keep reading the status to prevent
+	 * the host from getting into suspend
+	 */
+	do {
+		mmc_claim_host(card->host);
+
+		if (!mmc_card_doing_bkops(card))
+			goto out;
+
+		err = mmc_send_status(card, &status);
+		if (err) {
+			pr_err("%s: error %d requesting status\n",
+			       mmc_hostname(card->host), err);
+			goto out;
+		}
+
+		/*
+		 * Some cards mishandle the status bits, so make sure to check
+		 * both the busy indication and the card state.
+		 */
+		if ((status & R1_READY_FOR_DATA) &&
+		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
+			pr_debug("%s: %s: completed BKOPs, exit polling\n",
+				 mmc_hostname(card->host), __func__);
+			mmc_card_clr_doing_bkops(card);
+			card->bkops_info.started_delayed_bkops = false;
+			goto out;
+		}
+
+		mmc_release_host(card->host);
+
+		/*
+		 * Sleep before checking the card status again to allow the
+		 * card to complete the BKOPs operation
+		 */
+		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
+	} while (time_before(jiffies, timeout_jiffies));
+
+	pr_err("%s: %s: exit polling due to timeout\n",
+	       mmc_hostname(card->host), __func__);
+
+	return;
+out:
+	mmc_release_host(card->host);
+}
+
+/**
+ * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
+ * needed
+ * @work:	The idle time BKOPS work
+ */
+void mmc_start_idle_time_bkops(struct work_struct *work)
+{
+	struct mmc_card *card = container_of(work, struct mmc_card,
+			bkops_info.dw.work);
+
+	/*
+	 * Prevent a race condition between mmc_stop_bkops and the delayed
+	 * BKOPS work in case the delayed work is executed on another CPU
+	 */
+	if (card->bkops_info.cancel_delayed_work)
+		return;
+
+	mmc_start_bkops(card, false);
+}
+EXPORT_SYMBOL(mmc_start_idle_time_bkops);
+
 static void mmc_wait_done(struct mmc_request *mrq)
 {
 	complete(&mrq->completion);
@@ -582,6 +732,19 @@ int mmc_stop_bkops(struct mmc_card *card)
 	int err = 0;
 
 	BUG_ON(!card);
+
+	mmc_claim_host(card->host);
+
+	/*
+	 * Notify the delayed work to be cancelled, in case it was already
+	 * removed from the queue, but was not started yet
+	 */
+	card->bkops_info.cancel_delayed_work = true;
+	if (delayed_work_pending(&card->bkops_info.dw))
+		cancel_delayed_work_sync(&card->bkops_info.dw);
+	if (!mmc_card_doing_bkops(card))
+		goto out;
+
 	err = mmc_interrupt_hpi(card);
 
 	/*
@@ -593,6 +756,8 @@ int mmc_stop_bkops(struct mmc_card *card)
 		err = 0;
 	}
 
+out:
+	mmc_release_host(card->host);
 	return err;
 }
 EXPORT_SYMBOL(mmc_stop_bkops);
@@ -2566,15 +2731,13 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 	switch (mode) {
 	case PM_HIBERNATION_PREPARE:
 	case PM_SUSPEND_PREPARE:
-		if (host->card && mmc_card_mmc(host->card) &&
-		    mmc_card_doing_bkops(host->card)) {
+		if (host->card && mmc_card_mmc(host->card)) {
 			err = mmc_stop_bkops(host->card);
 			if (err) {
 				pr_err("%s: didn't stop bkops\n",
 					mmc_hostname(host));
 				return err;
 			}
-			mmc_card_clr_doing_bkops(host->card);
 		}
 
 		spin_lock_irqsave(&host->lock, flags);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 7509de1..f8ff640 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -1258,6 +1258,30 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
 		}
 	}
 
+	if (!oldcard) {
+		if (card->ext_csd.bkops_en) {
+			INIT_DELAYED_WORK(&card->bkops_info.dw,
+					  mmc_start_idle_time_bkops);
+			INIT_WORK(&card->bkops_info.poll_for_completion,
+				  mmc_bkops_completion_polling);
+
+			/*
+			 * Calculate the time to start the BKOPs checking.
+			 * The idle time of the host controller should be taken
+			 * into account in order to prevent a race condition
+			 * before starting BKOPs and going into suspend.
+			 * If the host controller didn't set its idle time,
+			 * a default value is used.
+			 */
+			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
+			if (card->bkops_info.host_suspend_tout_ms)
+				card->bkops_info.delay_ms = min(
+					card->bkops_info.delay_ms,
+				      card->bkops_info.host_suspend_tout_ms/2);
+
+		}
+	}
+
 	if (!oldcard)
 		host->card = card;
 
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 78cc3be..0e4d55a 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -207,6 +207,48 @@ struct mmc_part {
 #define MMC_BLK_DATA_AREA_GP	(1<<2)
 };
 
+/**
+ * struct mmc_bkops_info - BKOPS data
+ * @dw:	Idle time bkops delayed work
+ * @host_suspend_tout_ms:	The host controller idle time,
+ * before getting into suspend
+ * @delay_ms:	The time to start the BKOPS
+ *        delayed work once MMC thread is idle
+ * @poll_for_completion:	Poll on BKOPS completion
+ * @cancel_delayed_work: A flag to indicate if the delayed work
+ *        should be cancelled
+ * @started_delayed_bkops:  A flag to indicate if the delayed
+ *        work was scheduled
+ * @sectors_changed:  number of  sectors written or
+ *       discard since the last idle BKOPS were scheduled
+ */
+struct mmc_bkops_info {
+	struct delayed_work	dw;
+	unsigned int		host_suspend_tout_ms;
+	unsigned int		delay_ms;
+/*
+ * A default time for checking the need for non urgent BKOPS once mmcqd
+ * is idle.
+ */
+#define MMC_IDLE_BKOPS_TIME_MS 2000
+	struct work_struct	poll_for_completion;
+/* Polling timeout and interval for waiting on non-blocking BKOPs completion */
+#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
+#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
+	bool			cancel_delayed_work;
+	bool			started_delayed_bkops;
+	unsigned int		sectors_changed;
+/*
+ * Since canceling the delayed work might have significant effect on the
+ * performance of small requests we won't queue the delayed work every time
+ * mmcqd thread is idle.
+ * The delayed work for idle BKOPS will be scheduled only after a significant
+ * amount of write or discard data.
+ * 100MB is chosen based on benchmark tests.
+ */
+#define BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK 204800 /* 100MB */
+};
+
 /*
  * MMC device
  */
@@ -281,6 +323,8 @@ struct mmc_card {
 	struct dentry		*debugfs_root;
 	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
 	unsigned int    nr_parts;
+
+	struct mmc_bkops_info	bkops_info;
 };
 
 /*
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 9b9cdaf..665d345 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
 extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
 	struct mmc_command *, int);
 extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
+extern void mmc_start_delayed_bkops(struct mmc_card *card);
+extern void mmc_start_idle_time_bkops(struct work_struct *work);
+extern void mmc_bkops_completion_polling(struct work_struct *work);
 extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
 extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
 
-- 
1.7.6
-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v2] mmc: core: Add support for idle time BKOPS

[merez]

Hi Chris and all,

According to the eMMC4.5 standard, a host that enables the BKOPS_EN bit
must also check the BKOPS status periodically:
"Host shall check the status periodically and start background operations
as needed, so that the device has enough time for its maintenance
operations, to help reduce the latencies during foreground operations. If
the status is at level 3 ("critical"), some operations may extend beyond
their original timeouts due to maintenance operations which cannot be
delayed anymore. The host should give the device enough time for
background operations to avoid getting to this level in the first place."

As mentioned in the standard quotation above, it is not recommended to
handle only BKOPS of level 3 since it can lead to foreground operations
timeout.

I would appreciate if you could review this change to add the periodic
BKOPS on top of handling BKOPS level 3 that was already mainlined.

Thnaks,
Maya
On Thu, October 4, 2012 3:28 pm, Maya Erez wrote:
> Devices have various maintenance operations need to perform internally.
> In order to reduce latencies during time critical operations like read
> and write, it is better to execute maintenance operations in other
> times - when the host is not being serviced. Such operations are called
> Background operations (BKOPS).
> The device notifies the status of the BKOPS need by updating BKOPS_STATUS
> (EXT_CSD byte [246]).
>
> According to the standard a host that supports BKOPS shall check the
> status periodically and start background operations as needed, so that
> the device has enough time for its maintenance operations.
>
> This patch adds support for this periodic check of the BKOPS status.
> Since foreground operations are of higher priority than background
> operations the host will check the need for BKOPS when it is idle,
> and in case of an incoming request the BKOPS operation will be
> interrupted.
>
> When the mmcqd thread is idle, a delayed work is created to check the
> need for BKOPS. The time to start the delayed work is calculated based
> on the host controller suspend timeout, in case it was set. If not, a
> default time is used.
> If BKOPS are required in level 1, which is non-blocking, there will be
> polling of the card status to wait for the BKOPS completion and prevent
> suspend that will interrupt the BKOPS.
> If the card raised an exception, the need for urgent BKOPS (level 2/3)
> will be checked immediately and if needed, the BKOPS will be performed
> without waiting for the next idle time.
>
> Signed-off-by: Maya Erez <merez@codeaurora.org>
> Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
> ---
> This patch is based on the periodic BKOPS implementation in version 8 of
> "support BKOPS feature for eMMC" patch.
> The patch was modified to answer the following issues:
> - In order to prevent a race condition between going into suspend and
> starting BKOPS,
>   the suspend timeout of the host controller is taking into accound in
> determination of the start time
>   of the delayed work
> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host
> was moved to the beginning of the function
> - Also, the check of doing_bkops should be protected when determing if an
> HPI is needed due to the same reason.
> - Starting and canceling the delayed work in each idle caused degradation
> of iozone performance. Therefore,
>   the delayed work is not started on each idle. The amount of sectors
> changed (written or discard) from the last
>   delayed work is the trigger for starting the delayed BKOPS work.
> ---
> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
> index 172a768..ed040d5 100644
> --- a/drivers/mmc/card/block.c
> +++ b/drivers/mmc/card/block.c
> @@ -827,6 +827,9 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue
> *mq, struct request *req)
>  	from = blk_rq_pos(req);
>  	nr = blk_rq_sectors(req);
>
> +	if (card->ext_csd.bkops_en)
> +		card->bkops_info.sectors_changed += blk_rq_sectors(req);
> +
>  	if (mmc_can_discard(card))
>  		arg = MMC_DISCARD_ARG;
>  	else if (mmc_can_trim(card))
> @@ -1268,6 +1271,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq,
> struct request *rqc)
>  	if (!rqc && !mq->mqrq_prev->req)
>  		return 0;
>
> +	if (rqc && (card->ext_csd.bkops_en) && (rq_data_dir(rqc) == WRITE))
> +			card->bkops_info.sectors_changed += blk_rq_sectors(rqc);
> +
>  	do {
>  		if (rqc) {
>  			/*
> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
> index e360a97..e96f5cf 100644
> --- a/drivers/mmc/card/queue.c
> +++ b/drivers/mmc/card/queue.c
> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>  {
>  	struct mmc_queue *mq = d;
>  	struct request_queue *q = mq->queue;
> +	struct mmc_card *card = mq->card;
>
>  	current->flags |= PF_MEMALLOC;
>
> @@ -66,6 +67,17 @@ static int mmc_queue_thread(void *d)
>  		spin_unlock_irq(q->queue_lock);
>
>  		if (req || mq->mqrq_prev->req) {
> +			/*
> +			 * If this is the first request, BKOPs might be in
> +			 * progress and needs to be stopped before issuing the
> +			 * request
> +			 */
> +			if (card->ext_csd.bkops_en &&
> +			    card->bkops_info.started_delayed_bkops) {
> +				card->bkops_info.started_delayed_bkops = false;
> +				mmc_stop_bkops(card);
> +			}
> +
>  			set_current_state(TASK_RUNNING);
>  			mq->issue_fn(mq, req);
>  		} else {
> @@ -73,6 +85,7 @@ static int mmc_queue_thread(void *d)
>  				set_current_state(TASK_RUNNING);
>  				break;
>  			}
> +			mmc_start_delayed_bkops(card);
>  			up(&mq->thread_sem);
>  			schedule();
>  			down(&mq->thread_sem);
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index 6612163..fd8783d 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -253,9 +253,42 @@ mmc_start_request(struct mmc_host *host, struct
> mmc_request *mrq)
>  }
>
>  /**
> + * mmc_start_delayed_bkops() - Start a delayed work to check for
> + *      the need of non urgent BKOPS
> + *
> + * @card: MMC card to start BKOPS on
> + */
> +void mmc_start_delayed_bkops(struct mmc_card *card)
> +{
> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +		return;
> +
> +	if (card->bkops_info.sectors_changed <
> +	    BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK)
> +		return;
> +
> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
> +		 mmc_hostname(card->host), __func__);
> +
> +	card->bkops_info.sectors_changed = 0;
> +
> +	/*
> +	 * cancel_delayed_bkops_work will prevent a race condition between
> +	 * fetching a request by the mmcqd and the delayed work, in case
> +	 * it was removed from the queue work but not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = false;
> +	card->bkops_info.started_delayed_bkops = true;
> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
> +			   msecs_to_jiffies(
> +				   card->bkops_info.delay_ms));
> +}
> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
> +
> +/**
>   *	mmc_start_bkops - start BKOPS for supported cards
>   *	@card: MMC card to start BKOPS
> - *	@form_exception: A flag to indicate if this function was
> + *	@from_exception: A flag to indicate if this function was
>   *			 called due to an exception raised by the card
>   *
>   *	Start background operations whenever requested.
> @@ -269,25 +302,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
> from_exception)
>  	bool use_busy_signal;
>
>  	BUG_ON(!card);
> -
> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +	if (!card->ext_csd.bkops_en)
>  		return;
>
> +	mmc_claim_host(card->host);
> +
> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		card->bkops_info.cancel_delayed_work = false;
> +		goto out;
> +	}
> +
> +	if (mmc_card_doing_bkops(card)) {
> +		pr_debug("%s: %s: already doing bkops, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		goto out;
> +	}
> +
>  	err = mmc_read_bkops_status(card);
>  	if (err) {
>  		pr_err("%s: Failed to read bkops status: %d\n",
>  		       mmc_hostname(card->host), err);
> -		return;
> +		goto out;
>  	}
>
>  	if (!card->ext_csd.raw_bkops_status)
> -		return;
> +		goto out;
> +
> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
> +		mmc_hostname(card->host), __func__,
> +		card->ext_csd.raw_bkops_status);
>
> +	/*
> +	 * If the function was called due to exception but there is no need
> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
> +	 * work, before going to suspend
> +	 */
>  	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>  	    from_exception)
> -		return;
> +		goto out;
>
> -	mmc_claim_host(card->host);
>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>  		timeout = MMC_BKOPS_MAX_TIMEOUT;
>  		use_busy_signal = true;
> @@ -309,13 +364,108 @@ void mmc_start_bkops(struct mmc_card *card, bool
> from_exception)
>  	 * bkops executed synchronously, otherwise
>  	 * the operation is in progress
>  	 */
> -	if (!use_busy_signal)
> +	if (!use_busy_signal) {
>  		mmc_card_set_doing_bkops(card);
> +		pr_debug("%s: %s: starting the polling thread\n",
> +			 mmc_hostname(card->host), __func__);
> +		queue_work(system_nrt_wq,
> +			   &card->bkops_info.poll_for_completion);
> +	}
> +
>  out:
>  	mmc_release_host(card->host);
>  }
>  EXPORT_SYMBOL(mmc_start_bkops);
>
> +/**
> + * mmc_bkops_completion_polling() - Poll on the card status to
> + * wait for the non-blocking BKOPS completion
> + * @work:	The completion polling work
> + *
> + * The on-going reading of the card status will prevent the card
> + * from getting into suspend while it is in the middle of
> + * performing BKOPS.
> + * Since the non blocking BKOPS can be interrupted by a fetched
> + * request we also check IF mmc_card_doing_bkops in each
> + * iteration.
> + */
> +void mmc_bkops_completion_polling(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.poll_for_completion);
> +	unsigned long timeout_jiffies = jiffies +
> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
> +	u32 status;
> +	int err;
> +
> +	/*
> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
> +	 * the host from getting into suspend
> +	 */
> +	do {
> +		mmc_claim_host(card->host);
> +
> +		if (!mmc_card_doing_bkops(card))
> +			goto out;
> +
> +		err = mmc_send_status(card, &status);
> +		if (err) {
> +			pr_err("%s: error %d requesting status\n",
> +			       mmc_hostname(card->host), err);
> +			goto out;
> +		}
> +
> +		/*
> +		 * Some cards mishandle the status bits, so make sure to check
> +		 * both the busy indication and the card state.
> +		 */
> +		if ((status & R1_READY_FOR_DATA) &&
> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
> +				 mmc_hostname(card->host), __func__);
> +			mmc_card_clr_doing_bkops(card);
> +			card->bkops_info.started_delayed_bkops = false;
> +			goto out;
> +		}
> +
> +		mmc_release_host(card->host);
> +
> +		/*
> +		 * Sleep before checking the card status again to allow the
> +		 * card to complete the BKOPs operation
> +		 */
> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
> +	} while (time_before(jiffies, timeout_jiffies));
> +
> +	pr_err("%s: %s: exit polling due to timeout\n",
> +	       mmc_hostname(card->host), __func__);
> +
> +	return;
> +out:
> +	mmc_release_host(card->host);
> +}
> +
> +/**
> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
> + * needed
> + * @work:	The idle time BKOPS work
> + */
> +void mmc_start_idle_time_bkops(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.dw.work);
> +
> +	/*
> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
> +	 * BKOPS work in case the delayed work is executed on another CPU
> +	 */
> +	if (card->bkops_info.cancel_delayed_work)
> +		return;
> +
> +	mmc_start_bkops(card, false);
> +}
> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
> +
>  static void mmc_wait_done(struct mmc_request *mrq)
>  {
>  	complete(&mrq->completion);
> @@ -582,6 +732,19 @@ int mmc_stop_bkops(struct mmc_card *card)
>  	int err = 0;
>
>  	BUG_ON(!card);
> +
> +	mmc_claim_host(card->host);
> +
> +	/*
> +	 * Notify the delayed work to be cancelled, in case it was already
> +	 * removed from the queue, but was not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = true;
> +	if (delayed_work_pending(&card->bkops_info.dw))
> +		cancel_delayed_work_sync(&card->bkops_info.dw);
> +	if (!mmc_card_doing_bkops(card))
> +		goto out;
> +
>  	err = mmc_interrupt_hpi(card);
>
>  	/*
> @@ -593,6 +756,8 @@ int mmc_stop_bkops(struct mmc_card *card)
>  		err = 0;
>  	}
>
> +out:
> +	mmc_release_host(card->host);
>  	return err;
>  }
>  EXPORT_SYMBOL(mmc_stop_bkops);
> @@ -2566,15 +2731,13 @@ int mmc_pm_notify(struct notifier_block
> *notify_block,
>  	switch (mode) {
>  	case PM_HIBERNATION_PREPARE:
>  	case PM_SUSPEND_PREPARE:
> -		if (host->card && mmc_card_mmc(host->card) &&
> -		    mmc_card_doing_bkops(host->card)) {
> +		if (host->card && mmc_card_mmc(host->card)) {
>  			err = mmc_stop_bkops(host->card);
>  			if (err) {
>  				pr_err("%s: didn't stop bkops\n",
>  					mmc_hostname(host));
>  				return err;
>  			}
> -			mmc_card_clr_doing_bkops(host->card);
>  		}
>
>  		spin_lock_irqsave(&host->lock, flags);
> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
> index 7509de1..f8ff640 100644
> --- a/drivers/mmc/core/mmc.c
> +++ b/drivers/mmc/core/mmc.c
> @@ -1258,6 +1258,30 @@ static int mmc_init_card(struct mmc_host *host, u32
> ocr,
>  		}
>  	}
>
> +	if (!oldcard) {
> +		if (card->ext_csd.bkops_en) {
> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
> +					  mmc_start_idle_time_bkops);
> +			INIT_WORK(&card->bkops_info.poll_for_completion,
> +				  mmc_bkops_completion_polling);
> +
> +			/*
> +			 * Calculate the time to start the BKOPs checking.
> +			 * The idle time of the host controller should be taken
> +			 * into account in order to prevent a race condition
> +			 * before starting BKOPs and going into suspend.
> +			 * If the host controller didn't set its idle time,
> +			 * a default value is used.
> +			 */
> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
> +			if (card->bkops_info.host_suspend_tout_ms)
> +				card->bkops_info.delay_ms = min(
> +					card->bkops_info.delay_ms,
> +				      card->bkops_info.host_suspend_tout_ms/2);
> +
> +		}
> +	}
> +
>  	if (!oldcard)
>  		host->card = card;
>
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index 78cc3be..0e4d55a 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -207,6 +207,48 @@ struct mmc_part {
>  #define MMC_BLK_DATA_AREA_GP	(1<<2)
>  };
>
> +/**
> + * struct mmc_bkops_info - BKOPS data
> + * @dw:	Idle time bkops delayed work
> + * @host_suspend_tout_ms:	The host controller idle time,
> + * before getting into suspend
> + * @delay_ms:	The time to start the BKOPS
> + *        delayed work once MMC thread is idle
> + * @poll_for_completion:	Poll on BKOPS completion
> + * @cancel_delayed_work: A flag to indicate if the delayed work
> + *        should be cancelled
> + * @started_delayed_bkops:  A flag to indicate if the delayed
> + *        work was scheduled
> + * @sectors_changed:  number of  sectors written or
> + *       discard since the last idle BKOPS were scheduled
> + */
> +struct mmc_bkops_info {
> +	struct delayed_work	dw;
> +	unsigned int		host_suspend_tout_ms;
> +	unsigned int		delay_ms;
> +/*
> + * A default time for checking the need for non urgent BKOPS once mmcqd
> + * is idle.
> + */
> +#define MMC_IDLE_BKOPS_TIME_MS 2000
> +	struct work_struct	poll_for_completion;
> +/* Polling timeout and interval for waiting on non-blocking BKOPs
> completion */
> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
> +	bool			cancel_delayed_work;
> +	bool			started_delayed_bkops;
> +	unsigned int		sectors_changed;
> +/*
> + * Since canceling the delayed work might have significant effect on the
> + * performance of small requests we won't queue the delayed work every
> time
> + * mmcqd thread is idle.
> + * The delayed work for idle BKOPS will be scheduled only after a
> significant
> + * amount of write or discard data.
> + * 100MB is chosen based on benchmark tests.
> + */
> +#define BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK 204800 /* 100MB */
> +};
> +
>  /*
>   * MMC device
>   */
> @@ -281,6 +323,8 @@ struct mmc_card {
>  	struct dentry		*debugfs_root;
>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>  	unsigned int    nr_parts;
> +
> +	struct mmc_bkops_info	bkops_info;
>  };
>
>  /*
> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
> index 9b9cdaf..665d345 100644
> --- a/include/linux/mmc/core.h
> +++ b/include/linux/mmc/core.h
> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
> mmc_card *);
>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>  	struct mmc_command *, int);
>  extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
> bool);
>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>
> --
> 1.7.6
> --
> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
> of Code Aurora Forum, hosted by The Linux Foundation
> --
> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>


-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v2] mmc: core: Add support for idle time BKOPS

[Jaehoon Chung]

Hi Maya,

I'm testing with your patch..but i need to have the more time for testing.
In now, it looks good to me. Thank you for working the idle bkops.

Best Regards,
Jaehoon Chung

> ---
> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
> index 172a768..ed040d5 100644
> --- a/drivers/mmc/card/block.c
> +++ b/drivers/mmc/card/block.c
> @@ -827,6 +827,9 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
>  	from = blk_rq_pos(req);
>  	nr = blk_rq_sectors(req);
>  
> +	if (card->ext_csd.bkops_en)
> +		card->bkops_info.sectors_changed += blk_rq_sectors(req);
using nr?
> +
>  	if (mmc_can_discard(card))
>  		arg = MMC_DISCARD_ARG;
>  	else if (mmc_can_trim(card))
> @@ -1268,6 +1271,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
>  	if (!rqc && !mq->mqrq_prev->req)
>  		return 0;
>  
> +	if (rqc && (card->ext_csd.bkops_en) && (rq_data_dir(rqc) == WRITE))
> +			card->bkops_info.sectors_changed += blk_rq_sectors(rqc);
Fix the indent.
> +
>  	do {
>  		if (rqc) {
>  			/*
> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
> index e360a97..e96f5cf 100644
> --- a/drivers/mmc/card/queue.c
> +++ b/drivers/mmc/card/queue.c
> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>  {
>  	struct mmc_queue *mq = d;
>  	struct request_queue *q = mq->queue;
> +	struct mmc_card *card = mq->card;
>  
>  	current->flags |= PF_MEMALLOC;
>  
> @@ -66,6 +67,17 @@ static int mmc_queue_thread(void *d)
>  		spin_unlock_irq(q->queue_lock);
>  
>  		if (req || mq->mqrq_prev->req) {
> +			/*
> +			 * If this is the first request, BKOPs might be in
> +			 * progress and needs to be stopped before issuing the
> +			 * request
> +			 */
> +			if (card->ext_csd.bkops_en &&
> +			    card->bkops_info.started_delayed_bkops) {
> +				card->bkops_info.started_delayed_bkops = false;
> +				mmc_stop_bkops(card);
if mmc_stop_bkops is failed..?
> +			}
> +
>  			set_current_state(TASK_RUNNING);
>  			mq->issue_fn(mq, req);
>  		} else {
> @@ -73,6 +85,7 @@ static int mmc_queue_thread(void *d)
>  				set_current_state(TASK_RUNNING);
>  				break;
>  			}
> +			mmc_start_delayed_bkops(card);
>  			up(&mq->thread_sem);
>  			schedule();
>  			down(&mq->thread_sem);
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index 6612163..fd8783d 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -253,9 +253,42 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
>  }
>  
>  /**
> + * mmc_start_delayed_bkops() - Start a delayed work to check for
> + *      the need of non urgent BKOPS
> + *
> + * @card: MMC card to start BKOPS on
> + */
> +void mmc_start_delayed_bkops(struct mmc_card *card)
> +{
> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +		return;
> +
> +	if (card->bkops_info.sectors_changed <
> +	    BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK)
> +		return;
> +
> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
> +		 mmc_hostname(card->host), __func__);
> +
> +	card->bkops_info.sectors_changed = 0;
> +
> +	/*
> +	 * cancel_delayed_bkops_work will prevent a race condition between
> +	 * fetching a request by the mmcqd and the delayed work, in case
> +	 * it was removed from the queue work but not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = false;
> +	card->bkops_info.started_delayed_bkops = true;
> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
> +			   msecs_to_jiffies(
> +				   card->bkops_info.delay_ms));
> +}
> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
> +
> +/**
>   *	mmc_start_bkops - start BKOPS for supported cards
>   *	@card: MMC card to start BKOPS
> - *	@form_exception: A flag to indicate if this function was
> + *	@from_exception: A flag to indicate if this function was
>   *			 called due to an exception raised by the card
>   *
>   *	Start background operations whenever requested.
> @@ -269,25 +302,47 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>  	bool use_busy_signal;
>  
>  	BUG_ON(!card);
> -
> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +	if (!card->ext_csd.bkops_en)
>  		return;
>  
> +	mmc_claim_host(card->host);
> +
> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		card->bkops_info.cancel_delayed_work = false;
> +		goto out;
> +	}
> +
> +	if (mmc_card_doing_bkops(card)) {
> +		pr_debug("%s: %s: already doing bkops, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		goto out;
> +	}
> +
>  	err = mmc_read_bkops_status(card);
>  	if (err) {
>  		pr_err("%s: Failed to read bkops status: %d\n",
>  		       mmc_hostname(card->host), err);
> -		return;
> +		goto out;
>  	}
>  
>  	if (!card->ext_csd.raw_bkops_status)
> -		return;
> +		goto out;
> +
> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
> +		mmc_hostname(card->host), __func__,
> +		card->ext_csd.raw_bkops_status);
>  
> +	/*
> +	 * If the function was called due to exception but there is no need
> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
> +	 * work, before going to suspend
> +	 */
>  	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>  	    from_exception)
> -		return;
> +		goto out;
>  
> -	mmc_claim_host(card->host);
>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>  		timeout = MMC_BKOPS_MAX_TIMEOUT;
>  		use_busy_signal = true;
> @@ -309,13 +364,108 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>  	 * bkops executed synchronously, otherwise
>  	 * the operation is in progress
>  	 */
> -	if (!use_busy_signal)
> +	if (!use_busy_signal) {
>  		mmc_card_set_doing_bkops(card);
> +		pr_debug("%s: %s: starting the polling thread\n",
> +			 mmc_hostname(card->host), __func__);
> +		queue_work(system_nrt_wq,
> +			   &card->bkops_info.poll_for_completion);
> +	}
> +
>  out:
>  	mmc_release_host(card->host);
>  }
>  EXPORT_SYMBOL(mmc_start_bkops);
>  
> +/**
> + * mmc_bkops_completion_polling() - Poll on the card status to
> + * wait for the non-blocking BKOPS completion
> + * @work:	The completion polling work
> + *
> + * The on-going reading of the card status will prevent the card
> + * from getting into suspend while it is in the middle of
> + * performing BKOPS.
> + * Since the non blocking BKOPS can be interrupted by a fetched
> + * request we also check IF mmc_card_doing_bkops in each
> + * iteration.
> + */
> +void mmc_bkops_completion_polling(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.poll_for_completion);
> +	unsigned long timeout_jiffies = jiffies +
> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
> +	u32 status;
> +	int err;
> +
> +	/*
> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
> +	 * the host from getting into suspend
> +	 */
> +	do {
> +		mmc_claim_host(card->host);
> +
> +		if (!mmc_card_doing_bkops(card))
> +			goto out;
> +
> +		err = mmc_send_status(card, &status);
> +		if (err) {
> +			pr_err("%s: error %d requesting status\n",
> +			       mmc_hostname(card->host), err);
> +			goto out;
> +		}
> +
> +		/*
> +		 * Some cards mishandle the status bits, so make sure to check
> +		 * both the busy indication and the card state.
> +		 */
> +		if ((status & R1_READY_FOR_DATA) &&
> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
> +				 mmc_hostname(card->host), __func__);
> +			mmc_card_clr_doing_bkops(card);
> +			card->bkops_info.started_delayed_bkops = false;
> +			goto out;
> +		}
> +
> +		mmc_release_host(card->host);
> +
> +		/*
> +		 * Sleep before checking the card status again to allow the
> +		 * card to complete the BKOPs operation
> +		 */
> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
> +	} while (time_before(jiffies, timeout_jiffies));
> +
> +	pr_err("%s: %s: exit polling due to timeout\n",
> +	       mmc_hostname(card->host), __func__);
> +
> +	return;
> +out:
> +	mmc_release_host(card->host);
> +}
> +
> +/**
> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
> + * needed
> + * @work:	The idle time BKOPS work
> + */
> +void mmc_start_idle_time_bkops(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.dw.work);
> +
> +	/*
> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
> +	 * BKOPS work in case the delayed work is executed on another CPU
> +	 */
> +	if (card->bkops_info.cancel_delayed_work)
> +		return;
> +
> +	mmc_start_bkops(card, false);
> +}
> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
> +
>  static void mmc_wait_done(struct mmc_request *mrq)
>  {
>  	complete(&mrq->completion);
> @@ -582,6 +732,19 @@ int mmc_stop_bkops(struct mmc_card *card)
>  	int err = 0;
>  
>  	BUG_ON(!card);
> +
> +	mmc_claim_host(card->host);
> +
> +	/*
> +	 * Notify the delayed work to be cancelled, in case it was already
> +	 * removed from the queue, but was not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = true;
> +	if (delayed_work_pending(&card->bkops_info.dw))
> +		cancel_delayed_work_sync(&card->bkops_info.dw);
> +	if (!mmc_card_doing_bkops(card))
> +		goto out;
> +
>  	err = mmc_interrupt_hpi(card);
>  
>  	/*
> @@ -593,6 +756,8 @@ int mmc_stop_bkops(struct mmc_card *card)
>  		err = 0;
>  	}
>  
> +out:
> +	mmc_release_host(card->host);
>  	return err;
>  }
>  EXPORT_SYMBOL(mmc_stop_bkops);
> @@ -2566,15 +2731,13 @@ int mmc_pm_notify(struct notifier_block *notify_block,
>  	switch (mode) {
>  	case PM_HIBERNATION_PREPARE:
>  	case PM_SUSPEND_PREPARE:
> -		if (host->card && mmc_card_mmc(host->card) &&
> -		    mmc_card_doing_bkops(host->card)) {
> +		if (host->card && mmc_card_mmc(host->card)) {
>  			err = mmc_stop_bkops(host->card);
>  			if (err) {
>  				pr_err("%s: didn't stop bkops\n",
>  					mmc_hostname(host));
>  				return err;
>  			}
> -			mmc_card_clr_doing_bkops(host->card);
>  		}
>  
>  		spin_lock_irqsave(&host->lock, flags);
> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
> index 7509de1..f8ff640 100644
> --- a/drivers/mmc/core/mmc.c
> +++ b/drivers/mmc/core/mmc.c
> @@ -1258,6 +1258,30 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
>  		}
>  	}
>  
> +	if (!oldcard) {
> +		if (card->ext_csd.bkops_en) {
> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
> +					  mmc_start_idle_time_bkops);
> +			INIT_WORK(&card->bkops_info.poll_for_completion,
> +				  mmc_bkops_completion_polling);
> +
> +			/*
> +			 * Calculate the time to start the BKOPs checking.
> +			 * The idle time of the host controller should be taken
> +			 * into account in order to prevent a race condition
> +			 * before starting BKOPs and going into suspend.
> +			 * If the host controller didn't set its idle time,
> +			 * a default value is used.
> +			 */
> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
> +			if (card->bkops_info.host_suspend_tout_ms)
> +				card->bkops_info.delay_ms = min(
> +					card->bkops_info.delay_ms,
> +				      card->bkops_info.host_suspend_tout_ms/2);
> +
> +		}
> +	}
> +
>  	if (!oldcard)
>  		host->card = card;
>  
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index 78cc3be..0e4d55a 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -207,6 +207,48 @@ struct mmc_part {
>  #define MMC_BLK_DATA_AREA_GP	(1<<2)
>  };
>  
> +/**
> + * struct mmc_bkops_info - BKOPS data
> + * @dw:	Idle time bkops delayed work
> + * @host_suspend_tout_ms:	The host controller idle time,
> + * before getting into suspend
> + * @delay_ms:	The time to start the BKOPS
> + *        delayed work once MMC thread is idle
> + * @poll_for_completion:	Poll on BKOPS completion
> + * @cancel_delayed_work: A flag to indicate if the delayed work
> + *        should be cancelled
> + * @started_delayed_bkops:  A flag to indicate if the delayed
> + *        work was scheduled
> + * @sectors_changed:  number of  sectors written or
> + *       discard since the last idle BKOPS were scheduled
> + */
> +struct mmc_bkops_info {
> +	struct delayed_work	dw;
> +	unsigned int		host_suspend_tout_ms;
> +	unsigned int		delay_ms;
> +/*
> + * A default time for checking the need for non urgent BKOPS once mmcqd
> + * is idle.
> + */
> +#define MMC_IDLE_BKOPS_TIME_MS 2000
> +	struct work_struct	poll_for_completion;
> +/* Polling timeout and interval for waiting on non-blocking BKOPs completion */
> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
> +	bool			cancel_delayed_work;
> +	bool			started_delayed_bkops;
> +	unsigned int		sectors_changed;
> +/*
> + * Since canceling the delayed work might have significant effect on the
> + * performance of small requests we won't queue the delayed work every time
> + * mmcqd thread is idle.
> + * The delayed work for idle BKOPS will be scheduled only after a significant
> + * amount of write or discard data.
> + * 100MB is chosen based on benchmark tests.
> + */
> +#define BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK 204800 /* 100MB */
> +};
> +
>  /*
>   * MMC device
>   */
> @@ -281,6 +323,8 @@ struct mmc_card {
>  	struct dentry		*debugfs_root;
>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>  	unsigned int    nr_parts;
> +
> +	struct mmc_bkops_info	bkops_info;
>  };
>  
>  /*
> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
> index 9b9cdaf..665d345 100644
> --- a/include/linux/mmc/core.h
> +++ b/include/linux/mmc/core.h
> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>  	struct mmc_command *, int);
>  extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>  
> 

Re: [PATCH v2] mmc: core: Add support for idle time BKOPS

[merez]

Hi Jaehoon,

Any update on this patch review and testing?

Thanks,
Maya
On Mon, October 15, 2012 11:53 pm, Jaehoon Chung wrote:
> Hi Maya,
>
> I'm testing with your patch..but i need to have the more time for testing.
> In now, it looks good to me. Thank you for working the idle bkops.
>
> Best Regards,
> Jaehoon Chung
>
>> ---
>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>> index 172a768..ed040d5 100644
>> --- a/drivers/mmc/card/block.c
>> +++ b/drivers/mmc/card/block.c
>> @@ -827,6 +827,9 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue
>> *mq, struct request *req)
>>  	from = blk_rq_pos(req);
>>  	nr = blk_rq_sectors(req);
>>
>> +	if (card->ext_csd.bkops_en)
>> +		card->bkops_info.sectors_changed += blk_rq_sectors(req);
> using nr?
>> +
>>  	if (mmc_can_discard(card))
>>  		arg = MMC_DISCARD_ARG;
>>  	else if (mmc_can_trim(card))
>> @@ -1268,6 +1271,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue
>> *mq, struct request *rqc)
>>  	if (!rqc && !mq->mqrq_prev->req)
>>  		return 0;
>>
>> +	if (rqc && (card->ext_csd.bkops_en) && (rq_data_dir(rqc) == WRITE))
>> +			card->bkops_info.sectors_changed += blk_rq_sectors(rqc);
> Fix the indent.
>> +
>>  	do {
>>  		if (rqc) {
>>  			/*
>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>> index e360a97..e96f5cf 100644
>> --- a/drivers/mmc/card/queue.c
>> +++ b/drivers/mmc/card/queue.c
>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>  {
>>  	struct mmc_queue *mq = d;
>>  	struct request_queue *q = mq->queue;
>> +	struct mmc_card *card = mq->card;
>>
>>  	current->flags |= PF_MEMALLOC;
>>
>> @@ -66,6 +67,17 @@ static int mmc_queue_thread(void *d)
>>  		spin_unlock_irq(q->queue_lock);
>>
>>  		if (req || mq->mqrq_prev->req) {
>> +			/*
>> +			 * If this is the first request, BKOPs might be in
>> +			 * progress and needs to be stopped before issuing the
>> +			 * request
>> +			 */
>> +			if (card->ext_csd.bkops_en &&
>> +			    card->bkops_info.started_delayed_bkops) {
>> +				card->bkops_info.started_delayed_bkops = false;
>> +				mmc_stop_bkops(card);
> if mmc_stop_bkops is failed..?
>> +			}
>> +
>>  			set_current_state(TASK_RUNNING);
>>  			mq->issue_fn(mq, req);
>>  		} else {
>> @@ -73,6 +85,7 @@ static int mmc_queue_thread(void *d)
>>  				set_current_state(TASK_RUNNING);
>>  				break;
>>  			}
>> +			mmc_start_delayed_bkops(card);
>>  			up(&mq->thread_sem);
>>  			schedule();
>>  			down(&mq->thread_sem);
>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>> index 6612163..fd8783d 100644
>> --- a/drivers/mmc/core/core.c
>> +++ b/drivers/mmc/core/core.c
>> @@ -253,9 +253,42 @@ mmc_start_request(struct mmc_host *host, struct
>> mmc_request *mrq)
>>  }
>>
>>  /**
>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>> + *      the need of non urgent BKOPS
>> + *
>> + * @card: MMC card to start BKOPS on
>> + */
>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>> +{
>> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>> +		return;
>> +
>> +	if (card->bkops_info.sectors_changed <
>> +	    BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK)
>> +		return;
>> +
>> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
>> +		 mmc_hostname(card->host), __func__);
>> +
>> +	card->bkops_info.sectors_changed = 0;
>> +
>> +	/*
>> +	 * cancel_delayed_bkops_work will prevent a race condition between
>> +	 * fetching a request by the mmcqd and the delayed work, in case
>> +	 * it was removed from the queue work but not started yet
>> +	 */
>> +	card->bkops_info.cancel_delayed_work = false;
>> +	card->bkops_info.started_delayed_bkops = true;
>> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>> +			   msecs_to_jiffies(
>> +				   card->bkops_info.delay_ms));
>> +}
>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>> +
>> +/**
>>   *	mmc_start_bkops - start BKOPS for supported cards
>>   *	@card: MMC card to start BKOPS
>> - *	@form_exception: A flag to indicate if this function was
>> + *	@from_exception: A flag to indicate if this function was
>>   *			 called due to an exception raised by the card
>>   *
>>   *	Start background operations whenever requested.
>> @@ -269,25 +302,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception)
>>  	bool use_busy_signal;
>>
>>  	BUG_ON(!card);
>> -
>> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>> +	if (!card->ext_csd.bkops_en)
>>  		return;
>>
>> +	mmc_claim_host(card->host);
>> +
>> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
>> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>> +			 mmc_hostname(card->host), __func__);
>> +		card->bkops_info.cancel_delayed_work = false;
>> +		goto out;
>> +	}
>> +
>> +	if (mmc_card_doing_bkops(card)) {
>> +		pr_debug("%s: %s: already doing bkops, exit\n",
>> +			 mmc_hostname(card->host), __func__);
>> +		goto out;
>> +	}
>> +
>>  	err = mmc_read_bkops_status(card);
>>  	if (err) {
>>  		pr_err("%s: Failed to read bkops status: %d\n",
>>  		       mmc_hostname(card->host), err);
>> -		return;
>> +		goto out;
>>  	}
>>
>>  	if (!card->ext_csd.raw_bkops_status)
>> -		return;
>> +		goto out;
>> +
>> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>> +		mmc_hostname(card->host), __func__,
>> +		card->ext_csd.raw_bkops_status);
>>
>> +	/*
>> +	 * If the function was called due to exception but there is no need
>> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
>> +	 * work, before going to suspend
>> +	 */
>>  	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>  	    from_exception)
>> -		return;
>> +		goto out;
>>
>> -	mmc_claim_host(card->host);
>>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>  		timeout = MMC_BKOPS_MAX_TIMEOUT;
>>  		use_busy_signal = true;
>> @@ -309,13 +364,108 @@ void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception)
>>  	 * bkops executed synchronously, otherwise
>>  	 * the operation is in progress
>>  	 */
>> -	if (!use_busy_signal)
>> +	if (!use_busy_signal) {
>>  		mmc_card_set_doing_bkops(card);
>> +		pr_debug("%s: %s: starting the polling thread\n",
>> +			 mmc_hostname(card->host), __func__);
>> +		queue_work(system_nrt_wq,
>> +			   &card->bkops_info.poll_for_completion);
>> +	}
>> +
>>  out:
>>  	mmc_release_host(card->host);
>>  }
>>  EXPORT_SYMBOL(mmc_start_bkops);
>>
>> +/**
>> + * mmc_bkops_completion_polling() - Poll on the card status to
>> + * wait for the non-blocking BKOPS completion
>> + * @work:	The completion polling work
>> + *
>> + * The on-going reading of the card status will prevent the card
>> + * from getting into suspend while it is in the middle of
>> + * performing BKOPS.
>> + * Since the non blocking BKOPS can be interrupted by a fetched
>> + * request we also check IF mmc_card_doing_bkops in each
>> + * iteration.
>> + */
>> +void mmc_bkops_completion_polling(struct work_struct *work)
>> +{
>> +	struct mmc_card *card = container_of(work, struct mmc_card,
>> +			bkops_info.poll_for_completion);
>> +	unsigned long timeout_jiffies = jiffies +
>> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>> +	u32 status;
>> +	int err;
>> +
>> +	/*
>> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
>> +	 * the host from getting into suspend
>> +	 */
>> +	do {
>> +		mmc_claim_host(card->host);
>> +
>> +		if (!mmc_card_doing_bkops(card))
>> +			goto out;
>> +
>> +		err = mmc_send_status(card, &status);
>> +		if (err) {
>> +			pr_err("%s: error %d requesting status\n",
>> +			       mmc_hostname(card->host), err);
>> +			goto out;
>> +		}
>> +
>> +		/*
>> +		 * Some cards mishandle the status bits, so make sure to check
>> +		 * both the busy indication and the card state.
>> +		 */
>> +		if ((status & R1_READY_FOR_DATA) &&
>> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
>> +				 mmc_hostname(card->host), __func__);
>> +			mmc_card_clr_doing_bkops(card);
>> +			card->bkops_info.started_delayed_bkops = false;
>> +			goto out;
>> +		}
>> +
>> +		mmc_release_host(card->host);
>> +
>> +		/*
>> +		 * Sleep before checking the card status again to allow the
>> +		 * card to complete the BKOPs operation
>> +		 */
>> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>> +	} while (time_before(jiffies, timeout_jiffies));
>> +
>> +	pr_err("%s: %s: exit polling due to timeout\n",
>> +	       mmc_hostname(card->host), __func__);
>> +
>> +	return;
>> +out:
>> +	mmc_release_host(card->host);
>> +}
>> +
>> +/**
>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>> + * needed
>> + * @work:	The idle time BKOPS work
>> + */
>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>> +{
>> +	struct mmc_card *card = container_of(work, struct mmc_card,
>> +			bkops_info.dw.work);
>> +
>> +	/*
>> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
>> +	 * BKOPS work in case the delayed work is executed on another CPU
>> +	 */
>> +	if (card->bkops_info.cancel_delayed_work)
>> +		return;
>> +
>> +	mmc_start_bkops(card, false);
>> +}
>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>> +
>>  static void mmc_wait_done(struct mmc_request *mrq)
>>  {
>>  	complete(&mrq->completion);
>> @@ -582,6 +732,19 @@ int mmc_stop_bkops(struct mmc_card *card)
>>  	int err = 0;
>>
>>  	BUG_ON(!card);
>> +
>> +	mmc_claim_host(card->host);
>> +
>> +	/*
>> +	 * Notify the delayed work to be cancelled, in case it was already
>> +	 * removed from the queue, but was not started yet
>> +	 */
>> +	card->bkops_info.cancel_delayed_work = true;
>> +	if (delayed_work_pending(&card->bkops_info.dw))
>> +		cancel_delayed_work_sync(&card->bkops_info.dw);
>> +	if (!mmc_card_doing_bkops(card))
>> +		goto out;
>> +
>>  	err = mmc_interrupt_hpi(card);
>>
>>  	/*
>> @@ -593,6 +756,8 @@ int mmc_stop_bkops(struct mmc_card *card)
>>  		err = 0;
>>  	}
>>
>> +out:
>> +	mmc_release_host(card->host);
>>  	return err;
>>  }
>>  EXPORT_SYMBOL(mmc_stop_bkops);
>> @@ -2566,15 +2731,13 @@ int mmc_pm_notify(struct notifier_block
>> *notify_block,
>>  	switch (mode) {
>>  	case PM_HIBERNATION_PREPARE:
>>  	case PM_SUSPEND_PREPARE:
>> -		if (host->card && mmc_card_mmc(host->card) &&
>> -		    mmc_card_doing_bkops(host->card)) {
>> +		if (host->card && mmc_card_mmc(host->card)) {
>>  			err = mmc_stop_bkops(host->card);
>>  			if (err) {
>>  				pr_err("%s: didn't stop bkops\n",
>>  					mmc_hostname(host));
>>  				return err;
>>  			}
>> -			mmc_card_clr_doing_bkops(host->card);
>>  		}
>>
>>  		spin_lock_irqsave(&host->lock, flags);
>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>> index 7509de1..f8ff640 100644
>> --- a/drivers/mmc/core/mmc.c
>> +++ b/drivers/mmc/core/mmc.c
>> @@ -1258,6 +1258,30 @@ static int mmc_init_card(struct mmc_host *host,
>> u32 ocr,
>>  		}
>>  	}
>>
>> +	if (!oldcard) {
>> +		if (card->ext_csd.bkops_en) {
>> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
>> +					  mmc_start_idle_time_bkops);
>> +			INIT_WORK(&card->bkops_info.poll_for_completion,
>> +				  mmc_bkops_completion_polling);
>> +
>> +			/*
>> +			 * Calculate the time to start the BKOPs checking.
>> +			 * The idle time of the host controller should be taken
>> +			 * into account in order to prevent a race condition
>> +			 * before starting BKOPs and going into suspend.
>> +			 * If the host controller didn't set its idle time,
>> +			 * a default value is used.
>> +			 */
>> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
>> +			if (card->bkops_info.host_suspend_tout_ms)
>> +				card->bkops_info.delay_ms = min(
>> +					card->bkops_info.delay_ms,
>> +				      card->bkops_info.host_suspend_tout_ms/2);
>> +
>> +		}
>> +	}
>> +
>>  	if (!oldcard)
>>  		host->card = card;
>>
>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>> index 78cc3be..0e4d55a 100644
>> --- a/include/linux/mmc/card.h
>> +++ b/include/linux/mmc/card.h
>> @@ -207,6 +207,48 @@ struct mmc_part {
>>  #define MMC_BLK_DATA_AREA_GP	(1<<2)
>>  };
>>
>> +/**
>> + * struct mmc_bkops_info - BKOPS data
>> + * @dw:	Idle time bkops delayed work
>> + * @host_suspend_tout_ms:	The host controller idle time,
>> + * before getting into suspend
>> + * @delay_ms:	The time to start the BKOPS
>> + *        delayed work once MMC thread is idle
>> + * @poll_for_completion:	Poll on BKOPS completion
>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>> + *        should be cancelled
>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>> + *        work was scheduled
>> + * @sectors_changed:  number of  sectors written or
>> + *       discard since the last idle BKOPS were scheduled
>> + */
>> +struct mmc_bkops_info {
>> +	struct delayed_work	dw;
>> +	unsigned int		host_suspend_tout_ms;
>> +	unsigned int		delay_ms;
>> +/*
>> + * A default time for checking the need for non urgent BKOPS once mmcqd
>> + * is idle.
>> + */
>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>> +	struct work_struct	poll_for_completion;
>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>> completion */
>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>> +	bool			cancel_delayed_work;
>> +	bool			started_delayed_bkops;
>> +	unsigned int		sectors_changed;
>> +/*
>> + * Since canceling the delayed work might have significant effect on
>> the
>> + * performance of small requests we won't queue the delayed work every
>> time
>> + * mmcqd thread is idle.
>> + * The delayed work for idle BKOPS will be scheduled only after a
>> significant
>> + * amount of write or discard data.
>> + * 100MB is chosen based on benchmark tests.
>> + */
>> +#define BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK 204800 /* 100MB */
>> +};
>> +
>>  /*
>>   * MMC device
>>   */
>> @@ -281,6 +323,8 @@ struct mmc_card {
>>  	struct dentry		*debugfs_root;
>>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>>  	unsigned int    nr_parts;
>> +
>> +	struct mmc_bkops_info	bkops_info;
>>  };
>>
>>  /*
>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>> index 9b9cdaf..665d345 100644
>> --- a/include/linux/mmc/core.h
>> +++ b/include/linux/mmc/core.h
>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>> mmc_card *);
>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>>  	struct mmc_command *, int);
>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception);
>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
>> bool);
>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>
>>
>
>


-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v2] mmc: core: Add support for idle time BKOPS

[Jaehoon Chung]

Hi Maya, 

I tested with dw-mmc controller.
It's look good to me.

Tested-by: Jaehoon Chung <jh80.chung@samsung.com>

On 11/07/2012 01:28 PM, merez@codeaurora.org wrote:
> Hi Jaehoon,
> 
> Any update on this patch review and testing?
> 
> Thanks,
> Maya
> On Mon, October 15, 2012 11:53 pm, Jaehoon Chung wrote:
>> Hi Maya,
>>
>> I'm testing with your patch..but i need to have the more time for testing.
>> In now, it looks good to me. Thank you for working the idle bkops.
>>
>> Best Regards,
>> Jaehoon Chung
>>
>>> ---
>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>> index 172a768..ed040d5 100644
>>> --- a/drivers/mmc/card/block.c
>>> +++ b/drivers/mmc/card/block.c
>>> @@ -827,6 +827,9 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue
>>> *mq, struct request *req)
>>>  	from = blk_rq_pos(req);
>>>  	nr = blk_rq_sectors(req);
>>>
>>> +	if (card->ext_csd.bkops_en)
>>> +		card->bkops_info.sectors_changed += blk_rq_sectors(req);
>> using nr?
>>> +
>>>  	if (mmc_can_discard(card))
>>>  		arg = MMC_DISCARD_ARG;
>>>  	else if (mmc_can_trim(card))
>>> @@ -1268,6 +1271,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue
>>> *mq, struct request *rqc)
>>>  	if (!rqc && !mq->mqrq_prev->req)
>>>  		return 0;
>>>
>>> +	if (rqc && (card->ext_csd.bkops_en) && (rq_data_dir(rqc) == WRITE))
>>> +			card->bkops_info.sectors_changed += blk_rq_sectors(rqc);
>> Fix the indent.
>>> +
>>>  	do {
>>>  		if (rqc) {
>>>  			/*
>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>> index e360a97..e96f5cf 100644
>>> --- a/drivers/mmc/card/queue.c
>>> +++ b/drivers/mmc/card/queue.c
>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>>  {
>>>  	struct mmc_queue *mq = d;
>>>  	struct request_queue *q = mq->queue;
>>> +	struct mmc_card *card = mq->card;
>>>
>>>  	current->flags |= PF_MEMALLOC;
>>>
>>> @@ -66,6 +67,17 @@ static int mmc_queue_thread(void *d)
>>>  		spin_unlock_irq(q->queue_lock);
>>>
>>>  		if (req || mq->mqrq_prev->req) {
>>> +			/*
>>> +			 * If this is the first request, BKOPs might be in
>>> +			 * progress and needs to be stopped before issuing the
>>> +			 * request
>>> +			 */
>>> +			if (card->ext_csd.bkops_en &&
>>> +			    card->bkops_info.started_delayed_bkops) {
>>> +				card->bkops_info.started_delayed_bkops = false;
>>> +				mmc_stop_bkops(card);
>> if mmc_stop_bkops is failed..?
>>> +			}
>>> +
>>>  			set_current_state(TASK_RUNNING);
>>>  			mq->issue_fn(mq, req);
>>>  		} else {
>>> @@ -73,6 +85,7 @@ static int mmc_queue_thread(void *d)
>>>  				set_current_state(TASK_RUNNING);
>>>  				break;
>>>  			}
>>> +			mmc_start_delayed_bkops(card);
>>>  			up(&mq->thread_sem);
>>>  			schedule();
>>>  			down(&mq->thread_sem);
>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>> index 6612163..fd8783d 100644
>>> --- a/drivers/mmc/core/core.c
>>> +++ b/drivers/mmc/core/core.c
>>> @@ -253,9 +253,42 @@ mmc_start_request(struct mmc_host *host, struct
>>> mmc_request *mrq)
>>>  }
>>>
>>>  /**
>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>> + *      the need of non urgent BKOPS
>>> + *
>>> + * @card: MMC card to start BKOPS on
>>> + */
>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>> +{
>>> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>> +		return;
>>> +
>>> +	if (card->bkops_info.sectors_changed <
>>> +	    BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK)
>>> +		return;
>>> +
>>> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>> +		 mmc_hostname(card->host), __func__);
>>> +
>>> +	card->bkops_info.sectors_changed = 0;
>>> +
>>> +	/*
>>> +	 * cancel_delayed_bkops_work will prevent a race condition between
>>> +	 * fetching a request by the mmcqd and the delayed work, in case
>>> +	 * it was removed from the queue work but not started yet
>>> +	 */
>>> +	card->bkops_info.cancel_delayed_work = false;
>>> +	card->bkops_info.started_delayed_bkops = true;
>>> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>> +			   msecs_to_jiffies(
>>> +				   card->bkops_info.delay_ms));
>>> +}
>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>> +
>>> +/**
>>>   *	mmc_start_bkops - start BKOPS for supported cards
>>>   *	@card: MMC card to start BKOPS
>>> - *	@form_exception: A flag to indicate if this function was
>>> + *	@from_exception: A flag to indicate if this function was
>>>   *			 called due to an exception raised by the card
>>>   *
>>>   *	Start background operations whenever requested.
>>> @@ -269,25 +302,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
>>> from_exception)
>>>  	bool use_busy_signal;
>>>
>>>  	BUG_ON(!card);
>>> -
>>> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>> +	if (!card->ext_csd.bkops_en)
>>>  		return;
>>>
>>> +	mmc_claim_host(card->host);
>>> +
>>> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
>>> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>> +			 mmc_hostname(card->host), __func__);
>>> +		card->bkops_info.cancel_delayed_work = false;
>>> +		goto out;
>>> +	}
>>> +
>>> +	if (mmc_card_doing_bkops(card)) {
>>> +		pr_debug("%s: %s: already doing bkops, exit\n",
>>> +			 mmc_hostname(card->host), __func__);
>>> +		goto out;
>>> +	}
>>> +
>>>  	err = mmc_read_bkops_status(card);
>>>  	if (err) {
>>>  		pr_err("%s: Failed to read bkops status: %d\n",
>>>  		       mmc_hostname(card->host), err);
>>> -		return;
>>> +		goto out;
>>>  	}
>>>
>>>  	if (!card->ext_csd.raw_bkops_status)
>>> -		return;
>>> +		goto out;
>>> +
>>> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>> +		mmc_hostname(card->host), __func__,
>>> +		card->ext_csd.raw_bkops_status);
>>>
>>> +	/*
>>> +	 * If the function was called due to exception but there is no need
>>> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
>>> +	 * work, before going to suspend
>>> +	 */
>>>  	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>  	    from_exception)
>>> -		return;
>>> +		goto out;
>>>
>>> -	mmc_claim_host(card->host);
>>>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>  		timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>  		use_busy_signal = true;
>>> @@ -309,13 +364,108 @@ void mmc_start_bkops(struct mmc_card *card, bool
>>> from_exception)
>>>  	 * bkops executed synchronously, otherwise
>>>  	 * the operation is in progress
>>>  	 */
>>> -	if (!use_busy_signal)
>>> +	if (!use_busy_signal) {
>>>  		mmc_card_set_doing_bkops(card);
>>> +		pr_debug("%s: %s: starting the polling thread\n",
>>> +			 mmc_hostname(card->host), __func__);
>>> +		queue_work(system_nrt_wq,
>>> +			   &card->bkops_info.poll_for_completion);
>>> +	}
>>> +
>>>  out:
>>>  	mmc_release_host(card->host);
>>>  }
>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>
>>> +/**
>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>> + * wait for the non-blocking BKOPS completion
>>> + * @work:	The completion polling work
>>> + *
>>> + * The on-going reading of the card status will prevent the card
>>> + * from getting into suspend while it is in the middle of
>>> + * performing BKOPS.
>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>> + * request we also check IF mmc_card_doing_bkops in each
>>> + * iteration.
>>> + */
>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>> +{
>>> +	struct mmc_card *card = container_of(work, struct mmc_card,
>>> +			bkops_info.poll_for_completion);
>>> +	unsigned long timeout_jiffies = jiffies +
>>> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>> +	u32 status;
>>> +	int err;
>>> +
>>> +	/*
>>> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
>>> +	 * the host from getting into suspend
>>> +	 */
>>> +	do {
>>> +		mmc_claim_host(card->host);
>>> +
>>> +		if (!mmc_card_doing_bkops(card))
>>> +			goto out;
>>> +
>>> +		err = mmc_send_status(card, &status);
>>> +		if (err) {
>>> +			pr_err("%s: error %d requesting status\n",
>>> +			       mmc_hostname(card->host), err);
>>> +			goto out;
>>> +		}
>>> +
>>> +		/*
>>> +		 * Some cards mishandle the status bits, so make sure to check
>>> +		 * both the busy indication and the card state.
>>> +		 */
>>> +		if ((status & R1_READY_FOR_DATA) &&
>>> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
>>> +				 mmc_hostname(card->host), __func__);
>>> +			mmc_card_clr_doing_bkops(card);
>>> +			card->bkops_info.started_delayed_bkops = false;
>>> +			goto out;
>>> +		}
>>> +
>>> +		mmc_release_host(card->host);
>>> +
>>> +		/*
>>> +		 * Sleep before checking the card status again to allow the
>>> +		 * card to complete the BKOPs operation
>>> +		 */
>>> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>> +	} while (time_before(jiffies, timeout_jiffies));
>>> +
>>> +	pr_err("%s: %s: exit polling due to timeout\n",
>>> +	       mmc_hostname(card->host), __func__);
>>> +
>>> +	return;
>>> +out:
>>> +	mmc_release_host(card->host);
>>> +}
>>> +
>>> +/**
>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>> + * needed
>>> + * @work:	The idle time BKOPS work
>>> + */
>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>> +{
>>> +	struct mmc_card *card = container_of(work, struct mmc_card,
>>> +			bkops_info.dw.work);
>>> +
>>> +	/*
>>> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
>>> +	 * BKOPS work in case the delayed work is executed on another CPU
>>> +	 */
>>> +	if (card->bkops_info.cancel_delayed_work)
>>> +		return;
>>> +
>>> +	mmc_start_bkops(card, false);
>>> +}
>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>> +
>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>  {
>>>  	complete(&mrq->completion);
>>> @@ -582,6 +732,19 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>  	int err = 0;
>>>
>>>  	BUG_ON(!card);
>>> +
>>> +	mmc_claim_host(card->host);
>>> +
>>> +	/*
>>> +	 * Notify the delayed work to be cancelled, in case it was already
>>> +	 * removed from the queue, but was not started yet
>>> +	 */
>>> +	card->bkops_info.cancel_delayed_work = true;
>>> +	if (delayed_work_pending(&card->bkops_info.dw))
>>> +		cancel_delayed_work_sync(&card->bkops_info.dw);
>>> +	if (!mmc_card_doing_bkops(card))
>>> +		goto out;
>>> +
>>>  	err = mmc_interrupt_hpi(card);
>>>
>>>  	/*
>>> @@ -593,6 +756,8 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>  		err = 0;
>>>  	}
>>>
>>> +out:
>>> +	mmc_release_host(card->host);
>>>  	return err;
>>>  }
>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>> @@ -2566,15 +2731,13 @@ int mmc_pm_notify(struct notifier_block
>>> *notify_block,
>>>  	switch (mode) {
>>>  	case PM_HIBERNATION_PREPARE:
>>>  	case PM_SUSPEND_PREPARE:
>>> -		if (host->card && mmc_card_mmc(host->card) &&
>>> -		    mmc_card_doing_bkops(host->card)) {
>>> +		if (host->card && mmc_card_mmc(host->card)) {
>>>  			err = mmc_stop_bkops(host->card);
>>>  			if (err) {
>>>  				pr_err("%s: didn't stop bkops\n",
>>>  					mmc_hostname(host));
>>>  				return err;
>>>  			}
>>> -			mmc_card_clr_doing_bkops(host->card);
>>>  		}
>>>
>>>  		spin_lock_irqsave(&host->lock, flags);
>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>> index 7509de1..f8ff640 100644
>>> --- a/drivers/mmc/core/mmc.c
>>> +++ b/drivers/mmc/core/mmc.c
>>> @@ -1258,6 +1258,30 @@ static int mmc_init_card(struct mmc_host *host,
>>> u32 ocr,
>>>  		}
>>>  	}
>>>
>>> +	if (!oldcard) {
>>> +		if (card->ext_csd.bkops_en) {
>>> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
>>> +					  mmc_start_idle_time_bkops);
>>> +			INIT_WORK(&card->bkops_info.poll_for_completion,
>>> +				  mmc_bkops_completion_polling);
>>> +
>>> +			/*
>>> +			 * Calculate the time to start the BKOPs checking.
>>> +			 * The idle time of the host controller should be taken
>>> +			 * into account in order to prevent a race condition
>>> +			 * before starting BKOPs and going into suspend.
>>> +			 * If the host controller didn't set its idle time,
>>> +			 * a default value is used.
>>> +			 */
>>> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
>>> +			if (card->bkops_info.host_suspend_tout_ms)
>>> +				card->bkops_info.delay_ms = min(
>>> +					card->bkops_info.delay_ms,
>>> +				      card->bkops_info.host_suspend_tout_ms/2);
>>> +
>>> +		}
>>> +	}
>>> +
>>>  	if (!oldcard)
>>>  		host->card = card;
>>>
>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>> index 78cc3be..0e4d55a 100644
>>> --- a/include/linux/mmc/card.h
>>> +++ b/include/linux/mmc/card.h
>>> @@ -207,6 +207,48 @@ struct mmc_part {
>>>  #define MMC_BLK_DATA_AREA_GP	(1<<2)
>>>  };
>>>
>>> +/**
>>> + * struct mmc_bkops_info - BKOPS data
>>> + * @dw:	Idle time bkops delayed work
>>> + * @host_suspend_tout_ms:	The host controller idle time,
>>> + * before getting into suspend
>>> + * @delay_ms:	The time to start the BKOPS
>>> + *        delayed work once MMC thread is idle
>>> + * @poll_for_completion:	Poll on BKOPS completion
>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>> + *        should be cancelled
>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>> + *        work was scheduled
>>> + * @sectors_changed:  number of  sectors written or
>>> + *       discard since the last idle BKOPS were scheduled
>>> + */
>>> +struct mmc_bkops_info {
>>> +	struct delayed_work	dw;
>>> +	unsigned int		host_suspend_tout_ms;
>>> +	unsigned int		delay_ms;
>>> +/*
>>> + * A default time for checking the need for non urgent BKOPS once mmcqd
>>> + * is idle.
>>> + */
>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>> +	struct work_struct	poll_for_completion;
>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>> completion */
>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>> +	bool			cancel_delayed_work;
>>> +	bool			started_delayed_bkops;
>>> +	unsigned int		sectors_changed;
>>> +/*
>>> + * Since canceling the delayed work might have significant effect on
>>> the
>>> + * performance of small requests we won't queue the delayed work every
>>> time
>>> + * mmcqd thread is idle.
>>> + * The delayed work for idle BKOPS will be scheduled only after a
>>> significant
>>> + * amount of write or discard data.
>>> + * 100MB is chosen based on benchmark tests.
>>> + */
>>> +#define BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK 204800 /* 100MB */
>>> +};
>>> +
>>>  /*
>>>   * MMC device
>>>   */
>>> @@ -281,6 +323,8 @@ struct mmc_card {
>>>  	struct dentry		*debugfs_root;
>>>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>>>  	unsigned int    nr_parts;
>>> +
>>> +	struct mmc_bkops_info	bkops_info;
>>>  };
>>>
>>>  /*
>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>> index 9b9cdaf..665d345 100644
>>> --- a/include/linux/mmc/core.h
>>> +++ b/include/linux/mmc/core.h
>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>> mmc_card *);
>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>>>  	struct mmc_command *, int);
>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>> from_exception);
>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
>>> bool);
>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>
>>>
>>
>>
> 
> 

Re: [PATCH v2] mmc: core: Add support for idle time BKOPS

[Subhash Jadavani]

Thanks Maya. Looks good to me.
Reviewed-by: subhashj@codeaurora.org

Regards,
Subhash

On 10/5/2012 3:58 AM, Maya Erez wrote:
> Devices have various maintenance operations need to perform internally.
> In order to reduce latencies during time critical operations like read
> and write, it is better to execute maintenance operations in other
> times - when the host is not being serviced. Such operations are called
> Background operations (BKOPS).
> The device notifies the status of the BKOPS need by updating BKOPS_STATUS
> (EXT_CSD byte [246]).
>
> According to the standard a host that supports BKOPS shall check the
> status periodically and start background operations as needed, so that
> the device has enough time for its maintenance operations.
>
> This patch adds support for this periodic check of the BKOPS status.
> Since foreground operations are of higher priority than background
> operations the host will check the need for BKOPS when it is idle,
> and in case of an incoming request the BKOPS operation will be
> interrupted.
>
> When the mmcqd thread is idle, a delayed work is created to check the
> need for BKOPS. The time to start the delayed work is calculated based
> on the host controller suspend timeout, in case it was set. If not, a
> default time is used.
> If BKOPS are required in level 1, which is non-blocking, there will be
> polling of the card status to wait for the BKOPS completion and prevent
> suspend that will interrupt the BKOPS.
> If the card raised an exception, the need for urgent BKOPS (level 2/3)
> will be checked immediately and if needed, the BKOPS will be performed
> without waiting for the next idle time.
>
> Signed-off-by: Maya Erez <merez@codeaurora.org>
> Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
> ---
> This patch is based on the periodic BKOPS implementation in version 8 of "support BKOPS feature for eMMC" patch.
> The patch was modified to answer the following issues:
> - In order to prevent a race condition between going into suspend and starting BKOPS,
>    the suspend timeout of the host controller is taking into accound in determination of the start time
>    of the delayed work
> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host was moved to the beginning of the function
> - Also, the check of doing_bkops should be protected when determing if an HPI is needed due to the same reason.
> - Starting and canceling the delayed work in each idle caused degradation of iozone performance. Therefore,
>    the delayed work is not started on each idle. The amount of sectors changed (written or discard) from the last
>    delayed work is the trigger for starting the delayed BKOPS work.
> ---
> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
> index 172a768..ed040d5 100644
> --- a/drivers/mmc/card/block.c
> +++ b/drivers/mmc/card/block.c
> @@ -827,6 +827,9 @@ static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
>   	from = blk_rq_pos(req);
>   	nr = blk_rq_sectors(req);
>   
> +	if (card->ext_csd.bkops_en)
> +		card->bkops_info.sectors_changed += blk_rq_sectors(req);
> +
>   	if (mmc_can_discard(card))
>   		arg = MMC_DISCARD_ARG;
>   	else if (mmc_can_trim(card))
> @@ -1268,6 +1271,9 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
>   	if (!rqc && !mq->mqrq_prev->req)
>   		return 0;
>   
> +	if (rqc && (card->ext_csd.bkops_en) && (rq_data_dir(rqc) == WRITE))
> +			card->bkops_info.sectors_changed += blk_rq_sectors(rqc);
> +
>   	do {
>   		if (rqc) {
>   			/*
> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
> index e360a97..e96f5cf 100644
> --- a/drivers/mmc/card/queue.c
> +++ b/drivers/mmc/card/queue.c
> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>   {
>   	struct mmc_queue *mq = d;
>   	struct request_queue *q = mq->queue;
> +	struct mmc_card *card = mq->card;
>   
>   	current->flags |= PF_MEMALLOC;
>   
> @@ -66,6 +67,17 @@ static int mmc_queue_thread(void *d)
>   		spin_unlock_irq(q->queue_lock);
>   
>   		if (req || mq->mqrq_prev->req) {
> +			/*
> +			 * If this is the first request, BKOPs might be in
> +			 * progress and needs to be stopped before issuing the
> +			 * request
> +			 */
> +			if (card->ext_csd.bkops_en &&
> +			    card->bkops_info.started_delayed_bkops) {
> +				card->bkops_info.started_delayed_bkops = false;
> +				mmc_stop_bkops(card);
> +			}
> +
>   			set_current_state(TASK_RUNNING);
>   			mq->issue_fn(mq, req);
>   		} else {
> @@ -73,6 +85,7 @@ static int mmc_queue_thread(void *d)
>   				set_current_state(TASK_RUNNING);
>   				break;
>   			}
> +			mmc_start_delayed_bkops(card);
>   			up(&mq->thread_sem);
>   			schedule();
>   			down(&mq->thread_sem);
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index 6612163..fd8783d 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -253,9 +253,42 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
>   }
>   
>   /**
> + * mmc_start_delayed_bkops() - Start a delayed work to check for
> + *      the need of non urgent BKOPS
> + *
> + * @card: MMC card to start BKOPS on
> + */
> +void mmc_start_delayed_bkops(struct mmc_card *card)
> +{
> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +		return;
> +
> +	if (card->bkops_info.sectors_changed <
> +	    BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK)
> +		return;
> +
> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
> +		 mmc_hostname(card->host), __func__);
> +
> +	card->bkops_info.sectors_changed = 0;
> +
> +	/*
> +	 * cancel_delayed_bkops_work will prevent a race condition between
> +	 * fetching a request by the mmcqd and the delayed work, in case
> +	 * it was removed from the queue work but not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = false;
> +	card->bkops_info.started_delayed_bkops = true;
> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
> +			   msecs_to_jiffies(
> +				   card->bkops_info.delay_ms));
> +}
> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
> +
> +/**
>    *	mmc_start_bkops - start BKOPS for supported cards
>    *	@card: MMC card to start BKOPS
> - *	@form_exception: A flag to indicate if this function was
> + *	@from_exception: A flag to indicate if this function was
>    *			 called due to an exception raised by the card
>    *
>    *	Start background operations whenever requested.
> @@ -269,25 +302,47 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>   	bool use_busy_signal;
>   
>   	BUG_ON(!card);
> -
> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +	if (!card->ext_csd.bkops_en)
>   		return;
>   
> +	mmc_claim_host(card->host);
> +
> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		card->bkops_info.cancel_delayed_work = false;
> +		goto out;
> +	}
> +
> +	if (mmc_card_doing_bkops(card)) {
> +		pr_debug("%s: %s: already doing bkops, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		goto out;
> +	}
> +
>   	err = mmc_read_bkops_status(card);
>   	if (err) {
>   		pr_err("%s: Failed to read bkops status: %d\n",
>   		       mmc_hostname(card->host), err);
> -		return;
> +		goto out;
>   	}
>   
>   	if (!card->ext_csd.raw_bkops_status)
> -		return;
> +		goto out;
> +
> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
> +		mmc_hostname(card->host), __func__,
> +		card->ext_csd.raw_bkops_status);
>   
> +	/*
> +	 * If the function was called due to exception but there is no need
> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
> +	 * work, before going to suspend
> +	 */
>   	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>   	    from_exception)
> -		return;
> +		goto out;
>   
> -	mmc_claim_host(card->host);
>   	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>   		timeout = MMC_BKOPS_MAX_TIMEOUT;
>   		use_busy_signal = true;
> @@ -309,13 +364,108 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>   	 * bkops executed synchronously, otherwise
>   	 * the operation is in progress
>   	 */
> -	if (!use_busy_signal)
> +	if (!use_busy_signal) {
>   		mmc_card_set_doing_bkops(card);
> +		pr_debug("%s: %s: starting the polling thread\n",
> +			 mmc_hostname(card->host), __func__);
> +		queue_work(system_nrt_wq,
> +			   &card->bkops_info.poll_for_completion);
> +	}
> +
>   out:
>   	mmc_release_host(card->host);
>   }
>   EXPORT_SYMBOL(mmc_start_bkops);
>   
> +/**
> + * mmc_bkops_completion_polling() - Poll on the card status to
> + * wait for the non-blocking BKOPS completion
> + * @work:	The completion polling work
> + *
> + * The on-going reading of the card status will prevent the card
> + * from getting into suspend while it is in the middle of
> + * performing BKOPS.
> + * Since the non blocking BKOPS can be interrupted by a fetched
> + * request we also check IF mmc_card_doing_bkops in each
> + * iteration.
> + */
> +void mmc_bkops_completion_polling(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.poll_for_completion);
> +	unsigned long timeout_jiffies = jiffies +
> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
> +	u32 status;
> +	int err;
> +
> +	/*
> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
> +	 * the host from getting into suspend
> +	 */
> +	do {
> +		mmc_claim_host(card->host);
> +
> +		if (!mmc_card_doing_bkops(card))
> +			goto out;
> +
> +		err = mmc_send_status(card, &status);
> +		if (err) {
> +			pr_err("%s: error %d requesting status\n",
> +			       mmc_hostname(card->host), err);
> +			goto out;
> +		}
> +
> +		/*
> +		 * Some cards mishandle the status bits, so make sure to check
> +		 * both the busy indication and the card state.
> +		 */
> +		if ((status & R1_READY_FOR_DATA) &&
> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
> +				 mmc_hostname(card->host), __func__);
> +			mmc_card_clr_doing_bkops(card);
> +			card->bkops_info.started_delayed_bkops = false;
> +			goto out;
> +		}
> +
> +		mmc_release_host(card->host);
> +
> +		/*
> +		 * Sleep before checking the card status again to allow the
> +		 * card to complete the BKOPs operation
> +		 */
> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
> +	} while (time_before(jiffies, timeout_jiffies));
> +
> +	pr_err("%s: %s: exit polling due to timeout\n",
> +	       mmc_hostname(card->host), __func__);
> +
> +	return;
> +out:
> +	mmc_release_host(card->host);
> +}
> +
> +/**
> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
> + * needed
> + * @work:	The idle time BKOPS work
> + */
> +void mmc_start_idle_time_bkops(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.dw.work);
> +
> +	/*
> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
> +	 * BKOPS work in case the delayed work is executed on another CPU
> +	 */
> +	if (card->bkops_info.cancel_delayed_work)
> +		return;
> +
> +	mmc_start_bkops(card, false);
> +}
> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
> +
>   static void mmc_wait_done(struct mmc_request *mrq)
>   {
>   	complete(&mrq->completion);
> @@ -582,6 +732,19 @@ int mmc_stop_bkops(struct mmc_card *card)
>   	int err = 0;
>   
>   	BUG_ON(!card);
> +
> +	mmc_claim_host(card->host);
> +
> +	/*
> +	 * Notify the delayed work to be cancelled, in case it was already
> +	 * removed from the queue, but was not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = true;
> +	if (delayed_work_pending(&card->bkops_info.dw))
> +		cancel_delayed_work_sync(&card->bkops_info.dw);
> +	if (!mmc_card_doing_bkops(card))
> +		goto out;
> +
>   	err = mmc_interrupt_hpi(card);
>   
>   	/*
> @@ -593,6 +756,8 @@ int mmc_stop_bkops(struct mmc_card *card)
>   		err = 0;
>   	}
>   
> +out:
> +	mmc_release_host(card->host);
>   	return err;
>   }
>   EXPORT_SYMBOL(mmc_stop_bkops);
> @@ -2566,15 +2731,13 @@ int mmc_pm_notify(struct notifier_block *notify_block,
>   	switch (mode) {
>   	case PM_HIBERNATION_PREPARE:
>   	case PM_SUSPEND_PREPARE:
> -		if (host->card && mmc_card_mmc(host->card) &&
> -		    mmc_card_doing_bkops(host->card)) {
> +		if (host->card && mmc_card_mmc(host->card)) {
>   			err = mmc_stop_bkops(host->card);
>   			if (err) {
>   				pr_err("%s: didn't stop bkops\n",
>   					mmc_hostname(host));
>   				return err;
>   			}
> -			mmc_card_clr_doing_bkops(host->card);
>   		}
>   
>   		spin_lock_irqsave(&host->lock, flags);
> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
> index 7509de1..f8ff640 100644
> --- a/drivers/mmc/core/mmc.c
> +++ b/drivers/mmc/core/mmc.c
> @@ -1258,6 +1258,30 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
>   		}
>   	}
>   
> +	if (!oldcard) {
> +		if (card->ext_csd.bkops_en) {
> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
> +					  mmc_start_idle_time_bkops);
> +			INIT_WORK(&card->bkops_info.poll_for_completion,
> +				  mmc_bkops_completion_polling);
> +
> +			/*
> +			 * Calculate the time to start the BKOPs checking.
> +			 * The idle time of the host controller should be taken
> +			 * into account in order to prevent a race condition
> +			 * before starting BKOPs and going into suspend.
> +			 * If the host controller didn't set its idle time,
> +			 * a default value is used.
> +			 */
> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
> +			if (card->bkops_info.host_suspend_tout_ms)
> +				card->bkops_info.delay_ms = min(
> +					card->bkops_info.delay_ms,
> +				      card->bkops_info.host_suspend_tout_ms/2);
> +
> +		}
> +	}
> +
>   	if (!oldcard)
>   		host->card = card;
>   
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index 78cc3be..0e4d55a 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -207,6 +207,48 @@ struct mmc_part {
>   #define MMC_BLK_DATA_AREA_GP	(1<<2)
>   };
>   
> +/**
> + * struct mmc_bkops_info - BKOPS data
> + * @dw:	Idle time bkops delayed work
> + * @host_suspend_tout_ms:	The host controller idle time,
> + * before getting into suspend
> + * @delay_ms:	The time to start the BKOPS
> + *        delayed work once MMC thread is idle
> + * @poll_for_completion:	Poll on BKOPS completion
> + * @cancel_delayed_work: A flag to indicate if the delayed work
> + *        should be cancelled
> + * @started_delayed_bkops:  A flag to indicate if the delayed
> + *        work was scheduled
> + * @sectors_changed:  number of  sectors written or
> + *       discard since the last idle BKOPS were scheduled
> + */
> +struct mmc_bkops_info {
> +	struct delayed_work	dw;
> +	unsigned int		host_suspend_tout_ms;
> +	unsigned int		delay_ms;
> +/*
> + * A default time for checking the need for non urgent BKOPS once mmcqd
> + * is idle.
> + */
> +#define MMC_IDLE_BKOPS_TIME_MS 2000
> +	struct work_struct	poll_for_completion;
> +/* Polling timeout and interval for waiting on non-blocking BKOPs completion */
> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
> +	bool			cancel_delayed_work;
> +	bool			started_delayed_bkops;
> +	unsigned int		sectors_changed;
> +/*
> + * Since canceling the delayed work might have significant effect on the
> + * performance of small requests we won't queue the delayed work every time
> + * mmcqd thread is idle.
> + * The delayed work for idle BKOPS will be scheduled only after a significant
> + * amount of write or discard data.
> + * 100MB is chosen based on benchmark tests.
> + */
> +#define BKOPS_MIN_SECTORS_TO_QUEUE_DELAYED_WORK 204800 /* 100MB */
> +};
> +
>   /*
>    * MMC device
>    */
> @@ -281,6 +323,8 @@ struct mmc_card {
>   	struct dentry		*debugfs_root;
>   	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>   	unsigned int    nr_parts;
> +
> +	struct mmc_bkops_info	bkops_info;
>   };
>   
>   /*
> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
> index 9b9cdaf..665d345 100644
> --- a/include/linux/mmc/core.h
> +++ b/include/linux/mmc/core.h
> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
>   extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>   	struct mmc_command *, int);
>   extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>   extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
>   extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>   

[PATCH 1/6] mmc: core: sdio_io.c: Fixed lines with > 80 chars

[Sangho Yi]

I fixed lines over 80 characters per line.

Signed-off-by: Sangho Yi <antiroot@gmail.com>
---
 drivers/mmc/core/sdio_io.c |    6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/mmc/core/sdio_io.c b/drivers/mmc/core/sdio_io.c
index 8f6f5ac..c5f53d8 100644
--- a/drivers/mmc/core/sdio_io.c
+++ b/drivers/mmc/core/sdio_io.c
@@ -80,7 +80,8 @@ int sdio_enable_func(struct sdio_func *func)
 	timeout = jiffies + msecs_to_jiffies(func->enable_timeout);
 
 	while (1) {
-		ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IORx, 0, &reg);
+		ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IORx, 0,
+				&reg);
 		if (ret)
 			goto err;
 		if (reg & (1 << func->num))
@@ -664,7 +665,8 @@ void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
 
 	BUG_ON(!func);
 
-	if ((addr < 0xF0 || addr > 0xFF) && (!mmc_card_lenient_fn0(func->card))) {
+	if ((addr < 0xF0 || addr > 0xFF) &&
+			(!mmc_card_lenient_fn0(func->card))) {
 		if (err_ret)
 			*err_ret = -EINVAL;
 		return;
-- 
1.7.9.5

[PATCH 2/6] mmc: core: sdio_bus.c: Removed trailing whitespace error

[Sangho Yi]

Removed the one unnecessary whitespace error from sdio_bus.c

Signed-off-by: Sangho Yi <antiroot@gmail.com>
---
 drivers/mmc/core/sdio_bus.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 6bf6879..13146d2 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -105,7 +105,7 @@ sdio_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 			"SDIO_CLASS=%02X", func->class))
 		return -ENOMEM;
 
-	if (add_uevent_var(env, 
+	if (add_uevent_var(env,
 			"SDIO_ID=%04X:%04X", func->vendor, func->device))
 		return -ENOMEM;
 
-- 
1.7.9.5

[PATCH 3/6] mmc: core: sdio_bus.c: Fixed lines > 80 chars

[Sangho Yi]

I fixed lines over 80 characters per line.

Signed-off-by: Sangho Yi <antiroot@gmail.com>
---
 drivers/mmc/core/sdio_bus.c |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 13146d2..efa30eb 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -27,7 +27,7 @@
 /* show configuration fields */
 #define sdio_config_attr(field, format_string)				\
 static ssize_t								\
-field##_show(struct device *dev, struct device_attribute *attr, char *buf)				\
+field##_show(struct device *dev, struct device_attribute *attr, char *buf)\
 {									\
 	struct sdio_func *func;						\
 									\
@@ -39,7 +39,8 @@ sdio_config_attr(class, "0x%02x\n");
 sdio_config_attr(vendor, "0x%04x\n");
 sdio_config_attr(device, "0x%04x\n");
 
-static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
+		char *buf)
 {
 	struct sdio_func *func = dev_to_sdio_func (dev);
 
-- 
1.7.9.5

Re: [PATCH 3/6] mmc: core: sdio_bus.c: Fixed lines > 80 chars

[Jaehoon Chung]

Hi,

your patch[1/3] is also "Fixed lines > 80chars".
Why do you separate with patch[1/6] and patch[3/6]?

Best Regards,
Jaehoon Chung

On 10/19/2012 01:31 AM, Sangho Yi wrote:
> I fixed lines over 80 characters per line.
> 
> Signed-off-by: Sangho Yi <antiroot@gmail.com>
> ---
>  drivers/mmc/core/sdio_bus.c |    5 +++--
>  1 file changed, 3 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
> index 13146d2..efa30eb 100644
> --- a/drivers/mmc/core/sdio_bus.c
> +++ b/drivers/mmc/core/sdio_bus.c
> @@ -27,7 +27,7 @@
>  /* show configuration fields */
>  #define sdio_config_attr(field, format_string)				\
>  static ssize_t								\
> -field##_show(struct device *dev, struct device_attribute *attr, char *buf)				\
> +field##_show(struct device *dev, struct device_attribute *attr, char *buf)\
>  {									\
>  	struct sdio_func *func;						\
>  									\
> @@ -39,7 +39,8 @@ sdio_config_attr(class, "0x%02x\n");
>  sdio_config_attr(vendor, "0x%04x\n");
>  sdio_config_attr(device, "0x%04x\n");
>  
> -static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
> +static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
> +		char *buf)
>  {
>  	struct sdio_func *func = dev_to_sdio_func (dev);
>  
> 

[PATCH 4/6] mmc: core: sdio_bus.c: Removed space between func name and ()

[Sangho Yi]

Fixed a coding style warning like this:
from foo (arg) --> to foo(arg)

Signed-off-by: Sangho Yi <antiroot@gmail.com>
---
 drivers/mmc/core/sdio_bus.c |    6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index efa30eb..1a1d96c 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -31,8 +31,8 @@ field##_show(struct device *dev, struct device_attribute *attr, char *buf)\
 {									\
 	struct sdio_func *func;						\
 									\
-	func = dev_to_sdio_func (dev);					\
-	return sprintf (buf, format_string, func->field);		\
+	func = dev_to_sdio_func(dev);					\
+	return sprintf(buf, format_string, func->field);		\
 }
 
 sdio_config_attr(class, "0x%02x\n");
@@ -42,7 +42,7 @@ sdio_config_attr(device, "0x%04x\n");
 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 		char *buf)
 {
-	struct sdio_func *func = dev_to_sdio_func (dev);
+	struct sdio_func *func = dev_to_sdio_func(dev);
 
 	return sprintf(buf, "sdio:c%02Xv%04Xd%04X\n",
 			func->class, func->vendor, func->device);
-- 
1.7.9.5

[PATCH 5/6] mmc: core: sdio_bus.c: Fixed a warning for the pr_warning(...

[Sangho Yi]

I fixed a line which had the following warning:
WARNING: Prefer pr_warn(... to pr_warning(...

Signed-off-by: Sangho Yi <antiroot@gmail.com>
---
 drivers/mmc/core/sdio_bus.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 1a1d96c..e5b7197 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -175,7 +175,7 @@ static int sdio_bus_remove(struct device *dev)
 	drv->remove(func);
 
 	if (func->irq_handler) {
-		pr_warning("WARNING: driver %s did not remove "
+		pr_warn("WARNING: driver %s did not remove "
 			"its interrupt handler!\n", drv->name);
 		sdio_claim_host(func);
 		sdio_release_irq(func);
-- 
1.7.9.5

[PATCH 6/6] mmc: core: sdio_bus.c: Removed unnecessary NULL check routine

[Sangho Yi]

kfree(something) is safe function, so I removed the NULL check routine
for the input of kfree.

Signed-off-by: Sangho Yi <antiroot@gmail.com>
---
 drivers/mmc/core/sdio_bus.c |    3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index e5b7197..cf02146 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -259,8 +259,7 @@ static void sdio_release_func(struct device *dev)
 
 	sdio_free_func_cis(func);
 
-	if (func->info)
-		kfree(func->info);
+	kfree(func->info);
 
 	kfree(func);
 }
-- 
1.7.9.5

Re: [PATCH 1/6] mmc: core: sdio_io.c: Fixed lines with > 80 chars

[Joe Perches]

On Fri, 2012-10-19 at 01:31 +0900, Sangho Yi wrote:
> I fixed lines over 80 characters per line.

If you really must do these things, please use
checkpatch.pl --strict for guidance on how to align
function arguments.

> diff --git a/drivers/mmc/core/sdio_io.c b/drivers/mmc/core/sdio_io.c
[]
> @@ -664,7 +665,8 @@ void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
>  
>  	BUG_ON(!func);
>  
> -	if ((addr < 0xF0 || addr > 0xFF) && (!mmc_card_lenient_fn0(func->card))) {
> +	if ((addr < 0xF0 || addr > 0xFF) &&
> +			(!mmc_card_lenient_fn0(func->card))) {

ugly alignment and unnecessary parenthesis too.

[PATCH v3] mmc: core: Add support for idle time BKOPS

[Maya Erez]

Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).

According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.

This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.

When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.

Signed-off-by: Maya Erez <merez@codeaurora.org>

---
This patch is based on the periodic BKOPS implementation in version 8 of "support BKOPS feature for eMMC" patch.
The patch was modified to answer the following issues:
- In order to prevent a race condition between going into suspend and starting BKOPS, 
  the suspend timeout of the host controller is taking into accound in determination of the start time 
  of the delayed work
- Since mmc_start_bkops is called from two contexts now, mmc_claim_host was moved to the beginning of the function
- Also, the check of doing_bkops should be protected when determing if an HPI is needed due to the same reason.

Changes in v3:
    - Move the call to stop_bkops to block.c. 
      This allows us to remove the mmc_claim_host from inside the function and doesn't cause additional degradation 
      due to un-neccessary calim host operation

Changes in v2:
    - Check the number of written / discarded sectors as the trigger for checking the BKOPS need.
    - Code review fixes

---
 drivers/mmc/card/block.c |    8 ++-
 drivers/mmc/card/queue.c |    2 +
 drivers/mmc/core/core.c  |  178 +++++++++++++++++++++++++++++++++++++++++++---
 drivers/mmc/core/mmc.c   |   23 ++++++
 include/linux/mmc/card.h |   35 +++++++++
 include/linux/mmc/core.h |    3 +
 6 files changed, 237 insertions(+), 12 deletions(-)

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 172a768..40b4ae3 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 	struct mmc_blk_data *md = mq->data;
 	struct mmc_card *card = md->queue.card;
 
-	if (req && !mq->mqrq_prev->req)
+	if (req && !mq->mqrq_prev->req) {
 		/* claim host only for the first request */
 		mmc_claim_host(card->host);
+		if (card->ext_csd.bkops_en &&
+		    card->bkops_info.started_delayed_bkops) {
+				card->bkops_info.started_delayed_bkops = false;
+				mmc_stop_bkops(card);
+		}
+	}
 
 	ret = mmc_blk_part_switch(card, md);
 	if (ret) {
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index fadf52e..9d0c96a 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
 {
 	struct mmc_queue *mq = d;
 	struct request_queue *q = mq->queue;
+	struct mmc_card *card = mq->card;
 
 	current->flags |= PF_MEMALLOC;
 
@@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
 				set_current_state(TASK_RUNNING);
 				break;
 			}
+			mmc_start_delayed_bkops(card);
 			up(&mq->thread_sem);
 			schedule();
 			down(&mq->thread_sem);
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 06c42cf..72ae15b 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 }
 
 /**
+ * mmc_start_delayed_bkops() - Start a delayed work to check for
+ *      the need of non urgent BKOPS
+ *
+ * @card: MMC card to start BKOPS on
+ */
+void mmc_start_delayed_bkops(struct mmc_card *card)
+{
+	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+		return;
+
+	pr_debug("%s: %s: queueing delayed_bkops_work\n",
+		 mmc_hostname(card->host), __func__);
+
+	/*
+	 * cancel_delayed_bkops_work will prevent a race condition between
+	 * fetching a request by the mmcqd and the delayed work, in case
+	 * it was removed from the queue work but not started yet
+	 */
+	card->bkops_info.cancel_delayed_work = false;
+	card->bkops_info.started_delayed_bkops = true;
+	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
+			   msecs_to_jiffies(
+				   card->bkops_info.delay_ms));
+}
+EXPORT_SYMBOL(mmc_start_delayed_bkops);
+
+/**
  *	mmc_start_bkops - start BKOPS for supported cards
  *	@card: MMC card to start BKOPS
- *	@form_exception: A flag to indicate if this function was
+ *	@from_exception: A flag to indicate if this function was
  *			 called due to an exception raised by the card
  *
  *	Start background operations whenever requested.
@@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
 	bool use_busy_signal;
 
 	BUG_ON(!card);
-
-	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+	if (!card->ext_csd.bkops_en)
 		return;
 
+	mmc_claim_host(card->host);
+
+	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
+		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
+			 mmc_hostname(card->host), __func__);
+		card->bkops_info.cancel_delayed_work = false;
+		goto out;
+	}
+
+	if (mmc_card_doing_bkops(card)) {
+		pr_debug("%s: %s: already doing bkops, exit\n",
+			 mmc_hostname(card->host), __func__);
+		goto out;
+	}
+
 	err = mmc_read_bkops_status(card);
 	if (err) {
 		pr_err("%s: Failed to read bkops status: %d\n",
 		       mmc_hostname(card->host), err);
-		return;
+		goto out;
 	}
 
 	if (!card->ext_csd.raw_bkops_status)
-		return;
+		goto out;
 
+	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
+		mmc_hostname(card->host), __func__,
+		card->ext_csd.raw_bkops_status);
+
+	/*
+	 * If the function was called due to exception but there is no need
+	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
+	 * work, before going to suspend
+	 */
 	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
 	    from_exception)
-		return;
+		goto out;
 
-	mmc_claim_host(card->host);
 	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
 		timeout = MMC_BKOPS_MAX_TIMEOUT;
 		use_busy_signal = true;
@@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
 	 * bkops executed synchronously, otherwise
 	 * the operation is in progress
 	 */
-	if (!use_busy_signal)
+	if (!use_busy_signal) {
 		mmc_card_set_doing_bkops(card);
+		pr_debug("%s: %s: starting the polling thread\n",
+			 mmc_hostname(card->host), __func__);
+		queue_work(system_nrt_wq,
+			   &card->bkops_info.poll_for_completion);
+	}
+
 out:
 	mmc_release_host(card->host);
 }
 EXPORT_SYMBOL(mmc_start_bkops);
 
+/**
+ * mmc_bkops_completion_polling() - Poll on the card status to
+ * wait for the non-blocking BKOPS completion
+ * @work:	The completion polling work
+ *
+ * The on-going reading of the card status will prevent the card
+ * from getting into suspend while it is in the middle of
+ * performing BKOPS.
+ * Since the non blocking BKOPS can be interrupted by a fetched
+ * request we also check IF mmc_card_doing_bkops in each
+ * iteration.
+ */
+void mmc_bkops_completion_polling(struct work_struct *work)
+{
+	struct mmc_card *card = container_of(work, struct mmc_card,
+			bkops_info.poll_for_completion);
+	unsigned long timeout_jiffies = jiffies +
+		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
+	u32 status;
+	int err;
+
+	/*
+	 * Wait for the BKOPs to complete. Keep reading the status to prevent
+	 * the host from getting into suspend
+	 */
+	do {
+		mmc_claim_host(card->host);
+
+		if (!mmc_card_doing_bkops(card))
+			goto out;
+
+		err = mmc_send_status(card, &status);
+		if (err) {
+			pr_err("%s: error %d requesting status\n",
+			       mmc_hostname(card->host), err);
+			goto out;
+		}
+
+		/*
+		 * Some cards mishandle the status bits, so make sure to check
+		 * both the busy indication and the card state.
+		 */
+		if ((status & R1_READY_FOR_DATA) &&
+		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
+			pr_debug("%s: %s: completed BKOPs, exit polling\n",
+				 mmc_hostname(card->host), __func__);
+			mmc_card_clr_doing_bkops(card);
+			card->bkops_info.started_delayed_bkops = false;
+			goto out;
+		}
+
+		mmc_release_host(card->host);
+
+		/*
+		 * Sleep before checking the card status again to allow the
+		 * card to complete the BKOPs operation
+		 */
+		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
+	} while (time_before(jiffies, timeout_jiffies));
+
+	pr_err("%s: %s: exit polling due to timeout\n",
+	       mmc_hostname(card->host), __func__);
+
+	return;
+out:
+	mmc_release_host(card->host);
+}
+
+/**
+ * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
+ * needed
+ * @work:	The idle time BKOPS work
+ */
+void mmc_start_idle_time_bkops(struct work_struct *work)
+{
+	struct mmc_card *card = container_of(work, struct mmc_card,
+			bkops_info.dw.work);
+
+	/*
+	 * Prevent a race condition between mmc_stop_bkops and the delayed
+	 * BKOPS work in case the delayed work is executed on another CPU
+	 */
+	if (card->bkops_info.cancel_delayed_work)
+		return;
+
+	mmc_start_bkops(card, false);
+}
+EXPORT_SYMBOL(mmc_start_idle_time_bkops);
+
 static void mmc_wait_done(struct mmc_request *mrq)
 {
 	complete(&mrq->completion);
@@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
 	int err = 0;
 
 	BUG_ON(!card);
+
+	/*
+	 * Notify the delayed work to be cancelled, in case it was already
+	 * removed from the queue, but was not started yet
+	 */
+	card->bkops_info.cancel_delayed_work = true;
+	if (delayed_work_pending(&card->bkops_info.dw))
+		cancel_delayed_work_sync(&card->bkops_info.dw);
+	if (!mmc_card_doing_bkops(card))
+		goto out;
+
 	err = mmc_interrupt_hpi(card);
 
 	/*
@@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
 		err = 0;
 	}
 
+out:
 	return err;
 }
 EXPORT_SYMBOL(mmc_stop_bkops);
@@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 	switch (mode) {
 	case PM_HIBERNATION_PREPARE:
 	case PM_SUSPEND_PREPARE:
-		if (host->card && mmc_card_mmc(host->card) &&
-		    mmc_card_doing_bkops(host->card)) {
+		if (host->card && mmc_card_mmc(host->card)) {
+			mmc_claim_host(host);
 			err = mmc_stop_bkops(host->card);
+			mmc_release_host(host);
 			if (err) {
 				pr_err("%s: didn't stop bkops\n",
 					mmc_hostname(host));
 				return err;
 			}
-			mmc_card_clr_doing_bkops(host->card);
 		}
 
 		spin_lock_irqsave(&host->lock, flags);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 7cc4638..dba76e3 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
 		}
 	}
 
+	if (!oldcard) {
+		if (card->ext_csd.bkops_en) {
+			INIT_DELAYED_WORK(&card->bkops_info.dw,
+					  mmc_start_idle_time_bkops);
+			INIT_WORK(&card->bkops_info.poll_for_completion,
+				  mmc_bkops_completion_polling);
+
+			/*
+			 * Calculate the time to start the BKOPs checking.
+			 * The idle time of the host controller should be taken
+			 * into account in order to prevent a race condition
+			 * before starting BKOPs and going into suspend.
+			 * If the host controller didn't set its idle time,
+			 * a default value is used.
+			 */
+			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
+			if (card->bkops_info.host_suspend_tout_ms)
+				card->bkops_info.delay_ms = min(
+					card->bkops_info.delay_ms,
+				      card->bkops_info.host_suspend_tout_ms/2);
+		}
+	}
+
 	if (!oldcard)
 		host->card = card;
 
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 943550d..224e2a5 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -208,6 +208,39 @@ struct mmc_part {
 #define MMC_BLK_DATA_AREA_GP	(1<<2)
 };
 
+/**
+ * struct mmc_bkops_info - BKOPS data
+ * @dw:	Idle time bkops delayed work
+ * @host_suspend_tout_ms:	The host controller idle time,
+ * before getting into suspend
+ * @delay_ms:	The time to start the BKOPS
+ *        delayed work once MMC thread is idle
+ * @poll_for_completion:	Poll on BKOPS completion
+ * @cancel_delayed_work: A flag to indicate if the delayed work
+ *        should be cancelled
+ * @started_delayed_bkops:  A flag to indicate if the delayed
+ *        work was scheduled
+ * @sectors_changed:  number of  sectors written or
+ *       discard since the last idle BKOPS were scheduled
+ */
+struct mmc_bkops_info {
+	struct delayed_work	dw;
+	unsigned int		host_suspend_tout_ms;
+	unsigned int		delay_ms;
+/*
+ * A default time for checking the need for non urgent BKOPS once mmcqd
+ * is idle.
+ */
+#define MMC_IDLE_BKOPS_TIME_MS 2000
+	struct work_struct	poll_for_completion;
+/* Polling timeout and interval for waiting on non-blocking BKOPs completion */
+#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
+#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
+	bool			cancel_delayed_work;
+	bool			started_delayed_bkops;
+	unsigned int		sectors_changed;
+};
+
 /*
  * MMC device
  */
@@ -276,6 +309,8 @@ struct mmc_card {
 	struct dentry		*debugfs_root;
 	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
 	unsigned int    nr_parts;
+
+	struct mmc_bkops_info	bkops_info;
 };
 
 /*
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 9b9cdaf..665d345 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
 extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
 	struct mmc_command *, int);
 extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
+extern void mmc_start_delayed_bkops(struct mmc_card *card);
+extern void mmc_start_idle_time_bkops(struct work_struct *work);
+extern void mmc_bkops_completion_polling(struct work_struct *work);
 extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
 extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
 
-- 
1.7.3.3
-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[merez]

Hi Chris,

I managed to find a solution in which there is no need to check the number
of written / discarded sectors as a trigger for BKOPS status check.
I moved the code that checks the need to stop the BKOPS to mmc/block code,
in which there is no need for additional claim_host and remove_host
operations.
Please review this patch.

Thanks,
Maya
On Sun, November 25, 2012 3:56 am, Maya Erez wrote:
> Devices have various maintenance operations need to perform internally.
> In order to reduce latencies during time critical operations like read
> and write, it is better to execute maintenance operations in other
> times - when the host is not being serviced. Such operations are called
> Background operations (BKOPS).
> The device notifies the status of the BKOPS need by updating BKOPS_STATUS
> (EXT_CSD byte [246]).
>
> According to the standard a host that supports BKOPS shall check the
> status periodically and start background operations as needed, so that
> the device has enough time for its maintenance operations.
>
> This patch adds support for this periodic check of the BKOPS status.
> Since foreground operations are of higher priority than background
> operations the host will check the need for BKOPS when it is idle,
> and in case of an incoming request the BKOPS operation will be
> interrupted.
>
> When the mmcqd thread is idle, a delayed work is created to check the
> need for BKOPS. The time to start the delayed work is calculated based
> on the host controller suspend timeout, in case it was set. If not, a
> default time is used.
> If BKOPS are required in level 1, which is non-blocking, there will be
> polling of the card status to wait for the BKOPS completion and prevent
> suspend that will interrupt the BKOPS.
> If the card raised an exception, the need for urgent BKOPS (level 2/3)
> will be checked immediately and if needed, the BKOPS will be performed
> without waiting for the next idle time.
>
> Signed-off-by: Maya Erez <merez@codeaurora.org>
>
> ---
> This patch is based on the periodic BKOPS implementation in version 8 of
> "support BKOPS feature for eMMC" patch.
> The patch was modified to answer the following issues:
> - In order to prevent a race condition between going into suspend and
> starting BKOPS,
>   the suspend timeout of the host controller is taking into accound in
> determination of the start time
>   of the delayed work
> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host
> was moved to the beginning of the function
> - Also, the check of doing_bkops should be protected when determing if an
> HPI is needed due to the same reason.
>
> Changes in v3:
>     - Move the call to stop_bkops to block.c.
>       This allows us to remove the mmc_claim_host from inside the function
> and doesn't cause additional degradation
>       due to un-neccessary calim host operation
>
> Changes in v2:
>     - Check the number of written / discarded sectors as the trigger for
> checking the BKOPS need.
>     - Code review fixes
>
> ---
>  drivers/mmc/card/block.c |    8 ++-
>  drivers/mmc/card/queue.c |    2 +
>  drivers/mmc/core/core.c  |  178
> +++++++++++++++++++++++++++++++++++++++++++---
>  drivers/mmc/core/mmc.c   |   23 ++++++
>  include/linux/mmc/card.h |   35 +++++++++
>  include/linux/mmc/core.h |    3 +
>  6 files changed, 237 insertions(+), 12 deletions(-)
>
> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
> index 172a768..40b4ae3 100644
> --- a/drivers/mmc/card/block.c
> +++ b/drivers/mmc/card/block.c
> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq,
> struct request *req)
>  	struct mmc_blk_data *md = mq->data;
>  	struct mmc_card *card = md->queue.card;
>
> -	if (req && !mq->mqrq_prev->req)
> +	if (req && !mq->mqrq_prev->req) {
>  		/* claim host only for the first request */
>  		mmc_claim_host(card->host);
> +		if (card->ext_csd.bkops_en &&
> +		    card->bkops_info.started_delayed_bkops) {
> +				card->bkops_info.started_delayed_bkops = false;
> +				mmc_stop_bkops(card);
> +		}
> +	}
>
>  	ret = mmc_blk_part_switch(card, md);
>  	if (ret) {
> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
> index fadf52e..9d0c96a 100644
> --- a/drivers/mmc/card/queue.c
> +++ b/drivers/mmc/card/queue.c
> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>  {
>  	struct mmc_queue *mq = d;
>  	struct request_queue *q = mq->queue;
> +	struct mmc_card *card = mq->card;
>
>  	current->flags |= PF_MEMALLOC;
>
> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>  				set_current_state(TASK_RUNNING);
>  				break;
>  			}
> +			mmc_start_delayed_bkops(card);
>  			up(&mq->thread_sem);
>  			schedule();
>  			down(&mq->thread_sem);
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index 06c42cf..72ae15b 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
> mmc_request *mrq)
>  }
>
>  /**
> + * mmc_start_delayed_bkops() - Start a delayed work to check for
> + *      the need of non urgent BKOPS
> + *
> + * @card: MMC card to start BKOPS on
> + */
> +void mmc_start_delayed_bkops(struct mmc_card *card)
> +{
> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +		return;
> +
> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
> +		 mmc_hostname(card->host), __func__);
> +
> +	/*
> +	 * cancel_delayed_bkops_work will prevent a race condition between
> +	 * fetching a request by the mmcqd and the delayed work, in case
> +	 * it was removed from the queue work but not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = false;
> +	card->bkops_info.started_delayed_bkops = true;
> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
> +			   msecs_to_jiffies(
> +				   card->bkops_info.delay_ms));
> +}
> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
> +
> +/**
>   *	mmc_start_bkops - start BKOPS for supported cards
>   *	@card: MMC card to start BKOPS
> - *	@form_exception: A flag to indicate if this function was
> + *	@from_exception: A flag to indicate if this function was
>   *			 called due to an exception raised by the card
>   *
>   *	Start background operations whenever requested.
> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
> from_exception)
>  	bool use_busy_signal;
>
>  	BUG_ON(!card);
> -
> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +	if (!card->ext_csd.bkops_en)
>  		return;
>
> +	mmc_claim_host(card->host);
> +
> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		card->bkops_info.cancel_delayed_work = false;
> +		goto out;
> +	}
> +
> +	if (mmc_card_doing_bkops(card)) {
> +		pr_debug("%s: %s: already doing bkops, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		goto out;
> +	}
> +
>  	err = mmc_read_bkops_status(card);
>  	if (err) {
>  		pr_err("%s: Failed to read bkops status: %d\n",
>  		       mmc_hostname(card->host), err);
> -		return;
> +		goto out;
>  	}
>
>  	if (!card->ext_csd.raw_bkops_status)
> -		return;
> +		goto out;
>
> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
> +		mmc_hostname(card->host), __func__,
> +		card->ext_csd.raw_bkops_status);
> +
> +	/*
> +	 * If the function was called due to exception but there is no need
> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
> +	 * work, before going to suspend
> +	 */
>  	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>  	    from_exception)
> -		return;
> +		goto out;
>
> -	mmc_claim_host(card->host);
>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>  		timeout = MMC_BKOPS_MAX_TIMEOUT;
>  		use_busy_signal = true;
> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card, bool
> from_exception)
>  	 * bkops executed synchronously, otherwise
>  	 * the operation is in progress
>  	 */
> -	if (!use_busy_signal)
> +	if (!use_busy_signal) {
>  		mmc_card_set_doing_bkops(card);
> +		pr_debug("%s: %s: starting the polling thread\n",
> +			 mmc_hostname(card->host), __func__);
> +		queue_work(system_nrt_wq,
> +			   &card->bkops_info.poll_for_completion);
> +	}
> +
>  out:
>  	mmc_release_host(card->host);
>  }
>  EXPORT_SYMBOL(mmc_start_bkops);
>
> +/**
> + * mmc_bkops_completion_polling() - Poll on the card status to
> + * wait for the non-blocking BKOPS completion
> + * @work:	The completion polling work
> + *
> + * The on-going reading of the card status will prevent the card
> + * from getting into suspend while it is in the middle of
> + * performing BKOPS.
> + * Since the non blocking BKOPS can be interrupted by a fetched
> + * request we also check IF mmc_card_doing_bkops in each
> + * iteration.
> + */
> +void mmc_bkops_completion_polling(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.poll_for_completion);
> +	unsigned long timeout_jiffies = jiffies +
> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
> +	u32 status;
> +	int err;
> +
> +	/*
> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
> +	 * the host from getting into suspend
> +	 */
> +	do {
> +		mmc_claim_host(card->host);
> +
> +		if (!mmc_card_doing_bkops(card))
> +			goto out;
> +
> +		err = mmc_send_status(card, &status);
> +		if (err) {
> +			pr_err("%s: error %d requesting status\n",
> +			       mmc_hostname(card->host), err);
> +			goto out;
> +		}
> +
> +		/*
> +		 * Some cards mishandle the status bits, so make sure to check
> +		 * both the busy indication and the card state.
> +		 */
> +		if ((status & R1_READY_FOR_DATA) &&
> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
> +				 mmc_hostname(card->host), __func__);
> +			mmc_card_clr_doing_bkops(card);
> +			card->bkops_info.started_delayed_bkops = false;
> +			goto out;
> +		}
> +
> +		mmc_release_host(card->host);
> +
> +		/*
> +		 * Sleep before checking the card status again to allow the
> +		 * card to complete the BKOPs operation
> +		 */
> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
> +	} while (time_before(jiffies, timeout_jiffies));
> +
> +	pr_err("%s: %s: exit polling due to timeout\n",
> +	       mmc_hostname(card->host), __func__);
> +
> +	return;
> +out:
> +	mmc_release_host(card->host);
> +}
> +
> +/**
> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
> + * needed
> + * @work:	The idle time BKOPS work
> + */
> +void mmc_start_idle_time_bkops(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.dw.work);
> +
> +	/*
> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
> +	 * BKOPS work in case the delayed work is executed on another CPU
> +	 */
> +	if (card->bkops_info.cancel_delayed_work)
> +		return;
> +
> +	mmc_start_bkops(card, false);
> +}
> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
> +
>  static void mmc_wait_done(struct mmc_request *mrq)
>  {
>  	complete(&mrq->completion);
> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>  	int err = 0;
>
>  	BUG_ON(!card);
> +
> +	/*
> +	 * Notify the delayed work to be cancelled, in case it was already
> +	 * removed from the queue, but was not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = true;
> +	if (delayed_work_pending(&card->bkops_info.dw))
> +		cancel_delayed_work_sync(&card->bkops_info.dw);
> +	if (!mmc_card_doing_bkops(card))
> +		goto out;
> +
>  	err = mmc_interrupt_hpi(card);
>
>  	/*
> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>  		err = 0;
>  	}
>
> +out:
>  	return err;
>  }
>  EXPORT_SYMBOL(mmc_stop_bkops);
> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
> *notify_block,
>  	switch (mode) {
>  	case PM_HIBERNATION_PREPARE:
>  	case PM_SUSPEND_PREPARE:
> -		if (host->card && mmc_card_mmc(host->card) &&
> -		    mmc_card_doing_bkops(host->card)) {
> +		if (host->card && mmc_card_mmc(host->card)) {
> +			mmc_claim_host(host);
>  			err = mmc_stop_bkops(host->card);
> +			mmc_release_host(host);
>  			if (err) {
>  				pr_err("%s: didn't stop bkops\n",
>  					mmc_hostname(host));
>  				return err;
>  			}
> -			mmc_card_clr_doing_bkops(host->card);
>  		}
>
>  		spin_lock_irqsave(&host->lock, flags);
> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
> index 7cc4638..dba76e3 100644
> --- a/drivers/mmc/core/mmc.c
> +++ b/drivers/mmc/core/mmc.c
> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host *host, u32
> ocr,
>  		}
>  	}
>
> +	if (!oldcard) {
> +		if (card->ext_csd.bkops_en) {
> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
> +					  mmc_start_idle_time_bkops);
> +			INIT_WORK(&card->bkops_info.poll_for_completion,
> +				  mmc_bkops_completion_polling);
> +
> +			/*
> +			 * Calculate the time to start the BKOPs checking.
> +			 * The idle time of the host controller should be taken
> +			 * into account in order to prevent a race condition
> +			 * before starting BKOPs and going into suspend.
> +			 * If the host controller didn't set its idle time,
> +			 * a default value is used.
> +			 */
> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
> +			if (card->bkops_info.host_suspend_tout_ms)
> +				card->bkops_info.delay_ms = min(
> +					card->bkops_info.delay_ms,
> +				      card->bkops_info.host_suspend_tout_ms/2);
> +		}
> +	}
> +
>  	if (!oldcard)
>  		host->card = card;
>
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index 943550d..224e2a5 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -208,6 +208,39 @@ struct mmc_part {
>  #define MMC_BLK_DATA_AREA_GP	(1<<2)
>  };
>
> +/**
> + * struct mmc_bkops_info - BKOPS data
> + * @dw:	Idle time bkops delayed work
> + * @host_suspend_tout_ms:	The host controller idle time,
> + * before getting into suspend
> + * @delay_ms:	The time to start the BKOPS
> + *        delayed work once MMC thread is idle
> + * @poll_for_completion:	Poll on BKOPS completion
> + * @cancel_delayed_work: A flag to indicate if the delayed work
> + *        should be cancelled
> + * @started_delayed_bkops:  A flag to indicate if the delayed
> + *        work was scheduled
> + * @sectors_changed:  number of  sectors written or
> + *       discard since the last idle BKOPS were scheduled
> + */
> +struct mmc_bkops_info {
> +	struct delayed_work	dw;
> +	unsigned int		host_suspend_tout_ms;
> +	unsigned int		delay_ms;
> +/*
> + * A default time for checking the need for non urgent BKOPS once mmcqd
> + * is idle.
> + */
> +#define MMC_IDLE_BKOPS_TIME_MS 2000
> +	struct work_struct	poll_for_completion;
> +/* Polling timeout and interval for waiting on non-blocking BKOPs
> completion */
> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
> +	bool			cancel_delayed_work;
> +	bool			started_delayed_bkops;
> +	unsigned int		sectors_changed;
> +};
> +
>  /*
>   * MMC device
>   */
> @@ -276,6 +309,8 @@ struct mmc_card {
>  	struct dentry		*debugfs_root;
>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>  	unsigned int    nr_parts;
> +
> +	struct mmc_bkops_info	bkops_info;
>  };
>
>  /*
> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
> index 9b9cdaf..665d345 100644
> --- a/include/linux/mmc/core.h
> +++ b/include/linux/mmc/core.h
> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
> mmc_card *);
>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>  	struct mmc_command *, int);
>  extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
> bool);
>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>
> --
> 1.7.3.3
> --
> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
> of Code Aurora Forum, hosted by The Linux Foundation
> --
> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>


-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Chris Ball]

Hi Maya,

On Sun, Nov 25 2012, merez@codeaurora.org wrote:
> I managed to find a solution in which there is no need to check the number
> of written / discarded sectors as a trigger for BKOPS status check.
> I moved the code that checks the need to stop the BKOPS to mmc/block code,
> in which there is no need for additional claim_host and remove_host
> operations.
> Please review this patch.

Looks good -- if we find that counting with a bitmask of eraseblocks is
necessary it can be added on later.

Do you have a testing plan for the patch?  I wonder if we could test
the effects on battery life and latency.

Thanks!

- Chris.
-- 
Chris Ball   <cjb@laptop.org>   <http://printf.net/>
One Laptop Per Child

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Jaehoon Chung]

Hi Maya,

Thank you a lot for working idle time BKOPS.

I tested with this patch. It's working fine.(Suspend/resume is also working well.)
Test controller is sdhci controller. 
When i tested the performance with iozone, i didn't find that performance is decreased.
Well, as Chris is mentioned, do you have any test plan?
So I will test more with this patch, because i want to test with dw-mmc controller, too.

On 11/25/2012 08:56 PM, Maya Erez wrote:
> Devices have various maintenance operations need to perform internally.
> In order to reduce latencies during time critical operations like read
> and write, it is better to execute maintenance operations in other
> times - when the host is not being serviced. Such operations are called
> Background operations (BKOPS).
> The device notifies the status of the BKOPS need by updating BKOPS_STATUS
> (EXT_CSD byte [246]).
> 
> According to the standard a host that supports BKOPS shall check the
> status periodically and start background operations as needed, so that
> the device has enough time for its maintenance operations.
> 
> This patch adds support for this periodic check of the BKOPS status.
> Since foreground operations are of higher priority than background
> operations the host will check the need for BKOPS when it is idle,
> and in case of an incoming request the BKOPS operation will be
> interrupted.
> 
> When the mmcqd thread is idle, a delayed work is created to check the
> need for BKOPS. The time to start the delayed work is calculated based
> on the host controller suspend timeout, in case it was set. If not, a
> default time is used.
> If BKOPS are required in level 1, which is non-blocking, there will be
> polling of the card status to wait for the BKOPS completion and prevent
> suspend that will interrupt the BKOPS.
> If the card raised an exception, the need for urgent BKOPS (level 2/3)
> will be checked immediately and if needed, the BKOPS will be performed
> without waiting for the next idle time.
> 
> Signed-off-by: Maya Erez <merez@codeaurora.org>
> 
> ---
> This patch is based on the periodic BKOPS implementation in version 8 of "support BKOPS feature for eMMC" patch.
> The patch was modified to answer the following issues:
> - In order to prevent a race condition between going into suspend and starting BKOPS, 
>   the suspend timeout of the host controller is taking into accound in determination of the start time 
>   of the delayed work
> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host was moved to the beginning of the function
> - Also, the check of doing_bkops should be protected when determing if an HPI is needed due to the same reason.
> 
> Changes in v3:
>     - Move the call to stop_bkops to block.c. 
>       This allows us to remove the mmc_claim_host from inside the function and doesn't cause additional degradation 
>       due to un-neccessary calim host operation
> 
> Changes in v2:
>     - Check the number of written / discarded sectors as the trigger for checking the BKOPS need.
>     - Code review fixes
> 
> ---
>  drivers/mmc/card/block.c |    8 ++-
>  drivers/mmc/card/queue.c |    2 +
>  drivers/mmc/core/core.c  |  178 +++++++++++++++++++++++++++++++++++++++++++---
>  drivers/mmc/core/mmc.c   |   23 ++++++
>  include/linux/mmc/card.h |   35 +++++++++
>  include/linux/mmc/core.h |    3 +
>  6 files changed, 237 insertions(+), 12 deletions(-)
> 
> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
> index 172a768..40b4ae3 100644
> --- a/drivers/mmc/card/block.c
> +++ b/drivers/mmc/card/block.c
> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
>  	struct mmc_blk_data *md = mq->data;
>  	struct mmc_card *card = md->queue.card;
>  
> -	if (req && !mq->mqrq_prev->req)
> +	if (req && !mq->mqrq_prev->req) {
>  		/* claim host only for the first request */
>  		mmc_claim_host(card->host);
> +		if (card->ext_csd.bkops_en &&
> +		    card->bkops_info.started_delayed_bkops) {
> +				card->bkops_info.started_delayed_bkops = false;
> +				mmc_stop_bkops(card);
We didn't need to check whether mmc_stop_bkops is success or not?
If mmc_stop_bkops() is failed, then bkops is continuously running.

Best Regards,
Jaehoon Chung

> +		}
> +	}
>  
>  	ret = mmc_blk_part_switch(card, md);
>  	if (ret) {
> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
> index fadf52e..9d0c96a 100644
> --- a/drivers/mmc/card/queue.c
> +++ b/drivers/mmc/card/queue.c
> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>  {
>  	struct mmc_queue *mq = d;
>  	struct request_queue *q = mq->queue;
> +	struct mmc_card *card = mq->card;
>  
>  	current->flags |= PF_MEMALLOC;
>  
> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>  				set_current_state(TASK_RUNNING);
>  				break;
>  			}
> +			mmc_start_delayed_bkops(card);
>  			up(&mq->thread_sem);
>  			schedule();
>  			down(&mq->thread_sem);
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index 06c42cf..72ae15b 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
>  }
>  
>  /**
> + * mmc_start_delayed_bkops() - Start a delayed work to check for
> + *      the need of non urgent BKOPS
> + *
> + * @card: MMC card to start BKOPS on
> + */
> +void mmc_start_delayed_bkops(struct mmc_card *card)
> +{
> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +		return;
> +
> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
> +		 mmc_hostname(card->host), __func__);
> +
> +	/*
> +	 * cancel_delayed_bkops_work will prevent a race condition between
> +	 * fetching a request by the mmcqd and the delayed work, in case
> +	 * it was removed from the queue work but not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = false;
> +	card->bkops_info.started_delayed_bkops = true;
> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
> +			   msecs_to_jiffies(
> +				   card->bkops_info.delay_ms));
> +}
> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
> +
> +/**
>   *	mmc_start_bkops - start BKOPS for supported cards
>   *	@card: MMC card to start BKOPS
> - *	@form_exception: A flag to indicate if this function was
> + *	@from_exception: A flag to indicate if this function was
>   *			 called due to an exception raised by the card
>   *
>   *	Start background operations whenever requested.
> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>  	bool use_busy_signal;
>  
>  	BUG_ON(!card);
> -
> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
> +	if (!card->ext_csd.bkops_en)
>  		return;
>  
> +	mmc_claim_host(card->host);
> +
> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		card->bkops_info.cancel_delayed_work = false;
> +		goto out;
> +	}
> +
> +	if (mmc_card_doing_bkops(card)) {
> +		pr_debug("%s: %s: already doing bkops, exit\n",
> +			 mmc_hostname(card->host), __func__);
> +		goto out;
> +	}
> +
>  	err = mmc_read_bkops_status(card);
>  	if (err) {
>  		pr_err("%s: Failed to read bkops status: %d\n",
>  		       mmc_hostname(card->host), err);
> -		return;
> +		goto out;
>  	}
>  
>  	if (!card->ext_csd.raw_bkops_status)
> -		return;
> +		goto out;
>  
> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
> +		mmc_hostname(card->host), __func__,
> +		card->ext_csd.raw_bkops_status);
> +
> +	/*
> +	 * If the function was called due to exception but there is no need
> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
> +	 * work, before going to suspend
> +	 */
>  	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>  	    from_exception)
> -		return;
> +		goto out;
>  
> -	mmc_claim_host(card->host);
>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>  		timeout = MMC_BKOPS_MAX_TIMEOUT;
>  		use_busy_signal = true;
> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card, bool from_exception)
>  	 * bkops executed synchronously, otherwise
>  	 * the operation is in progress
>  	 */
> -	if (!use_busy_signal)
> +	if (!use_busy_signal) {
>  		mmc_card_set_doing_bkops(card);
> +		pr_debug("%s: %s: starting the polling thread\n",
> +			 mmc_hostname(card->host), __func__);
> +		queue_work(system_nrt_wq,
> +			   &card->bkops_info.poll_for_completion);
> +	}
> +
>  out:
>  	mmc_release_host(card->host);
>  }
>  EXPORT_SYMBOL(mmc_start_bkops);
>  
> +/**
> + * mmc_bkops_completion_polling() - Poll on the card status to
> + * wait for the non-blocking BKOPS completion
> + * @work:	The completion polling work
> + *
> + * The on-going reading of the card status will prevent the card
> + * from getting into suspend while it is in the middle of
> + * performing BKOPS.
> + * Since the non blocking BKOPS can be interrupted by a fetched
> + * request we also check IF mmc_card_doing_bkops in each
> + * iteration.
> + */
> +void mmc_bkops_completion_polling(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.poll_for_completion);
> +	unsigned long timeout_jiffies = jiffies +
> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
> +	u32 status;
> +	int err;
> +
> +	/*
> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
> +	 * the host from getting into suspend
> +	 */
> +	do {
> +		mmc_claim_host(card->host);
> +
> +		if (!mmc_card_doing_bkops(card))
> +			goto out;
> +
> +		err = mmc_send_status(card, &status);
> +		if (err) {
> +			pr_err("%s: error %d requesting status\n",
> +			       mmc_hostname(card->host), err);
> +			goto out;
> +		}
> +
> +		/*
> +		 * Some cards mishandle the status bits, so make sure to check
> +		 * both the busy indication and the card state.
> +		 */
> +		if ((status & R1_READY_FOR_DATA) &&
> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
> +				 mmc_hostname(card->host), __func__);
> +			mmc_card_clr_doing_bkops(card);
> +			card->bkops_info.started_delayed_bkops = false;
> +			goto out;
> +		}
> +
> +		mmc_release_host(card->host);
> +
> +		/*
> +		 * Sleep before checking the card status again to allow the
> +		 * card to complete the BKOPs operation
> +		 */
> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
> +	} while (time_before(jiffies, timeout_jiffies));
> +
> +	pr_err("%s: %s: exit polling due to timeout\n",
> +	       mmc_hostname(card->host), __func__);
> +
> +	return;
> +out:
> +	mmc_release_host(card->host);
> +}
> +
> +/**
> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
> + * needed
> + * @work:	The idle time BKOPS work
> + */
> +void mmc_start_idle_time_bkops(struct work_struct *work)
> +{
> +	struct mmc_card *card = container_of(work, struct mmc_card,
> +			bkops_info.dw.work);
> +
> +	/*
> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
> +	 * BKOPS work in case the delayed work is executed on another CPU
> +	 */
> +	if (card->bkops_info.cancel_delayed_work)
> +		return;
> +
> +	mmc_start_bkops(card, false);
> +}
> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
> +
>  static void mmc_wait_done(struct mmc_request *mrq)
>  {
>  	complete(&mrq->completion);
> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>  	int err = 0;
>  
>  	BUG_ON(!card);
> +
> +	/*
> +	 * Notify the delayed work to be cancelled, in case it was already
> +	 * removed from the queue, but was not started yet
> +	 */
> +	card->bkops_info.cancel_delayed_work = true;
> +	if (delayed_work_pending(&card->bkops_info.dw))
> +		cancel_delayed_work_sync(&card->bkops_info.dw);
> +	if (!mmc_card_doing_bkops(card))
> +		goto out;
> +
>  	err = mmc_interrupt_hpi(card);
>  
>  	/*
> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>  		err = 0;
>  	}
>  
> +out:
>  	return err;
>  }
>  EXPORT_SYMBOL(mmc_stop_bkops);
> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block *notify_block,
>  	switch (mode) {
>  	case PM_HIBERNATION_PREPARE:
>  	case PM_SUSPEND_PREPARE:
> -		if (host->card && mmc_card_mmc(host->card) &&
> -		    mmc_card_doing_bkops(host->card)) {
> +		if (host->card && mmc_card_mmc(host->card)) {
> +			mmc_claim_host(host);
>  			err = mmc_stop_bkops(host->card);
> +			mmc_release_host(host);
>  			if (err) {
>  				pr_err("%s: didn't stop bkops\n",
>  					mmc_hostname(host));
>  				return err;
>  			}
> -			mmc_card_clr_doing_bkops(host->card);
>  		}
>  
>  		spin_lock_irqsave(&host->lock, flags);
> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
> index 7cc4638..dba76e3 100644
> --- a/drivers/mmc/core/mmc.c
> +++ b/drivers/mmc/core/mmc.c
> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
>  		}
>  	}
>  
> +	if (!oldcard) {
> +		if (card->ext_csd.bkops_en) {
> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
> +					  mmc_start_idle_time_bkops);
> +			INIT_WORK(&card->bkops_info.poll_for_completion,
> +				  mmc_bkops_completion_polling);
> +
> +			/*
> +			 * Calculate the time to start the BKOPs checking.
> +			 * The idle time of the host controller should be taken
> +			 * into account in order to prevent a race condition
> +			 * before starting BKOPs and going into suspend.
> +			 * If the host controller didn't set its idle time,
> +			 * a default value is used.
> +			 */
> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
> +			if (card->bkops_info.host_suspend_tout_ms)
> +				card->bkops_info.delay_ms = min(
> +					card->bkops_info.delay_ms,
> +				      card->bkops_info.host_suspend_tout_ms/2);
> +		}
> +	}
> +
>  	if (!oldcard)
>  		host->card = card;
>  
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index 943550d..224e2a5 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -208,6 +208,39 @@ struct mmc_part {
>  #define MMC_BLK_DATA_AREA_GP	(1<<2)
>  };
>  
> +/**
> + * struct mmc_bkops_info - BKOPS data
> + * @dw:	Idle time bkops delayed work
> + * @host_suspend_tout_ms:	The host controller idle time,
> + * before getting into suspend
> + * @delay_ms:	The time to start the BKOPS
> + *        delayed work once MMC thread is idle
> + * @poll_for_completion:	Poll on BKOPS completion
> + * @cancel_delayed_work: A flag to indicate if the delayed work
> + *        should be cancelled
> + * @started_delayed_bkops:  A flag to indicate if the delayed
> + *        work was scheduled
> + * @sectors_changed:  number of  sectors written or
> + *       discard since the last idle BKOPS were scheduled
> + */
> +struct mmc_bkops_info {
> +	struct delayed_work	dw;
> +	unsigned int		host_suspend_tout_ms;
> +	unsigned int		delay_ms;
> +/*
> + * A default time for checking the need for non urgent BKOPS once mmcqd
> + * is idle.
> + */
> +#define MMC_IDLE_BKOPS_TIME_MS 2000
> +	struct work_struct	poll_for_completion;
> +/* Polling timeout and interval for waiting on non-blocking BKOPs completion */
> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
> +	bool			cancel_delayed_work;
> +	bool			started_delayed_bkops;
> +	unsigned int		sectors_changed;
> +};
> +
>  /*
>   * MMC device
>   */
> @@ -276,6 +309,8 @@ struct mmc_card {
>  	struct dentry		*debugfs_root;
>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>  	unsigned int    nr_parts;
> +
> +	struct mmc_bkops_info	bkops_info;
>  };
>  
>  /*
> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
> index 9b9cdaf..665d345 100644
> --- a/include/linux/mmc/core.h
> +++ b/include/linux/mmc/core.h
> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>  	struct mmc_command *, int);
>  extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>  
> 

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[merez]

Hi Jaehoon,

With this patch we don't expect to see any degradation. Thanks for
verifying that.
The test plan would be to run the lmdd and iozone benchmarks with this
patch and verify that the performance is not degraded.
I verified it with the msm_sdcc controller.

Chris - We do expect it to influence the battery consumption, since we now
delay getting into suspend (since mmc_start_bkops which is called after
the delayed work is executed claims the host).
The solution for that should be done by the controller which can shorten
the timeout given to pm_schedule_suspend by the periodic BKOPS idle time.
Does it make sense to you?

Thanks,
Maya
On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
> Hi Maya,
>
> Thank you a lot for working idle time BKOPS.
>
> I tested with this patch. It's working fine.(Suspend/resume is also
> working well.)
> Test controller is sdhci controller.
> When i tested the performance with iozone, i didn't find that performance
> is decreased.
> Well, as Chris is mentioned, do you have any test plan?
> So I will test more with this patch, because i want to test with dw-mmc
> controller, too.
>
> On 11/25/2012 08:56 PM, Maya Erez wrote:
>> Devices have various maintenance operations need to perform internally.
>> In order to reduce latencies during time critical operations like read
>> and write, it is better to execute maintenance operations in other
>> times - when the host is not being serviced. Such operations are called
>> Background operations (BKOPS).
>> The device notifies the status of the BKOPS need by updating
>> BKOPS_STATUS
>> (EXT_CSD byte [246]).
>>
>> According to the standard a host that supports BKOPS shall check the
>> status periodically and start background operations as needed, so that
>> the device has enough time for its maintenance operations.
>>
>> This patch adds support for this periodic check of the BKOPS status.
>> Since foreground operations are of higher priority than background
>> operations the host will check the need for BKOPS when it is idle,
>> and in case of an incoming request the BKOPS operation will be
>> interrupted.
>>
>> When the mmcqd thread is idle, a delayed work is created to check the
>> need for BKOPS. The time to start the delayed work is calculated based
>> on the host controller suspend timeout, in case it was set. If not, a
>> default time is used.
>> If BKOPS are required in level 1, which is non-blocking, there will be
>> polling of the card status to wait for the BKOPS completion and prevent
>> suspend that will interrupt the BKOPS.
>> If the card raised an exception, the need for urgent BKOPS (level 2/3)
>> will be checked immediately and if needed, the BKOPS will be performed
>> without waiting for the next idle time.
>>
>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>
>> ---
>> This patch is based on the periodic BKOPS implementation in version 8 of
>> "support BKOPS feature for eMMC" patch.
>> The patch was modified to answer the following issues:
>> - In order to prevent a race condition between going into suspend and
>> starting BKOPS,
>>   the suspend timeout of the host controller is taking into accound in
>> determination of the start time
>>   of the delayed work
>> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host
>> was moved to the beginning of the function
>> - Also, the check of doing_bkops should be protected when determing if
>> an HPI is needed due to the same reason.
>>
>> Changes in v3:
>>     - Move the call to stop_bkops to block.c.
>>       This allows us to remove the mmc_claim_host from inside the
>> function and doesn't cause additional degradation
>>       due to un-neccessary calim host operation
>>
>> Changes in v2:
>>     - Check the number of written / discarded sectors as the trigger for
>> checking the BKOPS need.
>>     - Code review fixes
>>
>> ---
>>  drivers/mmc/card/block.c |    8 ++-
>>  drivers/mmc/card/queue.c |    2 +
>>  drivers/mmc/core/core.c  |  178
>> +++++++++++++++++++++++++++++++++++++++++++---
>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>  include/linux/mmc/card.h |   35 +++++++++
>>  include/linux/mmc/core.h |    3 +
>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>
>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>> index 172a768..40b4ae3 100644
>> --- a/drivers/mmc/card/block.c
>> +++ b/drivers/mmc/card/block.c
>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq,
>> struct request *req)
>>  	struct mmc_blk_data *md = mq->data;
>>  	struct mmc_card *card = md->queue.card;
>>
>> -	if (req && !mq->mqrq_prev->req)
>> +	if (req && !mq->mqrq_prev->req) {
>>  		/* claim host only for the first request */
>>  		mmc_claim_host(card->host);
>> +		if (card->ext_csd.bkops_en &&
>> +		    card->bkops_info.started_delayed_bkops) {
>> +				card->bkops_info.started_delayed_bkops = false;
>> +				mmc_stop_bkops(card);
> We didn't need to check whether mmc_stop_bkops is success or not?
> If mmc_stop_bkops() is failed, then bkops is continuously running.
>
> Best Regards,
> Jaehoon Chung
>
>> +		}
>> +	}
>>
>>  	ret = mmc_blk_part_switch(card, md);
>>  	if (ret) {
>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>> index fadf52e..9d0c96a 100644
>> --- a/drivers/mmc/card/queue.c
>> +++ b/drivers/mmc/card/queue.c
>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>  {
>>  	struct mmc_queue *mq = d;
>>  	struct request_queue *q = mq->queue;
>> +	struct mmc_card *card = mq->card;
>>
>>  	current->flags |= PF_MEMALLOC;
>>
>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>  				set_current_state(TASK_RUNNING);
>>  				break;
>>  			}
>> +			mmc_start_delayed_bkops(card);
>>  			up(&mq->thread_sem);
>>  			schedule();
>>  			down(&mq->thread_sem);
>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>> index 06c42cf..72ae15b 100644
>> --- a/drivers/mmc/core/core.c
>> +++ b/drivers/mmc/core/core.c
>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>> mmc_request *mrq)
>>  }
>>
>>  /**
>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>> + *      the need of non urgent BKOPS
>> + *
>> + * @card: MMC card to start BKOPS on
>> + */
>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>> +{
>> +	if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>> +		return;
>> +
>> +	pr_debug("%s: %s: queueing delayed_bkops_work\n",
>> +		 mmc_hostname(card->host), __func__);
>> +
>> +	/*
>> +	 * cancel_delayed_bkops_work will prevent a race condition between
>> +	 * fetching a request by the mmcqd and the delayed work, in case
>> +	 * it was removed from the queue work but not started yet
>> +	 */
>> +	card->bkops_info.cancel_delayed_work = false;
>> +	card->bkops_info.started_delayed_bkops = true;
>> +	queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>> +			   msecs_to_jiffies(
>> +				   card->bkops_info.delay_ms));
>> +}
>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>> +
>> +/**
>>   *	mmc_start_bkops - start BKOPS for supported cards
>>   *	@card: MMC card to start BKOPS
>> - *	@form_exception: A flag to indicate if this function was
>> + *	@from_exception: A flag to indicate if this function was
>>   *			 called due to an exception raised by the card
>>   *
>>   *	Start background operations whenever requested.
>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception)
>>  	bool use_busy_signal;
>>
>>  	BUG_ON(!card);
>> -
>> -	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>> +	if (!card->ext_csd.bkops_en)
>>  		return;
>>
>> +	mmc_claim_host(card->host);
>> +
>> +	if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
>> +		pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>> +			 mmc_hostname(card->host), __func__);
>> +		card->bkops_info.cancel_delayed_work = false;
>> +		goto out;
>> +	}
>> +
>> +	if (mmc_card_doing_bkops(card)) {
>> +		pr_debug("%s: %s: already doing bkops, exit\n",
>> +			 mmc_hostname(card->host), __func__);
>> +		goto out;
>> +	}
>> +
>>  	err = mmc_read_bkops_status(card);
>>  	if (err) {
>>  		pr_err("%s: Failed to read bkops status: %d\n",
>>  		       mmc_hostname(card->host), err);
>> -		return;
>> +		goto out;
>>  	}
>>
>>  	if (!card->ext_csd.raw_bkops_status)
>> -		return;
>> +		goto out;
>>
>> +	pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>> +		mmc_hostname(card->host), __func__,
>> +		card->ext_csd.raw_bkops_status);
>> +
>> +	/*
>> +	 * If the function was called due to exception but there is no need
>> +	 * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
>> +	 * work, before going to suspend
>> +	 */
>>  	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>  	    from_exception)
>> -		return;
>> +		goto out;
>>
>> -	mmc_claim_host(card->host);
>>  	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>  		timeout = MMC_BKOPS_MAX_TIMEOUT;
>>  		use_busy_signal = true;
>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception)
>>  	 * bkops executed synchronously, otherwise
>>  	 * the operation is in progress
>>  	 */
>> -	if (!use_busy_signal)
>> +	if (!use_busy_signal) {
>>  		mmc_card_set_doing_bkops(card);
>> +		pr_debug("%s: %s: starting the polling thread\n",
>> +			 mmc_hostname(card->host), __func__);
>> +		queue_work(system_nrt_wq,
>> +			   &card->bkops_info.poll_for_completion);
>> +	}
>> +
>>  out:
>>  	mmc_release_host(card->host);
>>  }
>>  EXPORT_SYMBOL(mmc_start_bkops);
>>
>> +/**
>> + * mmc_bkops_completion_polling() - Poll on the card status to
>> + * wait for the non-blocking BKOPS completion
>> + * @work:	The completion polling work
>> + *
>> + * The on-going reading of the card status will prevent the card
>> + * from getting into suspend while it is in the middle of
>> + * performing BKOPS.
>> + * Since the non blocking BKOPS can be interrupted by a fetched
>> + * request we also check IF mmc_card_doing_bkops in each
>> + * iteration.
>> + */
>> +void mmc_bkops_completion_polling(struct work_struct *work)
>> +{
>> +	struct mmc_card *card = container_of(work, struct mmc_card,
>> +			bkops_info.poll_for_completion);
>> +	unsigned long timeout_jiffies = jiffies +
>> +		msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>> +	u32 status;
>> +	int err;
>> +
>> +	/*
>> +	 * Wait for the BKOPs to complete. Keep reading the status to prevent
>> +	 * the host from getting into suspend
>> +	 */
>> +	do {
>> +		mmc_claim_host(card->host);
>> +
>> +		if (!mmc_card_doing_bkops(card))
>> +			goto out;
>> +
>> +		err = mmc_send_status(card, &status);
>> +		if (err) {
>> +			pr_err("%s: error %d requesting status\n",
>> +			       mmc_hostname(card->host), err);
>> +			goto out;
>> +		}
>> +
>> +		/*
>> +		 * Some cards mishandle the status bits, so make sure to check
>> +		 * both the busy indication and the card state.
>> +		 */
>> +		if ((status & R1_READY_FOR_DATA) &&
>> +		    (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>> +			pr_debug("%s: %s: completed BKOPs, exit polling\n",
>> +				 mmc_hostname(card->host), __func__);
>> +			mmc_card_clr_doing_bkops(card);
>> +			card->bkops_info.started_delayed_bkops = false;
>> +			goto out;
>> +		}
>> +
>> +		mmc_release_host(card->host);
>> +
>> +		/*
>> +		 * Sleep before checking the card status again to allow the
>> +		 * card to complete the BKOPs operation
>> +		 */
>> +		msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>> +	} while (time_before(jiffies, timeout_jiffies));
>> +
>> +	pr_err("%s: %s: exit polling due to timeout\n",
>> +	       mmc_hostname(card->host), __func__);
>> +
>> +	return;
>> +out:
>> +	mmc_release_host(card->host);
>> +}
>> +
>> +/**
>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>> + * needed
>> + * @work:	The idle time BKOPS work
>> + */
>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>> +{
>> +	struct mmc_card *card = container_of(work, struct mmc_card,
>> +			bkops_info.dw.work);
>> +
>> +	/*
>> +	 * Prevent a race condition between mmc_stop_bkops and the delayed
>> +	 * BKOPS work in case the delayed work is executed on another CPU
>> +	 */
>> +	if (card->bkops_info.cancel_delayed_work)
>> +		return;
>> +
>> +	mmc_start_bkops(card, false);
>> +}
>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>> +
>>  static void mmc_wait_done(struct mmc_request *mrq)
>>  {
>>  	complete(&mrq->completion);
>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>  	int err = 0;
>>
>>  	BUG_ON(!card);
>> +
>> +	/*
>> +	 * Notify the delayed work to be cancelled, in case it was already
>> +	 * removed from the queue, but was not started yet
>> +	 */
>> +	card->bkops_info.cancel_delayed_work = true;
>> +	if (delayed_work_pending(&card->bkops_info.dw))
>> +		cancel_delayed_work_sync(&card->bkops_info.dw);
>> +	if (!mmc_card_doing_bkops(card))
>> +		goto out;
>> +
>>  	err = mmc_interrupt_hpi(card);
>>
>>  	/*
>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>  		err = 0;
>>  	}
>>
>> +out:
>>  	return err;
>>  }
>>  EXPORT_SYMBOL(mmc_stop_bkops);
>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>> *notify_block,
>>  	switch (mode) {
>>  	case PM_HIBERNATION_PREPARE:
>>  	case PM_SUSPEND_PREPARE:
>> -		if (host->card && mmc_card_mmc(host->card) &&
>> -		    mmc_card_doing_bkops(host->card)) {
>> +		if (host->card && mmc_card_mmc(host->card)) {
>> +			mmc_claim_host(host);
>>  			err = mmc_stop_bkops(host->card);
>> +			mmc_release_host(host);
>>  			if (err) {
>>  				pr_err("%s: didn't stop bkops\n",
>>  					mmc_hostname(host));
>>  				return err;
>>  			}
>> -			mmc_card_clr_doing_bkops(host->card);
>>  		}
>>
>>  		spin_lock_irqsave(&host->lock, flags);
>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>> index 7cc4638..dba76e3 100644
>> --- a/drivers/mmc/core/mmc.c
>> +++ b/drivers/mmc/core/mmc.c
>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host *host,
>> u32 ocr,
>>  		}
>>  	}
>>
>> +	if (!oldcard) {
>> +		if (card->ext_csd.bkops_en) {
>> +			INIT_DELAYED_WORK(&card->bkops_info.dw,
>> +					  mmc_start_idle_time_bkops);
>> +			INIT_WORK(&card->bkops_info.poll_for_completion,
>> +				  mmc_bkops_completion_polling);
>> +
>> +			/*
>> +			 * Calculate the time to start the BKOPs checking.
>> +			 * The idle time of the host controller should be taken
>> +			 * into account in order to prevent a race condition
>> +			 * before starting BKOPs and going into suspend.
>> +			 * If the host controller didn't set its idle time,
>> +			 * a default value is used.
>> +			 */
>> +			card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
>> +			if (card->bkops_info.host_suspend_tout_ms)
>> +				card->bkops_info.delay_ms = min(
>> +					card->bkops_info.delay_ms,
>> +				      card->bkops_info.host_suspend_tout_ms/2);
>> +		}
>> +	}
>> +
>>  	if (!oldcard)
>>  		host->card = card;
>>
>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>> index 943550d..224e2a5 100644
>> --- a/include/linux/mmc/card.h
>> +++ b/include/linux/mmc/card.h
>> @@ -208,6 +208,39 @@ struct mmc_part {
>>  #define MMC_BLK_DATA_AREA_GP	(1<<2)
>>  };
>>
>> +/**
>> + * struct mmc_bkops_info - BKOPS data
>> + * @dw:	Idle time bkops delayed work
>> + * @host_suspend_tout_ms:	The host controller idle time,
>> + * before getting into suspend
>> + * @delay_ms:	The time to start the BKOPS
>> + *        delayed work once MMC thread is idle
>> + * @poll_for_completion:	Poll on BKOPS completion
>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>> + *        should be cancelled
>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>> + *        work was scheduled
>> + * @sectors_changed:  number of  sectors written or
>> + *       discard since the last idle BKOPS were scheduled
>> + */
>> +struct mmc_bkops_info {
>> +	struct delayed_work	dw;
>> +	unsigned int		host_suspend_tout_ms;
>> +	unsigned int		delay_ms;
>> +/*
>> + * A default time for checking the need for non urgent BKOPS once mmcqd
>> + * is idle.
>> + */
>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>> +	struct work_struct	poll_for_completion;
>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>> completion */
>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>> +	bool			cancel_delayed_work;
>> +	bool			started_delayed_bkops;
>> +	unsigned int		sectors_changed;
>> +};
>> +
>>  /*
>>   * MMC device
>>   */
>> @@ -276,6 +309,8 @@ struct mmc_card {
>>  	struct dentry		*debugfs_root;
>>  	struct mmc_part	part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>>  	unsigned int    nr_parts;
>> +
>> +	struct mmc_bkops_info	bkops_info;
>>  };
>>
>>  /*
>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>> index 9b9cdaf..665d345 100644
>> --- a/include/linux/mmc/core.h
>> +++ b/include/linux/mmc/core.h
>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>> mmc_card *);
>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>>  	struct mmc_command *, int);
>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>> from_exception);
>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
>> bool);
>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>
>>
>
>


-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Ulf Hansson]

On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
> Hi Jaehoon,
>
> With this patch we don't expect to see any degradation. Thanks for
> verifying that.
> The test plan would be to run the lmdd and iozone benchmarks with this
> patch and verify that the performance is not degraded.
> I verified it with the msm_sdcc controller.
>
> Chris - We do expect it to influence the battery consumption, since we now
> delay getting into suspend (since mmc_start_bkops which is called after
> the delayed work is executed claims the host).
> The solution for that should be done by the controller which can shorten
> the timeout given to pm_schedule_suspend by the periodic BKOPS idle time.
> Does it make sense to you?
>
> Thanks,
> Maya
> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>> Hi Maya,
>>
>> Thank you a lot for working idle time BKOPS.
>>
>> I tested with this patch. It's working fine.(Suspend/resume is also
>> working well.)
>> Test controller is sdhci controller.
>> When i tested the performance with iozone, i didn't find that performance
>> is decreased.
>> Well, as Chris is mentioned, do you have any test plan?
>> So I will test more with this patch, because i want to test with dw-mmc
>> controller, too.
>>
>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>> Devices have various maintenance operations need to perform internally.
>>> In order to reduce latencies during time critical operations like read
>>> and write, it is better to execute maintenance operations in other
>>> times - when the host is not being serviced. Such operations are called
>>> Background operations (BKOPS).
>>> The device notifies the status of the BKOPS need by updating
>>> BKOPS_STATUS
>>> (EXT_CSD byte [246]).
>>>
>>> According to the standard a host that supports BKOPS shall check the
>>> status periodically and start background operations as needed, so that
>>> the device has enough time for its maintenance operations.
>>>
>>> This patch adds support for this periodic check of the BKOPS status.
>>> Since foreground operations are of higher priority than background
>>> operations the host will check the need for BKOPS when it is idle,
>>> and in case of an incoming request the BKOPS operation will be
>>> interrupted.
>>>
>>> When the mmcqd thread is idle, a delayed work is created to check the
>>> need for BKOPS. The time to start the delayed work is calculated based
>>> on the host controller suspend timeout, in case it was set. If not, a
>>> default time is used.

What host controller suspend timeout are you referring to here?

If you are thinking of the runtime PM autosuspend timeout used in many
host driver, then you might have missunderstand how runtime PM is used
in host drivers.
This has nothing to do with BKOPS as such, unless you think that the
card must be kept clocked during BKOPS operations, but then this needs
to be stated somewhere in this patch and that is not the case.

Moreover, I could not find any new timeout added for the _host_ struct
in this patch.

>>> If BKOPS are required in level 1, which is non-blocking, there will be
>>> polling of the card status to wait for the BKOPS completion and prevent
>>> suspend that will interrupt the BKOPS.

Not sure of what suspend you are talking about here. But for sure
BKOPS must _never_ prevent a system suspend.

You might want to prevent a host from being runtime suspended though,
but that is not accomplished in this patch.

>>> If the card raised an exception, the need for urgent BKOPS (level 2/3)
>>> will be checked immediately and if needed, the BKOPS will be performed
>>> without waiting for the next idle time.
>>>
>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>
>>> ---
>>> This patch is based on the periodic BKOPS implementation in version 8 of
>>> "support BKOPS feature for eMMC" patch.
>>> The patch was modified to answer the following issues:
>>> - In order to prevent a race condition between going into suspend and
>>> starting BKOPS,
>>>   the suspend timeout of the host controller is taking into accound in
>>> determination of the start time
>>>   of the delayed work
>>> - Since mmc_start_bkops is called from two contexts now, mmc_claim_host
>>> was moved to the beginning of the function
>>> - Also, the check of doing_bkops should be protected when determing if
>>> an HPI is needed due to the same reason.
>>>
>>> Changes in v3:
>>>     - Move the call to stop_bkops to block.c.
>>>       This allows us to remove the mmc_claim_host from inside the
>>> function and doesn't cause additional degradation
>>>       due to un-neccessary calim host operation
>>>
>>> Changes in v2:
>>>     - Check the number of written / discarded sectors as the trigger for
>>> checking the BKOPS need.
>>>     - Code review fixes
>>>
>>> ---
>>>  drivers/mmc/card/block.c |    8 ++-
>>>  drivers/mmc/card/queue.c |    2 +
>>>  drivers/mmc/core/core.c  |  178
>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>  include/linux/mmc/card.h |   35 +++++++++
>>>  include/linux/mmc/core.h |    3 +
>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>
>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>> index 172a768..40b4ae3 100644
>>> --- a/drivers/mmc/card/block.c
>>> +++ b/drivers/mmc/card/block.c
>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq,
>>> struct request *req)
>>>      struct mmc_blk_data *md = mq->data;
>>>      struct mmc_card *card = md->queue.card;
>>>
>>> -    if (req && !mq->mqrq_prev->req)
>>> +    if (req && !mq->mqrq_prev->req) {
>>>              /* claim host only for the first request */
>>>              mmc_claim_host(card->host);
>>> +            if (card->ext_csd.bkops_en &&
>>> +                card->bkops_info.started_delayed_bkops) {
>>> +                            card->bkops_info.started_delayed_bkops = false;
>>> +                            mmc_stop_bkops(card);
>> We didn't need to check whether mmc_stop_bkops is success or not?
>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>
>> Best Regards,
>> Jaehoon Chung
>>
>>> +            }
>>> +    }
>>>
>>>      ret = mmc_blk_part_switch(card, md);
>>>      if (ret) {
>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>> index fadf52e..9d0c96a 100644
>>> --- a/drivers/mmc/card/queue.c
>>> +++ b/drivers/mmc/card/queue.c
>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>>  {
>>>      struct mmc_queue *mq = d;
>>>      struct request_queue *q = mq->queue;
>>> +    struct mmc_card *card = mq->card;
>>>
>>>      current->flags |= PF_MEMALLOC;
>>>
>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>                              set_current_state(TASK_RUNNING);
>>>                              break;
>>>                      }
>>> +                    mmc_start_delayed_bkops(card);
>>>                      up(&mq->thread_sem);
>>>                      schedule();
>>>                      down(&mq->thread_sem);
>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>> index 06c42cf..72ae15b 100644
>>> --- a/drivers/mmc/core/core.c
>>> +++ b/drivers/mmc/core/core.c
>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>> mmc_request *mrq)
>>>  }
>>>
>>>  /**
>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>> + *      the need of non urgent BKOPS
>>> + *
>>> + * @card: MMC card to start BKOPS on
>>> + */
>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>> +{
>>> +    if (!card || !card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>> +            return;
>>> +
>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>> +             mmc_hostname(card->host), __func__);
>>> +
>>> +    /*
>>> +     * cancel_delayed_bkops_work will prevent a race condition between
>>> +     * fetching a request by the mmcqd and the delayed work, in case
>>> +     * it was removed from the queue work but not started yet
>>> +     */
>>> +    card->bkops_info.cancel_delayed_work = false;
>>> +    card->bkops_info.started_delayed_bkops = true;
>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>> +                       msecs_to_jiffies(
>>> +                               card->bkops_info.delay_ms));
>>> +}
>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>> +
>>> +/**
>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>   *  @card: MMC card to start BKOPS
>>> - *  @form_exception: A flag to indicate if this function was
>>> + *  @from_exception: A flag to indicate if this function was
>>>   *                   called due to an exception raised by the card
>>>   *
>>>   *  Start background operations whenever requested.
>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
>>> from_exception)
>>>      bool use_busy_signal;
>>>
>>>      BUG_ON(!card);
>>> -
>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>> +    if (!card->ext_csd.bkops_en)
>>>              return;
>>>
>>> +    mmc_claim_host(card->host);
>>> +
>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>> +                     mmc_hostname(card->host), __func__);
>>> +            card->bkops_info.cancel_delayed_work = false;
>>> +            goto out;
>>> +    }
>>> +
>>> +    if (mmc_card_doing_bkops(card)) {
>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>> +                     mmc_hostname(card->host), __func__);
>>> +            goto out;
>>> +    }
>>> +
>>>      err = mmc_read_bkops_status(card);
>>>      if (err) {
>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>                     mmc_hostname(card->host), err);
>>> -            return;
>>> +            goto out;
>>>      }
>>>
>>>      if (!card->ext_csd.raw_bkops_status)
>>> -            return;
>>> +            goto out;
>>>
>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>> +            mmc_hostname(card->host), __func__,
>>> +            card->ext_csd.raw_bkops_status);
>>> +
>>> +    /*
>>> +     * If the function was called due to exception but there is no need
>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
>>> +     * work, before going to suspend
>>> +     */
>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>          from_exception)
>>> -            return;
>>> +            goto out;
>>>
>>> -    mmc_claim_host(card->host);
>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>              use_busy_signal = true;
>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card, bool
>>> from_exception)
>>>       * bkops executed synchronously, otherwise
>>>       * the operation is in progress
>>>       */
>>> -    if (!use_busy_signal)
>>> +    if (!use_busy_signal) {
>>>              mmc_card_set_doing_bkops(card);
>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>> +                     mmc_hostname(card->host), __func__);
>>> +            queue_work(system_nrt_wq,
>>> +                       &card->bkops_info.poll_for_completion);
>>> +    }
>>> +
>>>  out:
>>>      mmc_release_host(card->host);
>>>  }
>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>
>>> +/**
>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>> + * wait for the non-blocking BKOPS completion
>>> + * @work:   The completion polling work
>>> + *
>>> + * The on-going reading of the card status will prevent the card
>>> + * from getting into suspend while it is in the middle of
>>> + * performing BKOPS.

Not true! Suspend will not be prevented by doing a mmc_send_status.
Moreover, I would be interested to understand more about why you need
to prevent "suspend". Please elaborate why you think this is needed.

>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>> + * request we also check IF mmc_card_doing_bkops in each
>>> + * iteration.
>>> + */
>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>> +{
>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>> +                    bkops_info.poll_for_completion);
>>> +    unsigned long timeout_jiffies = jiffies +
>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>> +    u32 status;
>>> +    int err;
>>> +
>>> +    /*
>>> +     * Wait for the BKOPs to complete. Keep reading the status to prevent
>>> +     * the host from getting into suspend
>>> +     */
>>> +    do {
>>> +            mmc_claim_host(card->host);
>>> +
>>> +            if (!mmc_card_doing_bkops(card))
>>> +                    goto out;
>>> +
>>> +            err = mmc_send_status(card, &status);
>>> +            if (err) {
>>> +                    pr_err("%s: error %d requesting status\n",
>>> +                           mmc_hostname(card->host), err);
>>> +                    goto out;
>>> +            }
>>> +
>>> +            /*
>>> +             * Some cards mishandle the status bits, so make sure to check
>>> +             * both the busy indication and the card state.
>>> +             */
>>> +            if ((status & R1_READY_FOR_DATA) &&
>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>> +                    pr_debug("%s: %s: completed BKOPs, exit polling\n",
>>> +                             mmc_hostname(card->host), __func__);
>>> +                    mmc_card_clr_doing_bkops(card);
>>> +                    card->bkops_info.started_delayed_bkops = false;
>>> +                    goto out;
>>> +            }
>>> +
>>> +            mmc_release_host(card->host);
>>> +
>>> +            /*
>>> +             * Sleep before checking the card status again to allow the
>>> +             * card to complete the BKOPs operation
>>> +             */
>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>> +    } while (time_before(jiffies, timeout_jiffies));
>>> +
>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>> +           mmc_hostname(card->host), __func__);
>>> +
>>> +    return;
>>> +out:
>>> +    mmc_release_host(card->host);
>>> +}
>>> +
>>> +/**
>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>> + * needed
>>> + * @work:   The idle time BKOPS work
>>> + */
>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>> +{
>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>> +                    bkops_info.dw.work);
>>> +
>>> +    /*
>>> +     * Prevent a race condition between mmc_stop_bkops and the delayed
>>> +     * BKOPS work in case the delayed work is executed on another CPU
>>> +     */
>>> +    if (card->bkops_info.cancel_delayed_work)
>>> +            return;
>>> +
>>> +    mmc_start_bkops(card, false);
>>> +}
>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>> +
>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>  {
>>>      complete(&mrq->completion);
>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>      int err = 0;
>>>
>>>      BUG_ON(!card);
>>> +
>>> +    /*
>>> +     * Notify the delayed work to be cancelled, in case it was already
>>> +     * removed from the queue, but was not started yet
>>> +     */
>>> +    card->bkops_info.cancel_delayed_work = true;
>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>> +    if (!mmc_card_doing_bkops(card))
>>> +            goto out;
>>> +
>>>      err = mmc_interrupt_hpi(card);
>>>
>>>      /*
>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>              err = 0;
>>>      }
>>>
>>> +out:
>>>      return err;
>>>  }
>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>> *notify_block,
>>>      switch (mode) {
>>>      case PM_HIBERNATION_PREPARE:
>>>      case PM_SUSPEND_PREPARE:
>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>> -                mmc_card_doing_bkops(host->card)) {
>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>> +                    mmc_claim_host(host);
>>>                      err = mmc_stop_bkops(host->card);
>>> +                    mmc_release_host(host);

This code seems a bit strange. You will check for mmc_card_mmc, but
not all (e)MMC will support bkops. How about acually just checking if
bkops is "on" or "off" somehow.

Additionally, so this piece of code shall stop an ongoing bkops before
going to suspend, so that make sense. But would it not be more
meaningfull to take care of that in mmc_suspend_host? I mean why do yo
need to do it in the PM_SUSPEND_PREPARE notification sequence
especially?

>>>                      if (err) {
>>>                              pr_err("%s: didn't stop bkops\n",
>>>                                      mmc_hostname(host));
>>>                              return err;
>>>                      }
>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>              }
>>>
>>>              spin_lock_irqsave(&host->lock, flags);
>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>> index 7cc4638..dba76e3 100644
>>> --- a/drivers/mmc/core/mmc.c
>>> +++ b/drivers/mmc/core/mmc.c
>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host *host,
>>> u32 ocr,
>>>              }
>>>      }
>>>
>>> +    if (!oldcard) {
>>> +            if (card->ext_csd.bkops_en) {
>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>> +                                      mmc_start_idle_time_bkops);
>>> +                    INIT_WORK(&card->bkops_info.poll_for_completion,
>>> +                              mmc_bkops_completion_polling);

I guess you don't have "removable" eMMC with BKOPS support so this
code will in practice only be executed once for an eMMC, so we are
safe. But still I am not fond of putting this code for workqueue here.
Either that should be done as a part of when the card is
created/deleted or when then host is created/deleted.

>>> +
>>> +                    /*
>>> +                     * Calculate the time to start the BKOPs checking.
>>> +                     * The idle time of the host controller should be taken
>>> +                     * into account in order to prevent a race condition
>>> +                     * before starting BKOPs and going into suspend.
>>> +                     * If the host controller didn't set its idle time,
>>> +                     * a default value is used.
>>> +                     */
>>> +                    card->bkops_info.delay_ms = MMC_IDLE_BKOPS_TIME_MS;
>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>> +                            card->bkops_info.delay_ms = min(
>>> +                                    card->bkops_info.delay_ms,
>>> +                                  card->bkops_info.host_suspend_tout_ms/2);
>>> +            }
>>> +    }
>>> +
>>>      if (!oldcard)
>>>              host->card = card;
>>>
>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>> index 943550d..224e2a5 100644
>>> --- a/include/linux/mmc/card.h
>>> +++ b/include/linux/mmc/card.h
>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>  };
>>>
>>> +/**
>>> + * struct mmc_bkops_info - BKOPS data
>>> + * @dw:     Idle time bkops delayed work
>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>> + * before getting into suspend
>>> + * @delay_ms:       The time to start the BKOPS
>>> + *        delayed work once MMC thread is idle
>>> + * @poll_for_completion:    Poll on BKOPS completion
>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>> + *        should be cancelled
>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>> + *        work was scheduled
>>> + * @sectors_changed:  number of  sectors written or
>>> + *       discard since the last idle BKOPS were scheduled
>>> + */
>>> +struct mmc_bkops_info {
>>> +    struct delayed_work     dw;
>>> +    unsigned int            host_suspend_tout_ms;

As stated earlier, what is this timeout you are referring to? What suspend?

>>> +    unsigned int            delay_ms;
>>> +/*
>>> + * A default time for checking the need for non urgent BKOPS once mmcqd
>>> + * is idle.
>>> + */
>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>> +    struct work_struct      poll_for_completion;
>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>> completion */
>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>> +    bool                    cancel_delayed_work;
>>> +    bool                    started_delayed_bkops;
>>> +    unsigned int            sectors_changed;

Could not find "sectors_changed" being used. Maybe you forgot to
remove this from previous version of the patch.

>>> +};
>>> +
>>>  /*
>>>   * MMC device
>>>   */
>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>      struct dentry           *debugfs_root;
>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
>>>      unsigned int    nr_parts;
>>> +
>>> +    struct mmc_bkops_info   bkops_info;
>>>  };
>>>
>>>  /*
>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>> index 9b9cdaf..665d345 100644
>>> --- a/include/linux/mmc/core.h
>>> +++ b/include/linux/mmc/core.h
>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>> mmc_card *);
>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>>>      struct mmc_command *, int);
>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>> from_exception);
>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
>>> bool);
>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>
>>>
>>
>>
>
>
> --
> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
> of Code Aurora Forum, hosted by The Linux Foundation
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/

Finally some overall thoughts. What I would like to understand is how
we decide that the card has become "idle". I belive two values should
be considered, but are they?
1. The card need BKOPS to be performed for some status level.
2. Request inactivity for a certain timeout has occured.

Have you considered to use runtime PM for the card device instead of
the workqueue?

Kind regards
Ulf Hansson

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[merez]

Hi Ulf,

Let me try to better explain:
The idea behind the periodic BKOPS is to check the card's need for BKOPS
periodically in order to prevent an urgent BKOPS need by the card.
In order to actually manage to prevent the urgent BKOPS need, the host
should give the card enough time to perform the BKOPS (when it recognizes
BKOPS need), otherwise there is no point in having the periodic BKOPS.
The above results in the following:
1. After starting non-urgent BKOPS we "delay" getting into suspend by
polling on the card's status (explanation below), in order to give the
card time to perform the BKOPS. This has no effect on the power
consumption since the same BKOPS operations that were performed after the
foregound operation just moved to another location, meaning before going
into suspend.
2. Using PM_SUSPEND_PREPARE instead of the workqueue would not be
efficient since we don't want to wait until the host is ready to get into
suspend and then prevent him from suspending by doing BKOPS operations
that can take a long time. It is better to start the BKOPS earlier.

I am not too familiar with the controllers code and also my understanding
in runtime suspend is very basic, so feel free to correct me if I'm wrong
here or the behavior in other controllers is different from msm_sdcc.
mmc_claim_host calls host->ops->enable. This API is implemented per
controller but as far as I understand it, this API must prevent suspend,
otherwise we might go into suspend while there is bus activity. By doing
get_card_status we call mmc_claim_host and this call is the one that
"delays" getting into suspend.
If this is not the case in other controllers than the BKOPS will not
prevent the suspend and BKOPS will be interrupted.
As for the effect on the battery consumption, this is probably something
specific to our controller, so sorry if I created a confusion.

Additional comments inline.

Thanks,
Maya

On Tue, December 4, 2012 1:52 am, Ulf Hansson wrote:
> On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
>> Hi Jaehoon,
>>
>> With this patch we don't expect to see any degradation. Thanks for
>> verifying that.
>> The test plan would be to run the lmdd and iozone benchmarks with this
>> patch and verify that the performance is not degraded.
>> I verified it with the msm_sdcc controller.
>>
>> Chris - We do expect it to influence the battery consumption, since we
>> now
>> delay getting into suspend (since mmc_start_bkops which is called after
>> the delayed work is executed claims the host).
>> The solution for that should be done by the controller which can shorten
>> the timeout given to pm_schedule_suspend by the periodic BKOPS idle
>> time.
>> Does it make sense to you?
>>
>> Thanks,
>> Maya
>> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>>> Hi Maya,
>>>
>>> Thank you a lot for working idle time BKOPS.
>>>
>>> I tested with this patch. It's working fine.(Suspend/resume is also
>>> working well.)
>>> Test controller is sdhci controller.
>>> When i tested the performance with iozone, i didn't find that
>>> performance
>>> is decreased.
>>> Well, as Chris is mentioned, do you have any test plan?
>>> So I will test more with this patch, because i want to test with dw-mmc
>>> controller, too.
>>>
>>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>>> Devices have various maintenance operations need to perform
>>>> internally.
>>>> In order to reduce latencies during time critical operations like read
>>>> and write, it is better to execute maintenance operations in other
>>>> times - when the host is not being serviced. Such operations are
>>>> called
>>>> Background operations (BKOPS).
>>>> The device notifies the status of the BKOPS need by updating
>>>> BKOPS_STATUS
>>>> (EXT_CSD byte [246]).
>>>>
>>>> According to the standard a host that supports BKOPS shall check the
>>>> status periodically and start background operations as needed, so that
>>>> the device has enough time for its maintenance operations.
>>>>
>>>> This patch adds support for this periodic check of the BKOPS status.
>>>> Since foreground operations are of higher priority than background
>>>> operations the host will check the need for BKOPS when it is idle,
>>>> and in case of an incoming request the BKOPS operation will be
>>>> interrupted.
>>>>
>>>> When the mmcqd thread is idle, a delayed work is created to check the
>>>> need for BKOPS. The time to start the delayed work is calculated based
>>>> on the host controller suspend timeout, in case it was set. If not, a
>>>> default time is used.
>
> What host controller suspend timeout are you referring to here?
>
> If you are thinking of the runtime PM autosuspend timeout used in many
> host driver, then you might have missunderstand how runtime PM is used
> in host drivers.
> This has nothing to do with BKOPS as such, unless you think that the
> card must be kept clocked during BKOPS operations, but then this needs
> to be stated somewhere in this patch and that is not the case.
>
> Moreover, I could not find any new timeout added for the _host_ struct
> in this patch.
Yes, I was referring to the runtime PM autosuspend timeout. Since we want
to give the BKOPS time to be performed before going into suspend, we need
to take this timeout into account.
>
>>>> If BKOPS are required in level 1, which is non-blocking, there will be
>>>> polling of the card status to wait for the BKOPS completion and
>>>> prevent
>>>> suspend that will interrupt the BKOPS.
>
> Not sure of what suspend you are talking about here. But for sure
> BKOPS must _never_ prevent a system suspend.
>
> You might want to prevent a host from being runtime suspended though,
> but that is not accomplished in this patch.
This is explained in my general comment. Let me know if it is still not
clear.
>
>>>> If the card raised an exception, the need for urgent BKOPS (level 2/3)
>>>> will be checked immediately and if needed, the BKOPS will be performed
>>>> without waiting for the next idle time.
>>>>
>>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>>
>>>> ---
>>>> This patch is based on the periodic BKOPS implementation in version 8
>>>> of
>>>> "support BKOPS feature for eMMC" patch.
>>>> The patch was modified to answer the following issues:
>>>> - In order to prevent a race condition between going into suspend and
>>>> starting BKOPS,
>>>>   the suspend timeout of the host controller is taking into accound in
>>>> determination of the start time
>>>>   of the delayed work
>>>> - Since mmc_start_bkops is called from two contexts now,
>>>> mmc_claim_host
>>>> was moved to the beginning of the function
>>>> - Also, the check of doing_bkops should be protected when determing if
>>>> an HPI is needed due to the same reason.
>>>>
>>>> Changes in v3:
>>>>     - Move the call to stop_bkops to block.c.
>>>>       This allows us to remove the mmc_claim_host from inside the
>>>> function and doesn't cause additional degradation
>>>>       due to un-neccessary calim host operation
>>>>
>>>> Changes in v2:
>>>>     - Check the number of written / discarded sectors as the trigger
>>>> for
>>>> checking the BKOPS need.
>>>>     - Code review fixes
>>>>
>>>> ---
>>>>  drivers/mmc/card/block.c |    8 ++-
>>>>  drivers/mmc/card/queue.c |    2 +
>>>>  drivers/mmc/core/core.c  |  178
>>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>>  include/linux/mmc/card.h |   35 +++++++++
>>>>  include/linux/mmc/core.h |    3 +
>>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>>
>>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>>> index 172a768..40b4ae3 100644
>>>> --- a/drivers/mmc/card/block.c
>>>> +++ b/drivers/mmc/card/block.c
>>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue
>>>> *mq,
>>>> struct request *req)
>>>>      struct mmc_blk_data *md = mq->data;
>>>>      struct mmc_card *card = md->queue.card;
>>>>
>>>> -    if (req && !mq->mqrq_prev->req)
>>>> +    if (req && !mq->mqrq_prev->req) {
>>>>              /* claim host only for the first request */
>>>>              mmc_claim_host(card->host);
>>>> +            if (card->ext_csd.bkops_en &&
>>>> +                card->bkops_info.started_delayed_bkops) {
>>>> +                            card->bkops_info.started_delayed_bkops =
>>>> false;
>>>> +                            mmc_stop_bkops(card);
>>> We didn't need to check whether mmc_stop_bkops is success or not?
>>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>>
>>> Best Regards,
>>> Jaehoon Chung
>>>
>>>> +            }
>>>> +    }
>>>>
>>>>      ret = mmc_blk_part_switch(card, md);
>>>>      if (ret) {
>>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>>> index fadf52e..9d0c96a 100644
>>>> --- a/drivers/mmc/card/queue.c
>>>> +++ b/drivers/mmc/card/queue.c
>>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>>>  {
>>>>      struct mmc_queue *mq = d;
>>>>      struct request_queue *q = mq->queue;
>>>> +    struct mmc_card *card = mq->card;
>>>>
>>>>      current->flags |= PF_MEMALLOC;
>>>>
>>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>>                              set_current_state(TASK_RUNNING);
>>>>                              break;
>>>>                      }
>>>> +                    mmc_start_delayed_bkops(card);
>>>>                      up(&mq->thread_sem);
>>>>                      schedule();
>>>>                      down(&mq->thread_sem);
>>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>>> index 06c42cf..72ae15b 100644
>>>> --- a/drivers/mmc/core/core.c
>>>> +++ b/drivers/mmc/core/core.c
>>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>>> mmc_request *mrq)
>>>>  }
>>>>
>>>>  /**
>>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>>> + *      the need of non urgent BKOPS
>>>> + *
>>>> + * @card: MMC card to start BKOPS on
>>>> + */
>>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>>> +{
>>>> +    if (!card || !card->ext_csd.bkops_en ||
>>>> mmc_card_doing_bkops(card))
>>>> +            return;
>>>> +
>>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>>> +             mmc_hostname(card->host), __func__);
>>>> +
>>>> +    /*
>>>> +     * cancel_delayed_bkops_work will prevent a race condition
>>>> between
>>>> +     * fetching a request by the mmcqd and the delayed work, in case
>>>> +     * it was removed from the queue work but not started yet
>>>> +     */
>>>> +    card->bkops_info.cancel_delayed_work = false;
>>>> +    card->bkops_info.started_delayed_bkops = true;
>>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>>> +                       msecs_to_jiffies(
>>>> +                               card->bkops_info.delay_ms));
>>>> +}
>>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>>> +
>>>> +/**
>>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>>   *  @card: MMC card to start BKOPS
>>>> - *  @form_exception: A flag to indicate if this function was
>>>> + *  @from_exception: A flag to indicate if this function was
>>>>   *                   called due to an exception raised by the card
>>>>   *
>>>>   *  Start background operations whenever requested.
>>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
>>>> from_exception)
>>>>      bool use_busy_signal;
>>>>
>>>>      BUG_ON(!card);
>>>> -
>>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>>> +    if (!card->ext_csd.bkops_en)
>>>>              return;
>>>>
>>>> +    mmc_claim_host(card->host);
>>>> +
>>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
>>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>>> +                     mmc_hostname(card->host), __func__);
>>>> +            card->bkops_info.cancel_delayed_work = false;
>>>> +            goto out;
>>>> +    }
>>>> +
>>>> +    if (mmc_card_doing_bkops(card)) {
>>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>>> +                     mmc_hostname(card->host), __func__);
>>>> +            goto out;
>>>> +    }
>>>> +
>>>>      err = mmc_read_bkops_status(card);
>>>>      if (err) {
>>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>>                     mmc_hostname(card->host), err);
>>>> -            return;
>>>> +            goto out;
>>>>      }
>>>>
>>>>      if (!card->ext_csd.raw_bkops_status)
>>>> -            return;
>>>> +            goto out;
>>>>
>>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>>> +            mmc_hostname(card->host), __func__,
>>>> +            card->ext_csd.raw_bkops_status);
>>>> +
>>>> +    /*
>>>> +     * If the function was called due to exception but there is no
>>>> need
>>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
>>>> +     * work, before going to suspend
>>>> +     */
>>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>>          from_exception)
>>>> -            return;
>>>> +            goto out;
>>>>
>>>> -    mmc_claim_host(card->host);
>>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>>              use_busy_signal = true;
>>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card,
>>>> bool
>>>> from_exception)
>>>>       * bkops executed synchronously, otherwise
>>>>       * the operation is in progress
>>>>       */
>>>> -    if (!use_busy_signal)
>>>> +    if (!use_busy_signal) {
>>>>              mmc_card_set_doing_bkops(card);
>>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>>> +                     mmc_hostname(card->host), __func__);
>>>> +            queue_work(system_nrt_wq,
>>>> +                       &card->bkops_info.poll_for_completion);
>>>> +    }
>>>> +
>>>>  out:
>>>>      mmc_release_host(card->host);
>>>>  }
>>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>>
>>>> +/**
>>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>>> + * wait for the non-blocking BKOPS completion
>>>> + * @work:   The completion polling work
>>>> + *
>>>> + * The on-going reading of the card status will prevent the card
>>>> + * from getting into suspend while it is in the middle of
>>>> + * performing BKOPS.
>
> Not true! Suspend will not be prevented by doing a mmc_send_status.
> Moreover, I would be interested to understand more about why you need
> to prevent "suspend". Please elaborate why you think this is needed.
This is explained in my general comment. Let me know if it is still not
clear.
>
>>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>>> + * request we also check IF mmc_card_doing_bkops in each
>>>> + * iteration.
>>>> + */
>>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>>> +{
>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>> +                    bkops_info.poll_for_completion);
>>>> +    unsigned long timeout_jiffies = jiffies +
>>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>>> +    u32 status;
>>>> +    int err;
>>>> +
>>>> +    /*
>>>> +     * Wait for the BKOPs to complete. Keep reading the status to
>>>> prevent
>>>> +     * the host from getting into suspend
>>>> +     */
>>>> +    do {
>>>> +            mmc_claim_host(card->host);
>>>> +
>>>> +            if (!mmc_card_doing_bkops(card))
>>>> +                    goto out;
>>>> +
>>>> +            err = mmc_send_status(card, &status);
>>>> +            if (err) {
>>>> +                    pr_err("%s: error %d requesting status\n",
>>>> +                           mmc_hostname(card->host), err);
>>>> +                    goto out;
>>>> +            }
>>>> +
>>>> +            /*
>>>> +             * Some cards mishandle the status bits, so make sure to
>>>> check
>>>> +             * both the busy indication and the card state.
>>>> +             */
>>>> +            if ((status & R1_READY_FOR_DATA) &&
>>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>>> +                    pr_debug("%s: %s: completed BKOPs, exit
>>>> polling\n",
>>>> +                             mmc_hostname(card->host), __func__);
>>>> +                    mmc_card_clr_doing_bkops(card);
>>>> +                    card->bkops_info.started_delayed_bkops = false;
>>>> +                    goto out;
>>>> +            }
>>>> +
>>>> +            mmc_release_host(card->host);
>>>> +
>>>> +            /*
>>>> +             * Sleep before checking the card status again to allow
>>>> the
>>>> +             * card to complete the BKOPs operation
>>>> +             */
>>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>>> +    } while (time_before(jiffies, timeout_jiffies));
>>>> +
>>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>>> +           mmc_hostname(card->host), __func__);
>>>> +
>>>> +    return;
>>>> +out:
>>>> +    mmc_release_host(card->host);
>>>> +}
>>>> +
>>>> +/**
>>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>>> + * needed
>>>> + * @work:   The idle time BKOPS work
>>>> + */
>>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>>> +{
>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>> +                    bkops_info.dw.work);
>>>> +
>>>> +    /*
>>>> +     * Prevent a race condition between mmc_stop_bkops and the
>>>> delayed
>>>> +     * BKOPS work in case the delayed work is executed on another CPU
>>>> +     */
>>>> +    if (card->bkops_info.cancel_delayed_work)
>>>> +            return;
>>>> +
>>>> +    mmc_start_bkops(card, false);
>>>> +}
>>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>>> +
>>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>>  {
>>>>      complete(&mrq->completion);
>>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>      int err = 0;
>>>>
>>>>      BUG_ON(!card);
>>>> +
>>>> +    /*
>>>> +     * Notify the delayed work to be cancelled, in case it was
>>>> already
>>>> +     * removed from the queue, but was not started yet
>>>> +     */
>>>> +    card->bkops_info.cancel_delayed_work = true;
>>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>>> +    if (!mmc_card_doing_bkops(card))
>>>> +            goto out;
>>>> +
>>>>      err = mmc_interrupt_hpi(card);
>>>>
>>>>      /*
>>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>              err = 0;
>>>>      }
>>>>
>>>> +out:
>>>>      return err;
>>>>  }
>>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>>> *notify_block,
>>>>      switch (mode) {
>>>>      case PM_HIBERNATION_PREPARE:
>>>>      case PM_SUSPEND_PREPARE:
>>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>>> -                mmc_card_doing_bkops(host->card)) {
>>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>>> +                    mmc_claim_host(host);
>>>>                      err = mmc_stop_bkops(host->card);
>>>> +                    mmc_release_host(host);
>
> This code seems a bit strange. You will check for mmc_card_mmc, but
> not all (e)MMC will support bkops. How about acually just checking if
> bkops is "on" or "off" somehow.
>
> Additionally, so this piece of code shall stop an ongoing bkops before
> going to suspend, so that make sense. But would it not be more
> meaningfull to take care of that in mmc_suspend_host? I mean why do yo
> need to do it in the PM_SUSPEND_PREPARE notification sequence
> especially?
This code was not added by me. I just added the
mmc_claim_host(host)/mmc_release_host calls. Maybe Jaehoon, who added this
code in the BKOPS patch can respond to your comment.
>
>>>>                      if (err) {
>>>>                              pr_err("%s: didn't stop bkops\n",
>>>>                                      mmc_hostname(host));
>>>>                              return err;
>>>>                      }
>>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>>              }
>>>>
>>>>              spin_lock_irqsave(&host->lock, flags);
>>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>>> index 7cc4638..dba76e3 100644
>>>> --- a/drivers/mmc/core/mmc.c
>>>> +++ b/drivers/mmc/core/mmc.c
>>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host *host,
>>>> u32 ocr,
>>>>              }
>>>>      }
>>>>
>>>> +    if (!oldcard) {
>>>> +            if (card->ext_csd.bkops_en) {
>>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>>> +                                      mmc_start_idle_time_bkops);
>>>> +                    INIT_WORK(&card->bkops_info.poll_for_completion,
>>>> +                              mmc_bkops_completion_polling);
>
> I guess you don't have "removable" eMMC with BKOPS support so this
> code will in practice only be executed once for an eMMC, so we are
> safe. But still I am not fond of putting this code for workqueue here.
> Either that should be done as a part of when the card is
> created/deleted or when then host is created/deleted.
I will check if there could be a better place for this.
>
>>>> +
>>>> +                    /*
>>>> +                     * Calculate the time to start the BKOPs
>>>> checking.
>>>> +                     * The idle time of the host controller should be
>>>> taken
>>>> +                     * into account in order to prevent a race
>>>> condition
>>>> +                     * before starting BKOPs and going into suspend.
>>>> +                     * If the host controller didn't set its idle
>>>> time,
>>>> +                     * a default value is used.
>>>> +                     */
>>>> +                    card->bkops_info.delay_ms =
>>>> MMC_IDLE_BKOPS_TIME_MS;
>>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>>> +                            card->bkops_info.delay_ms = min(
>>>> +                                    card->bkops_info.delay_ms,
>>>> +
>>>> card->bkops_info.host_suspend_tout_ms/2);
>>>> +            }
>>>> +    }
>>>> +
>>>>      if (!oldcard)
>>>>              host->card = card;
>>>>
>>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>>> index 943550d..224e2a5 100644
>>>> --- a/include/linux/mmc/card.h
>>>> +++ b/include/linux/mmc/card.h
>>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>>  };
>>>>
>>>> +/**
>>>> + * struct mmc_bkops_info - BKOPS data
>>>> + * @dw:     Idle time bkops delayed work
>>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>>> + * before getting into suspend
>>>> + * @delay_ms:       The time to start the BKOPS
>>>> + *        delayed work once MMC thread is idle
>>>> + * @poll_for_completion:    Poll on BKOPS completion
>>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>>> + *        should be cancelled
>>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>>> + *        work was scheduled
>>>> + * @sectors_changed:  number of  sectors written or
>>>> + *       discard since the last idle BKOPS were scheduled
>>>> + */
>>>> +struct mmc_bkops_info {
>>>> +    struct delayed_work     dw;
>>>> +    unsigned int            host_suspend_tout_ms;
>
> As stated earlier, what is this timeout you are referring to? What
> suspend?
Explained above.
>
>>>> +    unsigned int            delay_ms;
>>>> +/*
>>>> + * A default time for checking the need for non urgent BKOPS once
>>>> mmcqd
>>>> + * is idle.
>>>> + */
>>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>>> +    struct work_struct      poll_for_completion;
>>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>>> completion */
>>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>>> +    bool                    cancel_delayed_work;
>>>> +    bool                    started_delayed_bkops;
>>>> +    unsigned int            sectors_changed;
>
> Could not find "sectors_changed" being used. Maybe you forgot to
> remove this from previous version of the patch.
Yes, this should be removed.
>
>>>> +};
>>>> +
>>>>  /*
>>>>   * MMC device
>>>>   */
>>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>>      struct dentry           *debugfs_root;
>>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical
>>>> partitions */
>>>>      unsigned int    nr_parts;
>>>> +
>>>> +    struct mmc_bkops_info   bkops_info;
>>>>  };
>>>>
>>>>  /*
>>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>>> index 9b9cdaf..665d345 100644
>>>> --- a/include/linux/mmc/core.h
>>>> +++ b/include/linux/mmc/core.h
>>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>>> mmc_card *);
>>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>>>>      struct mmc_command *, int);
>>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>>> from_exception);
>>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
>>>> bool);
>>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>>
>>>>
>>>
>>>
>>
>>
>> --
>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>> member
>> of Code Aurora Forum, hosted by The Linux Foundation
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-kernel"
>> in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>> Please read the FAQ at  http://www.tux.org/lkml/
>
> Finally some overall thoughts. What I would like to understand is how
> we decide that the card has become "idle". I belive two values should
> be considered, but are they?
> 1. The card need BKOPS to be performed for some status level.
> 2. Request inactivity for a certain timeout has occured.
>
> Have you considered to use runtime PM for the card device instead of
> the workqueue?
>
> Kind regards
> Ulf Hansson
> --
> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>


-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Ulf Hansson]

Hi Maya,

On 4 December 2012 22:17,  <merez@codeaurora.org> wrote:
> Hi Ulf,
>
> Let me try to better explain:
> The idea behind the periodic BKOPS is to check the card's need for BKOPS
> periodically in order to prevent an urgent BKOPS need by the card.
> In order to actually manage to prevent the urgent BKOPS need, the host
> should give the card enough time to perform the BKOPS (when it recognizes
> BKOPS need), otherwise there is no point in having the periodic BKOPS.
> The above results in the following:
> 1. After starting non-urgent BKOPS we "delay" getting into suspend by
> polling on the card's status (explanation below), in order to give the
> card time to perform the BKOPS. This has no effect on the power
> consumption since the same BKOPS operations that were performed after the
> foregound operation just moved to another location, meaning before going
> into suspend.

I am not sure what you are talking about here, runtime suspend or
system suspend? Polling the card's status will not prevent any of
this. So you have got this wrong.

> 2. Using PM_SUSPEND_PREPARE instead of the workqueue would not be
> efficient since we don't want to wait until the host is ready to get into
> suspend and then prevent him from suspending by doing BKOPS operations
> that can take a long time. It is better to start the BKOPS earlier.

I did not suggest to use PM_SUSPEND_PREPARE, but to use runtime PM for
the card device. It can be an option to implement this feature on top
of a workqueue. At least worth to consider.

>
> I am not too familiar with the controllers code and also my understanding
> in runtime suspend is very basic, so feel free to correct me if I'm wrong
> here or the behavior in other controllers is different from msm_sdcc.
> mmc_claim_host calls host->ops->enable. This API is implemented per
> controller but as far as I understand it, this API must prevent suspend,
> otherwise we might go into suspend while there is bus activity. By doing
> get_card_status we call mmc_claim_host and this call is the one that
> "delays" getting into suspend.

host->ops->enable is the old way of implementing runtime power save
for host drivers. Nowadays most drivers is using runtime PM instead.

When you say that mmc_claim_host will prevent suspend, I suppose you
mean that host->ops->disable wont be called? That is definitely not
the same as preventing a system suspend, and moreover it should not.
If you think that the host must be prevented from entering runtime
power save (runtime_supend or host->ops->disable), you must elaborate
more on this, because I don't understand why this is needed.

> If this is not the case in other controllers than the BKOPS will not
> prevent the suspend and BKOPS will be interrupted.
> As for the effect on the battery consumption, this is probably something
> specific to our controller, so sorry if I created a confusion.
>
> Additional comments inline.
>
> Thanks,
> Maya
>
> On Tue, December 4, 2012 1:52 am, Ulf Hansson wrote:
>> On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
>>> Hi Jaehoon,
>>>
>>> With this patch we don't expect to see any degradation. Thanks for
>>> verifying that.
>>> The test plan would be to run the lmdd and iozone benchmarks with this
>>> patch and verify that the performance is not degraded.
>>> I verified it with the msm_sdcc controller.
>>>
>>> Chris - We do expect it to influence the battery consumption, since we
>>> now
>>> delay getting into suspend (since mmc_start_bkops which is called after
>>> the delayed work is executed claims the host).
>>> The solution for that should be done by the controller which can shorten
>>> the timeout given to pm_schedule_suspend by the periodic BKOPS idle
>>> time.
>>> Does it make sense to you?
>>>
>>> Thanks,
>>> Maya
>>> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>>>> Hi Maya,
>>>>
>>>> Thank you a lot for working idle time BKOPS.
>>>>
>>>> I tested with this patch. It's working fine.(Suspend/resume is also
>>>> working well.)
>>>> Test controller is sdhci controller.
>>>> When i tested the performance with iozone, i didn't find that
>>>> performance
>>>> is decreased.
>>>> Well, as Chris is mentioned, do you have any test plan?
>>>> So I will test more with this patch, because i want to test with dw-mmc
>>>> controller, too.
>>>>
>>>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>>>> Devices have various maintenance operations need to perform
>>>>> internally.
>>>>> In order to reduce latencies during time critical operations like read
>>>>> and write, it is better to execute maintenance operations in other
>>>>> times - when the host is not being serviced. Such operations are
>>>>> called
>>>>> Background operations (BKOPS).
>>>>> The device notifies the status of the BKOPS need by updating
>>>>> BKOPS_STATUS
>>>>> (EXT_CSD byte [246]).
>>>>>
>>>>> According to the standard a host that supports BKOPS shall check the
>>>>> status periodically and start background operations as needed, so that
>>>>> the device has enough time for its maintenance operations.
>>>>>
>>>>> This patch adds support for this periodic check of the BKOPS status.
>>>>> Since foreground operations are of higher priority than background
>>>>> operations the host will check the need for BKOPS when it is idle,
>>>>> and in case of an incoming request the BKOPS operation will be
>>>>> interrupted.
>>>>>
>>>>> When the mmcqd thread is idle, a delayed work is created to check the
>>>>> need for BKOPS. The time to start the delayed work is calculated based
>>>>> on the host controller suspend timeout, in case it was set. If not, a
>>>>> default time is used.
>>
>> What host controller suspend timeout are you referring to here?
>>
>> If you are thinking of the runtime PM autosuspend timeout used in many
>> host driver, then you might have missunderstand how runtime PM is used
>> in host drivers.
>> This has nothing to do with BKOPS as such, unless you think that the
>> card must be kept clocked during BKOPS operations, but then this needs
>> to be stated somewhere in this patch and that is not the case.
>>
>> Moreover, I could not find any new timeout added for the _host_ struct
>> in this patch.
> Yes, I was referring to the runtime PM autosuspend timeout. Since we want
> to give the BKOPS time to be performed before going into suspend, we need
> to take this timeout into account.

Not sure why need to consider this timeout. Anyway, if so you must
instead use the runtime PM API to prevent the host from being runtime
suspended, like pm_runtime_get_sync.

>>
>>>>> If BKOPS are required in level 1, which is non-blocking, there will be
>>>>> polling of the card status to wait for the BKOPS completion and
>>>>> prevent
>>>>> suspend that will interrupt the BKOPS.
>>
>> Not sure of what suspend you are talking about here. But for sure
>> BKOPS must _never_ prevent a system suspend.
>>
>> You might want to prevent a host from being runtime suspended though,
>> but that is not accomplished in this patch.
> This is explained in my general comment. Let me know if it is still not
> clear.
>>
>>>>> If the card raised an exception, the need for urgent BKOPS (level 2/3)
>>>>> will be checked immediately and if needed, the BKOPS will be performed
>>>>> without waiting for the next idle time.
>>>>>
>>>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>>>
>>>>> ---
>>>>> This patch is based on the periodic BKOPS implementation in version 8
>>>>> of
>>>>> "support BKOPS feature for eMMC" patch.
>>>>> The patch was modified to answer the following issues:
>>>>> - In order to prevent a race condition between going into suspend and
>>>>> starting BKOPS,
>>>>>   the suspend timeout of the host controller is taking into accound in
>>>>> determination of the start time
>>>>>   of the delayed work
>>>>> - Since mmc_start_bkops is called from two contexts now,
>>>>> mmc_claim_host
>>>>> was moved to the beginning of the function
>>>>> - Also, the check of doing_bkops should be protected when determing if
>>>>> an HPI is needed due to the same reason.
>>>>>
>>>>> Changes in v3:
>>>>>     - Move the call to stop_bkops to block.c.
>>>>>       This allows us to remove the mmc_claim_host from inside the
>>>>> function and doesn't cause additional degradation
>>>>>       due to un-neccessary calim host operation
>>>>>
>>>>> Changes in v2:
>>>>>     - Check the number of written / discarded sectors as the trigger
>>>>> for
>>>>> checking the BKOPS need.
>>>>>     - Code review fixes
>>>>>
>>>>> ---
>>>>>  drivers/mmc/card/block.c |    8 ++-
>>>>>  drivers/mmc/card/queue.c |    2 +
>>>>>  drivers/mmc/core/core.c  |  178
>>>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>>>  include/linux/mmc/card.h |   35 +++++++++
>>>>>  include/linux/mmc/core.h |    3 +
>>>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>>>
>>>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>>>> index 172a768..40b4ae3 100644
>>>>> --- a/drivers/mmc/card/block.c
>>>>> +++ b/drivers/mmc/card/block.c
>>>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue
>>>>> *mq,
>>>>> struct request *req)
>>>>>      struct mmc_blk_data *md = mq->data;
>>>>>      struct mmc_card *card = md->queue.card;
>>>>>
>>>>> -    if (req && !mq->mqrq_prev->req)
>>>>> +    if (req && !mq->mqrq_prev->req) {
>>>>>              /* claim host only for the first request */
>>>>>              mmc_claim_host(card->host);
>>>>> +            if (card->ext_csd.bkops_en &&
>>>>> +                card->bkops_info.started_delayed_bkops) {
>>>>> +                            card->bkops_info.started_delayed_bkops =
>>>>> false;
>>>>> +                            mmc_stop_bkops(card);
>>>> We didn't need to check whether mmc_stop_bkops is success or not?
>>>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>>>
>>>> Best Regards,
>>>> Jaehoon Chung
>>>>
>>>>> +            }
>>>>> +    }
>>>>>
>>>>>      ret = mmc_blk_part_switch(card, md);
>>>>>      if (ret) {
>>>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>>>> index fadf52e..9d0c96a 100644
>>>>> --- a/drivers/mmc/card/queue.c
>>>>> +++ b/drivers/mmc/card/queue.c
>>>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>>>>  {
>>>>>      struct mmc_queue *mq = d;
>>>>>      struct request_queue *q = mq->queue;
>>>>> +    struct mmc_card *card = mq->card;
>>>>>
>>>>>      current->flags |= PF_MEMALLOC;
>>>>>
>>>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>>>                              set_current_state(TASK_RUNNING);
>>>>>                              break;
>>>>>                      }
>>>>> +                    mmc_start_delayed_bkops(card);
>>>>>                      up(&mq->thread_sem);
>>>>>                      schedule();
>>>>>                      down(&mq->thread_sem);
>>>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>>>> index 06c42cf..72ae15b 100644
>>>>> --- a/drivers/mmc/core/core.c
>>>>> +++ b/drivers/mmc/core/core.c
>>>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>>>> mmc_request *mrq)
>>>>>  }
>>>>>
>>>>>  /**
>>>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>>>> + *      the need of non urgent BKOPS
>>>>> + *
>>>>> + * @card: MMC card to start BKOPS on
>>>>> + */
>>>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>>>> +{
>>>>> +    if (!card || !card->ext_csd.bkops_en ||
>>>>> mmc_card_doing_bkops(card))
>>>>> +            return;
>>>>> +
>>>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>>>> +             mmc_hostname(card->host), __func__);
>>>>> +
>>>>> +    /*
>>>>> +     * cancel_delayed_bkops_work will prevent a race condition
>>>>> between
>>>>> +     * fetching a request by the mmcqd and the delayed work, in case
>>>>> +     * it was removed from the queue work but not started yet
>>>>> +     */
>>>>> +    card->bkops_info.cancel_delayed_work = false;
>>>>> +    card->bkops_info.started_delayed_bkops = true;
>>>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>>>> +                       msecs_to_jiffies(
>>>>> +                               card->bkops_info.delay_ms));
>>>>> +}
>>>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>>>> +
>>>>> +/**
>>>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>>>   *  @card: MMC card to start BKOPS
>>>>> - *  @form_exception: A flag to indicate if this function was
>>>>> + *  @from_exception: A flag to indicate if this function was
>>>>>   *                   called due to an exception raised by the card
>>>>>   *
>>>>>   *  Start background operations whenever requested.
>>>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card, bool
>>>>> from_exception)
>>>>>      bool use_busy_signal;
>>>>>
>>>>>      BUG_ON(!card);
>>>>> -
>>>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>>>> +    if (!card->ext_csd.bkops_en)
>>>>>              return;
>>>>>
>>>>> +    mmc_claim_host(card->host);
>>>>> +
>>>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
>>>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>>>> +                     mmc_hostname(card->host), __func__);
>>>>> +            card->bkops_info.cancel_delayed_work = false;
>>>>> +            goto out;
>>>>> +    }
>>>>> +
>>>>> +    if (mmc_card_doing_bkops(card)) {
>>>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>>>> +                     mmc_hostname(card->host), __func__);
>>>>> +            goto out;
>>>>> +    }
>>>>> +
>>>>>      err = mmc_read_bkops_status(card);
>>>>>      if (err) {
>>>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>>>                     mmc_hostname(card->host), err);
>>>>> -            return;
>>>>> +            goto out;
>>>>>      }
>>>>>
>>>>>      if (!card->ext_csd.raw_bkops_status)
>>>>> -            return;
>>>>> +            goto out;
>>>>>
>>>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>>>> +            mmc_hostname(card->host), __func__,
>>>>> +            card->ext_csd.raw_bkops_status);
>>>>> +
>>>>> +    /*
>>>>> +     * If the function was called due to exception but there is no
>>>>> need
>>>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed BKOPs
>>>>> +     * work, before going to suspend
>>>>> +     */
>>>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>>>          from_exception)
>>>>> -            return;
>>>>> +            goto out;
>>>>>
>>>>> -    mmc_claim_host(card->host);
>>>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>>>              use_busy_signal = true;
>>>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>> bool
>>>>> from_exception)
>>>>>       * bkops executed synchronously, otherwise
>>>>>       * the operation is in progress
>>>>>       */
>>>>> -    if (!use_busy_signal)
>>>>> +    if (!use_busy_signal) {
>>>>>              mmc_card_set_doing_bkops(card);
>>>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>>>> +                     mmc_hostname(card->host), __func__);
>>>>> +            queue_work(system_nrt_wq,
>>>>> +                       &card->bkops_info.poll_for_completion);
>>>>> +    }
>>>>> +
>>>>>  out:
>>>>>      mmc_release_host(card->host);
>>>>>  }
>>>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>>>
>>>>> +/**
>>>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>>>> + * wait for the non-blocking BKOPS completion
>>>>> + * @work:   The completion polling work
>>>>> + *
>>>>> + * The on-going reading of the card status will prevent the card
>>>>> + * from getting into suspend while it is in the middle of
>>>>> + * performing BKOPS.
>>
>> Not true! Suspend will not be prevented by doing a mmc_send_status.
>> Moreover, I would be interested to understand more about why you need
>> to prevent "suspend". Please elaborate why you think this is needed.
> This is explained in my general comment. Let me know if it is still not
> clear.
>>
>>>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>>>> + * request we also check IF mmc_card_doing_bkops in each
>>>>> + * iteration.
>>>>> + */
>>>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>>>> +{
>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>> +                    bkops_info.poll_for_completion);
>>>>> +    unsigned long timeout_jiffies = jiffies +
>>>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>>>> +    u32 status;
>>>>> +    int err;
>>>>> +
>>>>> +    /*
>>>>> +     * Wait for the BKOPs to complete. Keep reading the status to
>>>>> prevent
>>>>> +     * the host from getting into suspend
>>>>> +     */
>>>>> +    do {
>>>>> +            mmc_claim_host(card->host);
>>>>> +
>>>>> +            if (!mmc_card_doing_bkops(card))
>>>>> +                    goto out;
>>>>> +
>>>>> +            err = mmc_send_status(card, &status);
>>>>> +            if (err) {
>>>>> +                    pr_err("%s: error %d requesting status\n",
>>>>> +                           mmc_hostname(card->host), err);
>>>>> +                    goto out;
>>>>> +            }
>>>>> +
>>>>> +            /*
>>>>> +             * Some cards mishandle the status bits, so make sure to
>>>>> check
>>>>> +             * both the busy indication and the card state.
>>>>> +             */
>>>>> +            if ((status & R1_READY_FOR_DATA) &&
>>>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>>>> +                    pr_debug("%s: %s: completed BKOPs, exit
>>>>> polling\n",
>>>>> +                             mmc_hostname(card->host), __func__);
>>>>> +                    mmc_card_clr_doing_bkops(card);
>>>>> +                    card->bkops_info.started_delayed_bkops = false;
>>>>> +                    goto out;
>>>>> +            }
>>>>> +
>>>>> +            mmc_release_host(card->host);
>>>>> +
>>>>> +            /*
>>>>> +             * Sleep before checking the card status again to allow
>>>>> the
>>>>> +             * card to complete the BKOPs operation
>>>>> +             */
>>>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>>>> +    } while (time_before(jiffies, timeout_jiffies));
>>>>> +
>>>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>>>> +           mmc_hostname(card->host), __func__);
>>>>> +
>>>>> +    return;
>>>>> +out:
>>>>> +    mmc_release_host(card->host);
>>>>> +}
>>>>> +
>>>>> +/**
>>>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>>>> + * needed
>>>>> + * @work:   The idle time BKOPS work
>>>>> + */
>>>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>>>> +{
>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>> +                    bkops_info.dw.work);
>>>>> +
>>>>> +    /*
>>>>> +     * Prevent a race condition between mmc_stop_bkops and the
>>>>> delayed
>>>>> +     * BKOPS work in case the delayed work is executed on another CPU
>>>>> +     */
>>>>> +    if (card->bkops_info.cancel_delayed_work)
>>>>> +            return;
>>>>> +
>>>>> +    mmc_start_bkops(card, false);
>>>>> +}
>>>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>>>> +
>>>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>>>  {
>>>>>      complete(&mrq->completion);
>>>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>      int err = 0;
>>>>>
>>>>>      BUG_ON(!card);
>>>>> +
>>>>> +    /*
>>>>> +     * Notify the delayed work to be cancelled, in case it was
>>>>> already
>>>>> +     * removed from the queue, but was not started yet
>>>>> +     */
>>>>> +    card->bkops_info.cancel_delayed_work = true;
>>>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>>>> +    if (!mmc_card_doing_bkops(card))
>>>>> +            goto out;
>>>>> +
>>>>>      err = mmc_interrupt_hpi(card);
>>>>>
>>>>>      /*
>>>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>              err = 0;
>>>>>      }
>>>>>
>>>>> +out:
>>>>>      return err;
>>>>>  }
>>>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>>>> *notify_block,
>>>>>      switch (mode) {
>>>>>      case PM_HIBERNATION_PREPARE:
>>>>>      case PM_SUSPEND_PREPARE:
>>>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>>>> -                mmc_card_doing_bkops(host->card)) {
>>>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>>>> +                    mmc_claim_host(host);
>>>>>                      err = mmc_stop_bkops(host->card);
>>>>> +                    mmc_release_host(host);
>>
>> This code seems a bit strange. You will check for mmc_card_mmc, but
>> not all (e)MMC will support bkops. How about acually just checking if
>> bkops is "on" or "off" somehow.
>>
>> Additionally, so this piece of code shall stop an ongoing bkops before
>> going to suspend, so that make sense. But would it not be more
>> meaningfull to take care of that in mmc_suspend_host? I mean why do yo
>> need to do it in the PM_SUSPEND_PREPARE notification sequence
>> especially?
> This code was not added by me. I just added the
> mmc_claim_host(host)/mmc_release_host calls. Maybe Jaehoon, who added this
> code in the BKOPS patch can respond to your comment.
>>
>>>>>                      if (err) {
>>>>>                              pr_err("%s: didn't stop bkops\n",
>>>>>                                      mmc_hostname(host));
>>>>>                              return err;
>>>>>                      }
>>>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>>>              }
>>>>>
>>>>>              spin_lock_irqsave(&host->lock, flags);
>>>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>>>> index 7cc4638..dba76e3 100644
>>>>> --- a/drivers/mmc/core/mmc.c
>>>>> +++ b/drivers/mmc/core/mmc.c
>>>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host *host,
>>>>> u32 ocr,
>>>>>              }
>>>>>      }
>>>>>
>>>>> +    if (!oldcard) {
>>>>> +            if (card->ext_csd.bkops_en) {
>>>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>>>> +                                      mmc_start_idle_time_bkops);
>>>>> +                    INIT_WORK(&card->bkops_info.poll_for_completion,
>>>>> +                              mmc_bkops_completion_polling);
>>
>> I guess you don't have "removable" eMMC with BKOPS support so this
>> code will in practice only be executed once for an eMMC, so we are
>> safe. But still I am not fond of putting this code for workqueue here.
>> Either that should be done as a part of when the card is
>> created/deleted or when then host is created/deleted.
> I will check if there could be a better place for this.
>>
>>>>> +
>>>>> +                    /*
>>>>> +                     * Calculate the time to start the BKOPs
>>>>> checking.
>>>>> +                     * The idle time of the host controller should be
>>>>> taken
>>>>> +                     * into account in order to prevent a race
>>>>> condition
>>>>> +                     * before starting BKOPs and going into suspend.
>>>>> +                     * If the host controller didn't set its idle
>>>>> time,
>>>>> +                     * a default value is used.
>>>>> +                     */
>>>>> +                    card->bkops_info.delay_ms =
>>>>> MMC_IDLE_BKOPS_TIME_MS;
>>>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>>>> +                            card->bkops_info.delay_ms = min(
>>>>> +                                    card->bkops_info.delay_ms,
>>>>> +
>>>>> card->bkops_info.host_suspend_tout_ms/2);
>>>>> +            }
>>>>> +    }
>>>>> +
>>>>>      if (!oldcard)
>>>>>              host->card = card;
>>>>>
>>>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>>>> index 943550d..224e2a5 100644
>>>>> --- a/include/linux/mmc/card.h
>>>>> +++ b/include/linux/mmc/card.h
>>>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>>>  };
>>>>>
>>>>> +/**
>>>>> + * struct mmc_bkops_info - BKOPS data
>>>>> + * @dw:     Idle time bkops delayed work
>>>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>>>> + * before getting into suspend
>>>>> + * @delay_ms:       The time to start the BKOPS
>>>>> + *        delayed work once MMC thread is idle
>>>>> + * @poll_for_completion:    Poll on BKOPS completion
>>>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>>>> + *        should be cancelled
>>>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>>>> + *        work was scheduled
>>>>> + * @sectors_changed:  number of  sectors written or
>>>>> + *       discard since the last idle BKOPS were scheduled
>>>>> + */
>>>>> +struct mmc_bkops_info {
>>>>> +    struct delayed_work     dw;
>>>>> +    unsigned int            host_suspend_tout_ms;
>>
>> As stated earlier, what is this timeout you are referring to? What
>> suspend?
> Explained above.
>>
>>>>> +    unsigned int            delay_ms;
>>>>> +/*
>>>>> + * A default time for checking the need for non urgent BKOPS once
>>>>> mmcqd
>>>>> + * is idle.
>>>>> + */
>>>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>>>> +    struct work_struct      poll_for_completion;
>>>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>>>> completion */
>>>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>>>> +    bool                    cancel_delayed_work;
>>>>> +    bool                    started_delayed_bkops;
>>>>> +    unsigned int            sectors_changed;
>>
>> Could not find "sectors_changed" being used. Maybe you forgot to
>> remove this from previous version of the patch.
> Yes, this should be removed.
>>
>>>>> +};
>>>>> +
>>>>>  /*
>>>>>   * MMC device
>>>>>   */
>>>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>>>      struct dentry           *debugfs_root;
>>>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical
>>>>> partitions */
>>>>>      unsigned int    nr_parts;
>>>>> +
>>>>> +    struct mmc_bkops_info   bkops_info;
>>>>>  };
>>>>>
>>>>>  /*
>>>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>>>> index 9b9cdaf..665d345 100644
>>>>> --- a/include/linux/mmc/core.h
>>>>> +++ b/include/linux/mmc/core.h
>>>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>>>> mmc_card *);
>>>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
>>>>>      struct mmc_command *, int);
>>>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>>>> from_exception);
>>>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int,
>>>>> bool);
>>>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>>>
>>>>>
>>>>
>>>>
>>>
>>>
>>> --
>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>> member
>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-kernel"
>>> in
>>> the body of a message to majordomo@vger.kernel.org
>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>> Please read the FAQ at  http://www.tux.org/lkml/
>>
>> Finally some overall thoughts. What I would like to understand is how
>> we decide that the card has become "idle". I belive two values should
>> be considered, but are they?
>> 1. The card need BKOPS to be performed for some status level.
>> 2. Request inactivity for a certain timeout has occured.
>>
>> Have you considered to use runtime PM for the card device instead of
>> the workqueue?
>>
>> Kind regards
>> Ulf Hansson
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>
>
>
> --
> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
> of Code Aurora Forum, hosted by The Linux Foundation
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/

Kind regards
Ulf Hansson

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[merez]

Hi Ulf,

Sorry for the late response.
See my reply below.

Thanks,
Maya

On Thu, December 6, 2012 2:18 am, Ulf Hansson wrote:
> Hi Maya,
>
> On 4 December 2012 22:17,  <merez@codeaurora.org> wrote:
>> Hi Ulf,
>>
>> Let me try to better explain:
>> The idea behind the periodic BKOPS is to check the card's need for BKOPS
>> periodically in order to prevent an urgent BKOPS need by the card.
>> In order to actually manage to prevent the urgent BKOPS need, the host
>> should give the card enough time to perform the BKOPS (when it
>> recognizes
>> BKOPS need), otherwise there is no point in having the periodic BKOPS.
>> The above results in the following:
>> 1. After starting non-urgent BKOPS we "delay" getting into suspend by
>> polling on the card's status (explanation below), in order to give the
>> card time to perform the BKOPS. This has no effect on the power
>> consumption since the same BKOPS operations that were performed after
>> the
>> foregound operation just moved to another location, meaning before going
>> into suspend.
>
> I am not sure what you are talking about here, runtime suspend or
> system suspend? Polling the card's status will not prevent any of
> this. So you have got this wrong.

I am referring to the runtime suspend.
Our controller implements the runtime suspend and is not using the default
implementation of core/bus.c.
This is the reason why in our implementation polling the card status
"delays" the runtime suspend while it is not the case when using the
default runtime suspend implementation.
I can try to explain here what our controller is doing but since it is
specific to us then I guess it is not relevant to the discussion.
Our controller is calling mmc_suspend_host in runtime suspend, which
issues an HPI to stop the BKOPS.
Now that I understand that this code is not needed for all the host
drivers I will add a flag to decide if polling is required when doing an
unblocking BKOPS.
Other host drivers that actually suspend on runtime suspend can enable
this flag and allow BKOPS to be active for a longer period.
I will prepare a new patch and send it for review.

>
>> 2. Using PM_SUSPEND_PREPARE instead of the workqueue would not be
>> efficient since we don't want to wait until the host is ready to get
>> into
>> suspend and then prevent him from suspending by doing BKOPS operations
>> that can take a long time. It is better to start the BKOPS earlier.
>
> I did not suggest to use PM_SUSPEND_PREPARE, but to use runtime PM for
> the card device. It can be an option to implement this feature on top
> of a workqueue. At least worth to consider.
>

We consider to call mmc_start_bkops every time MMC becomes idle, to
check the need for BKOPS. I will test it and include it in the next patch.

>>
>> I am not too familiar with the controllers code and also my
>> understanding
>> in runtime suspend is very basic, so feel free to correct me if I'm
>> wrong
>> here or the behavior in other controllers is different from msm_sdcc.
>> mmc_claim_host calls host->ops->enable. This API is implemented per
>> controller but as far as I understand it, this API must prevent suspend,
>> otherwise we might go into suspend while there is bus activity. By doing
>> get_card_status we call mmc_claim_host and this call is the one that
>> "delays" getting into suspend.
>
> host->ops->enable is the old way of implementing runtime power save
> for host drivers. Nowadays most drivers is using runtime PM instead.
>
> When you say that mmc_claim_host will prevent suspend, I suppose you
> mean that host->ops->disable wont be called? That is definitely not
> the same as preventing a system suspend, and moreover it should not.
> If you think that the host must be prevented from entering runtime
> power save (runtime_supend or host->ops->disable), you must elaborate
> more on this, because I don't understand why this is needed.
>
Again, this is specific to our controller, so you can just ignore that.

>> If this is not the case in other controllers than the BKOPS will not
>> prevent the suspend and BKOPS will be interrupted.
>> As for the effect on the battery consumption, this is probably something
>> specific to our controller, so sorry if I created a confusion.
>>
>> Additional comments inline.
>>
>> Thanks,
>> Maya
>>
>> On Tue, December 4, 2012 1:52 am, Ulf Hansson wrote:
>>> On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
>>>> Hi Jaehoon,
>>>>
>>>> With this patch we don't expect to see any degradation. Thanks for
>>>> verifying that.
>>>> The test plan would be to run the lmdd and iozone benchmarks with this
>>>> patch and verify that the performance is not degraded.
>>>> I verified it with the msm_sdcc controller.
>>>>
>>>> Chris - We do expect it to influence the battery consumption, since we
>>>> now
>>>> delay getting into suspend (since mmc_start_bkops which is called
>>>> after
>>>> the delayed work is executed claims the host).
>>>> The solution for that should be done by the controller which can
>>>> shorten
>>>> the timeout given to pm_schedule_suspend by the periodic BKOPS idle
>>>> time.
>>>> Does it make sense to you?
>>>>
>>>> Thanks,
>>>> Maya
>>>> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>>>>> Hi Maya,
>>>>>
>>>>> Thank you a lot for working idle time BKOPS.
>>>>>
>>>>> I tested with this patch. It's working fine.(Suspend/resume is also
>>>>> working well.)
>>>>> Test controller is sdhci controller.
>>>>> When i tested the performance with iozone, i didn't find that
>>>>> performance
>>>>> is decreased.
>>>>> Well, as Chris is mentioned, do you have any test plan?
>>>>> So I will test more with this patch, because i want to test with
>>>>> dw-mmc
>>>>> controller, too.
>>>>>
>>>>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>>>>> Devices have various maintenance operations need to perform
>>>>>> internally.
>>>>>> In order to reduce latencies during time critical operations like
>>>>>> read
>>>>>> and write, it is better to execute maintenance operations in other
>>>>>> times - when the host is not being serviced. Such operations are
>>>>>> called
>>>>>> Background operations (BKOPS).
>>>>>> The device notifies the status of the BKOPS need by updating
>>>>>> BKOPS_STATUS
>>>>>> (EXT_CSD byte [246]).
>>>>>>
>>>>>> According to the standard a host that supports BKOPS shall check the
>>>>>> status periodically and start background operations as needed, so
>>>>>> that
>>>>>> the device has enough time for its maintenance operations.
>>>>>>
>>>>>> This patch adds support for this periodic check of the BKOPS status.
>>>>>> Since foreground operations are of higher priority than background
>>>>>> operations the host will check the need for BKOPS when it is idle,
>>>>>> and in case of an incoming request the BKOPS operation will be
>>>>>> interrupted.
>>>>>>
>>>>>> When the mmcqd thread is idle, a delayed work is created to check
>>>>>> the
>>>>>> need for BKOPS. The time to start the delayed work is calculated
>>>>>> based
>>>>>> on the host controller suspend timeout, in case it was set. If not,
>>>>>> a
>>>>>> default time is used.
>>>
>>> What host controller suspend timeout are you referring to here?
>>>
>>> If you are thinking of the runtime PM autosuspend timeout used in many
>>> host driver, then you might have missunderstand how runtime PM is used
>>> in host drivers.
>>> This has nothing to do with BKOPS as such, unless you think that the
>>> card must be kept clocked during BKOPS operations, but then this needs
>>> to be stated somewhere in this patch and that is not the case.
>>>
>>> Moreover, I could not find any new timeout added for the _host_ struct
>>> in this patch.
>> Yes, I was referring to the runtime PM autosuspend timeout. Since we
>> want
>> to give the BKOPS time to be performed before going into suspend, we
>> need
>> to take this timeout into account.
>
> Not sure why need to consider this timeout. Anyway, if so you must
> instead use the runtime PM API to prevent the host from being runtime
> suspended, like pm_runtime_get_sync.
>
>>>
>>>>>> If BKOPS are required in level 1, which is non-blocking, there will
>>>>>> be
>>>>>> polling of the card status to wait for the BKOPS completion and
>>>>>> prevent
>>>>>> suspend that will interrupt the BKOPS.
>>>
>>> Not sure of what suspend you are talking about here. But for sure
>>> BKOPS must _never_ prevent a system suspend.
>>>
>>> You might want to prevent a host from being runtime suspended though,
>>> but that is not accomplished in this patch.
>> This is explained in my general comment. Let me know if it is still not
>> clear.
>>>
>>>>>> If the card raised an exception, the need for urgent BKOPS (level
>>>>>> 2/3)
>>>>>> will be checked immediately and if needed, the BKOPS will be
>>>>>> performed
>>>>>> without waiting for the next idle time.
>>>>>>
>>>>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>>>>
>>>>>> ---
>>>>>> This patch is based on the periodic BKOPS implementation in version
>>>>>> 8
>>>>>> of
>>>>>> "support BKOPS feature for eMMC" patch.
>>>>>> The patch was modified to answer the following issues:
>>>>>> - In order to prevent a race condition between going into suspend
>>>>>> and
>>>>>> starting BKOPS,
>>>>>>   the suspend timeout of the host controller is taking into accound
>>>>>> in
>>>>>> determination of the start time
>>>>>>   of the delayed work
>>>>>> - Since mmc_start_bkops is called from two contexts now,
>>>>>> mmc_claim_host
>>>>>> was moved to the beginning of the function
>>>>>> - Also, the check of doing_bkops should be protected when determing
>>>>>> if
>>>>>> an HPI is needed due to the same reason.
>>>>>>
>>>>>> Changes in v3:
>>>>>>     - Move the call to stop_bkops to block.c.
>>>>>>       This allows us to remove the mmc_claim_host from inside the
>>>>>> function and doesn't cause additional degradation
>>>>>>       due to un-neccessary calim host operation
>>>>>>
>>>>>> Changes in v2:
>>>>>>     - Check the number of written / discarded sectors as the trigger
>>>>>> for
>>>>>> checking the BKOPS need.
>>>>>>     - Code review fixes
>>>>>>
>>>>>> ---
>>>>>>  drivers/mmc/card/block.c |    8 ++-
>>>>>>  drivers/mmc/card/queue.c |    2 +
>>>>>>  drivers/mmc/core/core.c  |  178
>>>>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>>>>  include/linux/mmc/card.h |   35 +++++++++
>>>>>>  include/linux/mmc/core.h |    3 +
>>>>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>>>>
>>>>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>>>>> index 172a768..40b4ae3 100644
>>>>>> --- a/drivers/mmc/card/block.c
>>>>>> +++ b/drivers/mmc/card/block.c
>>>>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue
>>>>>> *mq,
>>>>>> struct request *req)
>>>>>>      struct mmc_blk_data *md = mq->data;
>>>>>>      struct mmc_card *card = md->queue.card;
>>>>>>
>>>>>> -    if (req && !mq->mqrq_prev->req)
>>>>>> +    if (req && !mq->mqrq_prev->req) {
>>>>>>              /* claim host only for the first request */
>>>>>>              mmc_claim_host(card->host);
>>>>>> +            if (card->ext_csd.bkops_en &&
>>>>>> +                card->bkops_info.started_delayed_bkops) {
>>>>>> +                            card->bkops_info.started_delayed_bkops
>>>>>> =
>>>>>> false;
>>>>>> +                            mmc_stop_bkops(card);
>>>>> We didn't need to check whether mmc_stop_bkops is success or not?
>>>>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>>>>
>>>>> Best Regards,
>>>>> Jaehoon Chung
>>>>>
>>>>>> +            }
>>>>>> +    }
>>>>>>
>>>>>>      ret = mmc_blk_part_switch(card, md);
>>>>>>      if (ret) {
>>>>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>>>>> index fadf52e..9d0c96a 100644
>>>>>> --- a/drivers/mmc/card/queue.c
>>>>>> +++ b/drivers/mmc/card/queue.c
>>>>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>>>>>  {
>>>>>>      struct mmc_queue *mq = d;
>>>>>>      struct request_queue *q = mq->queue;
>>>>>> +    struct mmc_card *card = mq->card;
>>>>>>
>>>>>>      current->flags |= PF_MEMALLOC;
>>>>>>
>>>>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>>>>                              set_current_state(TASK_RUNNING);
>>>>>>                              break;
>>>>>>                      }
>>>>>> +                    mmc_start_delayed_bkops(card);
>>>>>>                      up(&mq->thread_sem);
>>>>>>                      schedule();
>>>>>>                      down(&mq->thread_sem);
>>>>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>>>>> index 06c42cf..72ae15b 100644
>>>>>> --- a/drivers/mmc/core/core.c
>>>>>> +++ b/drivers/mmc/core/core.c
>>>>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>>>>> mmc_request *mrq)
>>>>>>  }
>>>>>>
>>>>>>  /**
>>>>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>>>>> + *      the need of non urgent BKOPS
>>>>>> + *
>>>>>> + * @card: MMC card to start BKOPS on
>>>>>> + */
>>>>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>>>>> +{
>>>>>> +    if (!card || !card->ext_csd.bkops_en ||
>>>>>> mmc_card_doing_bkops(card))
>>>>>> +            return;
>>>>>> +
>>>>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>>>>> +             mmc_hostname(card->host), __func__);
>>>>>> +
>>>>>> +    /*
>>>>>> +     * cancel_delayed_bkops_work will prevent a race condition
>>>>>> between
>>>>>> +     * fetching a request by the mmcqd and the delayed work, in
>>>>>> case
>>>>>> +     * it was removed from the queue work but not started yet
>>>>>> +     */
>>>>>> +    card->bkops_info.cancel_delayed_work = false;
>>>>>> +    card->bkops_info.started_delayed_bkops = true;
>>>>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>>>>> +                       msecs_to_jiffies(
>>>>>> +                               card->bkops_info.delay_ms));
>>>>>> +}
>>>>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>>>>> +
>>>>>> +/**
>>>>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>>>>   *  @card: MMC card to start BKOPS
>>>>>> - *  @form_exception: A flag to indicate if this function was
>>>>>> + *  @from_exception: A flag to indicate if this function was
>>>>>>   *                   called due to an exception raised by the card
>>>>>>   *
>>>>>>   *  Start background operations whenever requested.
>>>>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>> bool
>>>>>> from_exception)
>>>>>>      bool use_busy_signal;
>>>>>>
>>>>>>      BUG_ON(!card);
>>>>>> -
>>>>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>>>>> +    if (!card->ext_csd.bkops_en)
>>>>>>              return;
>>>>>>
>>>>>> +    mmc_claim_host(card->host);
>>>>>> +
>>>>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception)
>>>>>> {
>>>>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>> +            card->bkops_info.cancel_delayed_work = false;
>>>>>> +            goto out;
>>>>>> +    }
>>>>>> +
>>>>>> +    if (mmc_card_doing_bkops(card)) {
>>>>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>> +            goto out;
>>>>>> +    }
>>>>>> +
>>>>>>      err = mmc_read_bkops_status(card);
>>>>>>      if (err) {
>>>>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>>>>                     mmc_hostname(card->host), err);
>>>>>> -            return;
>>>>>> +            goto out;
>>>>>>      }
>>>>>>
>>>>>>      if (!card->ext_csd.raw_bkops_status)
>>>>>> -            return;
>>>>>> +            goto out;
>>>>>>
>>>>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>>>>> +            mmc_hostname(card->host), __func__,
>>>>>> +            card->ext_csd.raw_bkops_status);
>>>>>> +
>>>>>> +    /*
>>>>>> +     * If the function was called due to exception but there is no
>>>>>> need
>>>>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed
>>>>>> BKOPs
>>>>>> +     * work, before going to suspend
>>>>>> +     */
>>>>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>>>>          from_exception)
>>>>>> -            return;
>>>>>> +            goto out;
>>>>>>
>>>>>> -    mmc_claim_host(card->host);
>>>>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>>>>              use_busy_signal = true;
>>>>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>> bool
>>>>>> from_exception)
>>>>>>       * bkops executed synchronously, otherwise
>>>>>>       * the operation is in progress
>>>>>>       */
>>>>>> -    if (!use_busy_signal)
>>>>>> +    if (!use_busy_signal) {
>>>>>>              mmc_card_set_doing_bkops(card);
>>>>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>> +            queue_work(system_nrt_wq,
>>>>>> +                       &card->bkops_info.poll_for_completion);
>>>>>> +    }
>>>>>> +
>>>>>>  out:
>>>>>>      mmc_release_host(card->host);
>>>>>>  }
>>>>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>>>>
>>>>>> +/**
>>>>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>>>>> + * wait for the non-blocking BKOPS completion
>>>>>> + * @work:   The completion polling work
>>>>>> + *
>>>>>> + * The on-going reading of the card status will prevent the card
>>>>>> + * from getting into suspend while it is in the middle of
>>>>>> + * performing BKOPS.
>>>
>>> Not true! Suspend will not be prevented by doing a mmc_send_status.
>>> Moreover, I would be interested to understand more about why you need
>>> to prevent "suspend". Please elaborate why you think this is needed.
>> This is explained in my general comment. Let me know if it is still not
>> clear.
>>>
>>>>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>>>>> + * request we also check IF mmc_card_doing_bkops in each
>>>>>> + * iteration.
>>>>>> + */
>>>>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>>>>> +{
>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>> +                    bkops_info.poll_for_completion);
>>>>>> +    unsigned long timeout_jiffies = jiffies +
>>>>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>>>>> +    u32 status;
>>>>>> +    int err;
>>>>>> +
>>>>>> +    /*
>>>>>> +     * Wait for the BKOPs to complete. Keep reading the status to
>>>>>> prevent
>>>>>> +     * the host from getting into suspend
>>>>>> +     */
>>>>>> +    do {
>>>>>> +            mmc_claim_host(card->host);
>>>>>> +
>>>>>> +            if (!mmc_card_doing_bkops(card))
>>>>>> +                    goto out;
>>>>>> +
>>>>>> +            err = mmc_send_status(card, &status);
>>>>>> +            if (err) {
>>>>>> +                    pr_err("%s: error %d requesting status\n",
>>>>>> +                           mmc_hostname(card->host), err);
>>>>>> +                    goto out;
>>>>>> +            }
>>>>>> +
>>>>>> +            /*
>>>>>> +             * Some cards mishandle the status bits, so make sure
>>>>>> to
>>>>>> check
>>>>>> +             * both the busy indication and the card state.
>>>>>> +             */
>>>>>> +            if ((status & R1_READY_FOR_DATA) &&
>>>>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>>>>> +                    pr_debug("%s: %s: completed BKOPs, exit
>>>>>> polling\n",
>>>>>> +                             mmc_hostname(card->host), __func__);
>>>>>> +                    mmc_card_clr_doing_bkops(card);
>>>>>> +                    card->bkops_info.started_delayed_bkops = false;
>>>>>> +                    goto out;
>>>>>> +            }
>>>>>> +
>>>>>> +            mmc_release_host(card->host);
>>>>>> +
>>>>>> +            /*
>>>>>> +             * Sleep before checking the card status again to allow
>>>>>> the
>>>>>> +             * card to complete the BKOPs operation
>>>>>> +             */
>>>>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>>>>> +    } while (time_before(jiffies, timeout_jiffies));
>>>>>> +
>>>>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>>>>> +           mmc_hostname(card->host), __func__);
>>>>>> +
>>>>>> +    return;
>>>>>> +out:
>>>>>> +    mmc_release_host(card->host);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>>>>> + * needed
>>>>>> + * @work:   The idle time BKOPS work
>>>>>> + */
>>>>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>>>>> +{
>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>> +                    bkops_info.dw.work);
>>>>>> +
>>>>>> +    /*
>>>>>> +     * Prevent a race condition between mmc_stop_bkops and the
>>>>>> delayed
>>>>>> +     * BKOPS work in case the delayed work is executed on another
>>>>>> CPU
>>>>>> +     */
>>>>>> +    if (card->bkops_info.cancel_delayed_work)
>>>>>> +            return;
>>>>>> +
>>>>>> +    mmc_start_bkops(card, false);
>>>>>> +}
>>>>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>>>>> +
>>>>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>>>>  {
>>>>>>      complete(&mrq->completion);
>>>>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>      int err = 0;
>>>>>>
>>>>>>      BUG_ON(!card);
>>>>>> +
>>>>>> +    /*
>>>>>> +     * Notify the delayed work to be cancelled, in case it was
>>>>>> already
>>>>>> +     * removed from the queue, but was not started yet
>>>>>> +     */
>>>>>> +    card->bkops_info.cancel_delayed_work = true;
>>>>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>>>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>>>>> +    if (!mmc_card_doing_bkops(card))
>>>>>> +            goto out;
>>>>>> +
>>>>>>      err = mmc_interrupt_hpi(card);
>>>>>>
>>>>>>      /*
>>>>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>              err = 0;
>>>>>>      }
>>>>>>
>>>>>> +out:
>>>>>>      return err;
>>>>>>  }
>>>>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>>>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>>>>> *notify_block,
>>>>>>      switch (mode) {
>>>>>>      case PM_HIBERNATION_PREPARE:
>>>>>>      case PM_SUSPEND_PREPARE:
>>>>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>>>>> -                mmc_card_doing_bkops(host->card)) {
>>>>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>>>>> +                    mmc_claim_host(host);
>>>>>>                      err = mmc_stop_bkops(host->card);
>>>>>> +                    mmc_release_host(host);
>>>
>>> This code seems a bit strange. You will check for mmc_card_mmc, but
>>> not all (e)MMC will support bkops. How about acually just checking if
>>> bkops is "on" or "off" somehow.
>>>
>>> Additionally, so this piece of code shall stop an ongoing bkops before
>>> going to suspend, so that make sense. But would it not be more
>>> meaningfull to take care of that in mmc_suspend_host? I mean why do yo
>>> need to do it in the PM_SUSPEND_PREPARE notification sequence
>>> especially?
>> This code was not added by me. I just added the
>> mmc_claim_host(host)/mmc_release_host calls. Maybe Jaehoon, who added
>> this
>> code in the BKOPS patch can respond to your comment.
>>>
>>>>>>                      if (err) {
>>>>>>                              pr_err("%s: didn't stop bkops\n",
>>>>>>                                      mmc_hostname(host));
>>>>>>                              return err;
>>>>>>                      }
>>>>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>>>>              }
>>>>>>
>>>>>>              spin_lock_irqsave(&host->lock, flags);
>>>>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>>>>> index 7cc4638..dba76e3 100644
>>>>>> --- a/drivers/mmc/core/mmc.c
>>>>>> +++ b/drivers/mmc/core/mmc.c
>>>>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host
>>>>>> *host,
>>>>>> u32 ocr,
>>>>>>              }
>>>>>>      }
>>>>>>
>>>>>> +    if (!oldcard) {
>>>>>> +            if (card->ext_csd.bkops_en) {
>>>>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>>>>> +                                      mmc_start_idle_time_bkops);
>>>>>> +
>>>>>> INIT_WORK(&card->bkops_info.poll_for_completion,
>>>>>> +                              mmc_bkops_completion_polling);
>>>
>>> I guess you don't have "removable" eMMC with BKOPS support so this
>>> code will in practice only be executed once for an eMMC, so we are
>>> safe. But still I am not fond of putting this code for workqueue here.
>>> Either that should be done as a part of when the card is
>>> created/deleted or when then host is created/deleted.
>> I will check if there could be a better place for this.
>>>
>>>>>> +
>>>>>> +                    /*
>>>>>> +                     * Calculate the time to start the BKOPs
>>>>>> checking.
>>>>>> +                     * The idle time of the host controller should
>>>>>> be
>>>>>> taken
>>>>>> +                     * into account in order to prevent a race
>>>>>> condition
>>>>>> +                     * before starting BKOPs and going into
>>>>>> suspend.
>>>>>> +                     * If the host controller didn't set its idle
>>>>>> time,
>>>>>> +                     * a default value is used.
>>>>>> +                     */
>>>>>> +                    card->bkops_info.delay_ms =
>>>>>> MMC_IDLE_BKOPS_TIME_MS;
>>>>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>>>>> +                            card->bkops_info.delay_ms = min(
>>>>>> +                                    card->bkops_info.delay_ms,
>>>>>> +
>>>>>> card->bkops_info.host_suspend_tout_ms/2);
>>>>>> +            }
>>>>>> +    }
>>>>>> +
>>>>>>      if (!oldcard)
>>>>>>              host->card = card;
>>>>>>
>>>>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>>>>> index 943550d..224e2a5 100644
>>>>>> --- a/include/linux/mmc/card.h
>>>>>> +++ b/include/linux/mmc/card.h
>>>>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>>>>  };
>>>>>>
>>>>>> +/**
>>>>>> + * struct mmc_bkops_info - BKOPS data
>>>>>> + * @dw:     Idle time bkops delayed work
>>>>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>>>>> + * before getting into suspend
>>>>>> + * @delay_ms:       The time to start the BKOPS
>>>>>> + *        delayed work once MMC thread is idle
>>>>>> + * @poll_for_completion:    Poll on BKOPS completion
>>>>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>>>>> + *        should be cancelled
>>>>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>>>>> + *        work was scheduled
>>>>>> + * @sectors_changed:  number of  sectors written or
>>>>>> + *       discard since the last idle BKOPS were scheduled
>>>>>> + */
>>>>>> +struct mmc_bkops_info {
>>>>>> +    struct delayed_work     dw;
>>>>>> +    unsigned int            host_suspend_tout_ms;
>>>
>>> As stated earlier, what is this timeout you are referring to? What
>>> suspend?
>> Explained above.
>>>
>>>>>> +    unsigned int            delay_ms;
>>>>>> +/*
>>>>>> + * A default time for checking the need for non urgent BKOPS once
>>>>>> mmcqd
>>>>>> + * is idle.
>>>>>> + */
>>>>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>>>>> +    struct work_struct      poll_for_completion;
>>>>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>>>>> completion */
>>>>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>>>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>>>>> +    bool                    cancel_delayed_work;
>>>>>> +    bool                    started_delayed_bkops;
>>>>>> +    unsigned int            sectors_changed;
>>>
>>> Could not find "sectors_changed" being used. Maybe you forgot to
>>> remove this from previous version of the patch.
>> Yes, this should be removed.
>>>
>>>>>> +};
>>>>>> +
>>>>>>  /*
>>>>>>   * MMC device
>>>>>>   */
>>>>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>>>>      struct dentry           *debugfs_root;
>>>>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical
>>>>>> partitions */
>>>>>>      unsigned int    nr_parts;
>>>>>> +
>>>>>> +    struct mmc_bkops_info   bkops_info;
>>>>>>  };
>>>>>>
>>>>>>  /*
>>>>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>>>>> index 9b9cdaf..665d345 100644
>>>>>> --- a/include/linux/mmc/core.h
>>>>>> +++ b/include/linux/mmc/core.h
>>>>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>>>>> mmc_card *);
>>>>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card
>>>>>> *,
>>>>>>      struct mmc_command *, int);
>>>>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>>>>> from_exception);
>>>>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>>>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>>>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned
>>>>>> int,
>>>>>> bool);
>>>>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>> --
>>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>>> member
>>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>>
>>>> --
>>>> To unsubscribe from this list: send the line "unsubscribe
>>>> linux-kernel"
>>>> in
>>>> the body of a message to majordomo@vger.kernel.org
>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>> Please read the FAQ at  http://www.tux.org/lkml/
>>>
>>> Finally some overall thoughts. What I would like to understand is how
>>> we decide that the card has become "idle". I belive two values should
>>> be considered, but are they?
>>> 1. The card need BKOPS to be performed for some status level.
>>> 2. Request inactivity for a certain timeout has occured.
>>>
>>> Have you considered to use runtime PM for the card device instead of
>>> the workqueue?
>>>
>>> Kind regards
>>> Ulf Hansson
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>>> the body of a message to majordomo@vger.kernel.org
>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>
>>
>>
>> --
>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>> member
>> of Code Aurora Forum, hosted by The Linux Foundation
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-kernel"
>> in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>> Please read the FAQ at  http://www.tux.org/lkml/
>
> Kind regards
> Ulf Hansson
> --
> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>


-- 
QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
of Code Aurora Forum, hosted by The Linux Foundation

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Ulf Hansson]

On 12 December 2012 13:32,  <merez@codeaurora.org> wrote:
> Hi Ulf,
>
> Sorry for the late response.
> See my reply below.
>
> Thanks,
> Maya
>
> On Thu, December 6, 2012 2:18 am, Ulf Hansson wrote:
>> Hi Maya,
>>
>> On 4 December 2012 22:17,  <merez@codeaurora.org> wrote:
>>> Hi Ulf,
>>>
>>> Let me try to better explain:
>>> The idea behind the periodic BKOPS is to check the card's need for BKOPS
>>> periodically in order to prevent an urgent BKOPS need by the card.
>>> In order to actually manage to prevent the urgent BKOPS need, the host
>>> should give the card enough time to perform the BKOPS (when it
>>> recognizes
>>> BKOPS need), otherwise there is no point in having the periodic BKOPS.
>>> The above results in the following:
>>> 1. After starting non-urgent BKOPS we "delay" getting into suspend by
>>> polling on the card's status (explanation below), in order to give the
>>> card time to perform the BKOPS. This has no effect on the power
>>> consumption since the same BKOPS operations that were performed after
>>> the
>>> foregound operation just moved to another location, meaning before going
>>> into suspend.
>>
>> I am not sure what you are talking about here, runtime suspend or
>> system suspend? Polling the card's status will not prevent any of
>> this. So you have got this wrong.
>
> I am referring to the runtime suspend.
> Our controller implements the runtime suspend and is not using the default
> implementation of core/bus.c.

This is not the "default runtime suspend" for a host device, but for
the card device. Do not mix this up with runtime pm for a host device.

Right now runtime pm for the card _device_ is only enabled for SDIO.
Thus SDIO drivers can use runtime pm to actually trigger an SDIO card
to be fully suspended when it is not needed and thus save a lot of
power. For example when a WLAN interface goes up/down.

> This is the reason why in our implementation polling the card status
> "delays" the runtime suspend while it is not the case when using the
> default runtime suspend implementation.
> I can try to explain here what our controller is doing but since it is
> specific to us then I guess it is not relevant to the discussion.
> Our controller is calling mmc_suspend_host in runtime suspend, which
> issues an HPI to stop the BKOPS.

So, doing mmc_suspend_host in you runtime_suspend callback, is that
really what you want to do?

1.
You will introduce significant latencies (I have seen SD-cards which
needs more than 1 s to initialize, eMMC is better but we are anyway
talking several 100 ms) once new requests arrives after the host as
entered the runtime suspend state.

2.
SD cards has no "power off" notification, so you will actually stress
test the SD cards internal FTL to be crash safe by cutting the power
to it more often.

3.
You will prevent SD-cards from doing it's back ground operations,
which is done automatically and not like in a controlled manner as for
eMMC.

So of course, you save some power, but is the consequences worth it? :-)

> Now that I understand that this code is not needed for all the host
> drivers I will add a flag to decide if polling is required when doing an
> unblocking BKOPS.

You must not poll to prevent this!

Instead you need to prevent the host from going into runtime suspend
state, which is simply done by pm_runtime_get_sync for the host
device.
Although, it _must_ not be done for drivers not doing mmc_suspend_host
in their runtime suspend callbacks. Since then it will prevent these
from doing runtime power save actions, which is not ok.

> Other host drivers that actually suspend on runtime suspend can enable
> this flag and allow BKOPS to be active for a longer period.
> I will prepare a new patch and send it for review.
>
>>
>>> 2. Using PM_SUSPEND_PREPARE instead of the workqueue would not be
>>> efficient since we don't want to wait until the host is ready to get
>>> into
>>> suspend and then prevent him from suspending by doing BKOPS operations
>>> that can take a long time. It is better to start the BKOPS earlier.
>>
>> I did not suggest to use PM_SUSPEND_PREPARE, but to use runtime PM for
>> the card device. It can be an option to implement this feature on top
>> of a workqueue. At least worth to consider.
>>
>
> We consider to call mmc_start_bkops every time MMC becomes idle, to
> check the need for BKOPS. I will test it and include it in the next patch.
>
>>>
>>> I am not too familiar with the controllers code and also my
>>> understanding
>>> in runtime suspend is very basic, so feel free to correct me if I'm
>>> wrong
>>> here or the behavior in other controllers is different from msm_sdcc.
>>> mmc_claim_host calls host->ops->enable. This API is implemented per
>>> controller but as far as I understand it, this API must prevent suspend,
>>> otherwise we might go into suspend while there is bus activity. By doing
>>> get_card_status we call mmc_claim_host and this call is the one that
>>> "delays" getting into suspend.
>>
>> host->ops->enable is the old way of implementing runtime power save
>> for host drivers. Nowadays most drivers is using runtime PM instead.
>>
>> When you say that mmc_claim_host will prevent suspend, I suppose you
>> mean that host->ops->disable wont be called? That is definitely not
>> the same as preventing a system suspend, and moreover it should not.
>> If you think that the host must be prevented from entering runtime
>> power save (runtime_supend or host->ops->disable), you must elaborate
>> more on this, because I don't understand why this is needed.
>>
> Again, this is specific to our controller, so you can just ignore that.
>
>>> If this is not the case in other controllers than the BKOPS will not
>>> prevent the suspend and BKOPS will be interrupted.
>>> As for the effect on the battery consumption, this is probably something
>>> specific to our controller, so sorry if I created a confusion.
>>>
>>> Additional comments inline.
>>>
>>> Thanks,
>>> Maya
>>>
>>> On Tue, December 4, 2012 1:52 am, Ulf Hansson wrote:
>>>> On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
>>>>> Hi Jaehoon,
>>>>>
>>>>> With this patch we don't expect to see any degradation. Thanks for
>>>>> verifying that.
>>>>> The test plan would be to run the lmdd and iozone benchmarks with this
>>>>> patch and verify that the performance is not degraded.
>>>>> I verified it with the msm_sdcc controller.
>>>>>
>>>>> Chris - We do expect it to influence the battery consumption, since we
>>>>> now
>>>>> delay getting into suspend (since mmc_start_bkops which is called
>>>>> after
>>>>> the delayed work is executed claims the host).
>>>>> The solution for that should be done by the controller which can
>>>>> shorten
>>>>> the timeout given to pm_schedule_suspend by the periodic BKOPS idle
>>>>> time.
>>>>> Does it make sense to you?
>>>>>
>>>>> Thanks,
>>>>> Maya
>>>>> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>>>>>> Hi Maya,
>>>>>>
>>>>>> Thank you a lot for working idle time BKOPS.
>>>>>>
>>>>>> I tested with this patch. It's working fine.(Suspend/resume is also
>>>>>> working well.)
>>>>>> Test controller is sdhci controller.
>>>>>> When i tested the performance with iozone, i didn't find that
>>>>>> performance
>>>>>> is decreased.
>>>>>> Well, as Chris is mentioned, do you have any test plan?
>>>>>> So I will test more with this patch, because i want to test with
>>>>>> dw-mmc
>>>>>> controller, too.
>>>>>>
>>>>>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>>>>>> Devices have various maintenance operations need to perform
>>>>>>> internally.
>>>>>>> In order to reduce latencies during time critical operations like
>>>>>>> read
>>>>>>> and write, it is better to execute maintenance operations in other
>>>>>>> times - when the host is not being serviced. Such operations are
>>>>>>> called
>>>>>>> Background operations (BKOPS).
>>>>>>> The device notifies the status of the BKOPS need by updating
>>>>>>> BKOPS_STATUS
>>>>>>> (EXT_CSD byte [246]).
>>>>>>>
>>>>>>> According to the standard a host that supports BKOPS shall check the
>>>>>>> status periodically and start background operations as needed, so
>>>>>>> that
>>>>>>> the device has enough time for its maintenance operations.
>>>>>>>
>>>>>>> This patch adds support for this periodic check of the BKOPS status.
>>>>>>> Since foreground operations are of higher priority than background
>>>>>>> operations the host will check the need for BKOPS when it is idle,
>>>>>>> and in case of an incoming request the BKOPS operation will be
>>>>>>> interrupted.
>>>>>>>
>>>>>>> When the mmcqd thread is idle, a delayed work is created to check
>>>>>>> the
>>>>>>> need for BKOPS. The time to start the delayed work is calculated
>>>>>>> based
>>>>>>> on the host controller suspend timeout, in case it was set. If not,
>>>>>>> a
>>>>>>> default time is used.
>>>>
>>>> What host controller suspend timeout are you referring to here?
>>>>
>>>> If you are thinking of the runtime PM autosuspend timeout used in many
>>>> host driver, then you might have missunderstand how runtime PM is used
>>>> in host drivers.
>>>> This has nothing to do with BKOPS as such, unless you think that the
>>>> card must be kept clocked during BKOPS operations, but then this needs
>>>> to be stated somewhere in this patch and that is not the case.
>>>>
>>>> Moreover, I could not find any new timeout added for the _host_ struct
>>>> in this patch.
>>> Yes, I was referring to the runtime PM autosuspend timeout. Since we
>>> want
>>> to give the BKOPS time to be performed before going into suspend, we
>>> need
>>> to take this timeout into account.
>>
>> Not sure why need to consider this timeout. Anyway, if so you must
>> instead use the runtime PM API to prevent the host from being runtime
>> suspended, like pm_runtime_get_sync.
>>
>>>>
>>>>>>> If BKOPS are required in level 1, which is non-blocking, there will
>>>>>>> be
>>>>>>> polling of the card status to wait for the BKOPS completion and
>>>>>>> prevent
>>>>>>> suspend that will interrupt the BKOPS.
>>>>
>>>> Not sure of what suspend you are talking about here. But for sure
>>>> BKOPS must _never_ prevent a system suspend.
>>>>
>>>> You might want to prevent a host from being runtime suspended though,
>>>> but that is not accomplished in this patch.
>>> This is explained in my general comment. Let me know if it is still not
>>> clear.
>>>>
>>>>>>> If the card raised an exception, the need for urgent BKOPS (level
>>>>>>> 2/3)
>>>>>>> will be checked immediately and if needed, the BKOPS will be
>>>>>>> performed
>>>>>>> without waiting for the next idle time.
>>>>>>>
>>>>>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>>>>>
>>>>>>> ---
>>>>>>> This patch is based on the periodic BKOPS implementation in version
>>>>>>> 8
>>>>>>> of
>>>>>>> "support BKOPS feature for eMMC" patch.
>>>>>>> The patch was modified to answer the following issues:
>>>>>>> - In order to prevent a race condition between going into suspend
>>>>>>> and
>>>>>>> starting BKOPS,
>>>>>>>   the suspend timeout of the host controller is taking into accound
>>>>>>> in
>>>>>>> determination of the start time
>>>>>>>   of the delayed work
>>>>>>> - Since mmc_start_bkops is called from two contexts now,
>>>>>>> mmc_claim_host
>>>>>>> was moved to the beginning of the function
>>>>>>> - Also, the check of doing_bkops should be protected when determing
>>>>>>> if
>>>>>>> an HPI is needed due to the same reason.
>>>>>>>
>>>>>>> Changes in v3:
>>>>>>>     - Move the call to stop_bkops to block.c.
>>>>>>>       This allows us to remove the mmc_claim_host from inside the
>>>>>>> function and doesn't cause additional degradation
>>>>>>>       due to un-neccessary calim host operation
>>>>>>>
>>>>>>> Changes in v2:
>>>>>>>     - Check the number of written / discarded sectors as the trigger
>>>>>>> for
>>>>>>> checking the BKOPS need.
>>>>>>>     - Code review fixes
>>>>>>>
>>>>>>> ---
>>>>>>>  drivers/mmc/card/block.c |    8 ++-
>>>>>>>  drivers/mmc/card/queue.c |    2 +
>>>>>>>  drivers/mmc/core/core.c  |  178
>>>>>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>>>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>>>>>  include/linux/mmc/card.h |   35 +++++++++
>>>>>>>  include/linux/mmc/core.h |    3 +
>>>>>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>>>>>
>>>>>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>>>>>> index 172a768..40b4ae3 100644
>>>>>>> --- a/drivers/mmc/card/block.c
>>>>>>> +++ b/drivers/mmc/card/block.c
>>>>>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct mmc_queue
>>>>>>> *mq,
>>>>>>> struct request *req)
>>>>>>>      struct mmc_blk_data *md = mq->data;
>>>>>>>      struct mmc_card *card = md->queue.card;
>>>>>>>
>>>>>>> -    if (req && !mq->mqrq_prev->req)
>>>>>>> +    if (req && !mq->mqrq_prev->req) {
>>>>>>>              /* claim host only for the first request */
>>>>>>>              mmc_claim_host(card->host);
>>>>>>> +            if (card->ext_csd.bkops_en &&
>>>>>>> +                card->bkops_info.started_delayed_bkops) {
>>>>>>> +                            card->bkops_info.started_delayed_bkops
>>>>>>> =
>>>>>>> false;
>>>>>>> +                            mmc_stop_bkops(card);
>>>>>> We didn't need to check whether mmc_stop_bkops is success or not?
>>>>>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>>>>>
>>>>>> Best Regards,
>>>>>> Jaehoon Chung
>>>>>>
>>>>>>> +            }
>>>>>>> +    }
>>>>>>>
>>>>>>>      ret = mmc_blk_part_switch(card, md);
>>>>>>>      if (ret) {
>>>>>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>>>>>> index fadf52e..9d0c96a 100644
>>>>>>> --- a/drivers/mmc/card/queue.c
>>>>>>> +++ b/drivers/mmc/card/queue.c
>>>>>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)
>>>>>>>  {
>>>>>>>      struct mmc_queue *mq = d;
>>>>>>>      struct request_queue *q = mq->queue;
>>>>>>> +    struct mmc_card *card = mq->card;
>>>>>>>
>>>>>>>      current->flags |= PF_MEMALLOC;
>>>>>>>
>>>>>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>>>>>                              set_current_state(TASK_RUNNING);
>>>>>>>                              break;
>>>>>>>                      }
>>>>>>> +                    mmc_start_delayed_bkops(card);
>>>>>>>                      up(&mq->thread_sem);
>>>>>>>                      schedule();
>>>>>>>                      down(&mq->thread_sem);
>>>>>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>>>>>> index 06c42cf..72ae15b 100644
>>>>>>> --- a/drivers/mmc/core/core.c
>>>>>>> +++ b/drivers/mmc/core/core.c
>>>>>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>>>>>> mmc_request *mrq)
>>>>>>>  }
>>>>>>>
>>>>>>>  /**
>>>>>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>>>>>> + *      the need of non urgent BKOPS
>>>>>>> + *
>>>>>>> + * @card: MMC card to start BKOPS on
>>>>>>> + */
>>>>>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>>>>>> +{
>>>>>>> +    if (!card || !card->ext_csd.bkops_en ||
>>>>>>> mmc_card_doing_bkops(card))
>>>>>>> +            return;
>>>>>>> +
>>>>>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>>>>>> +             mmc_hostname(card->host), __func__);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * cancel_delayed_bkops_work will prevent a race condition
>>>>>>> between
>>>>>>> +     * fetching a request by the mmcqd and the delayed work, in
>>>>>>> case
>>>>>>> +     * it was removed from the queue work but not started yet
>>>>>>> +     */
>>>>>>> +    card->bkops_info.cancel_delayed_work = false;
>>>>>>> +    card->bkops_info.started_delayed_bkops = true;
>>>>>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>>>>>> +                       msecs_to_jiffies(
>>>>>>> +                               card->bkops_info.delay_ms));
>>>>>>> +}
>>>>>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>>>>>> +
>>>>>>> +/**
>>>>>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>>>>>   *  @card: MMC card to start BKOPS
>>>>>>> - *  @form_exception: A flag to indicate if this function was
>>>>>>> + *  @from_exception: A flag to indicate if this function was
>>>>>>>   *                   called due to an exception raised by the card
>>>>>>>   *
>>>>>>>   *  Start background operations whenever requested.
>>>>>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>> bool
>>>>>>> from_exception)
>>>>>>>      bool use_busy_signal;
>>>>>>>
>>>>>>>      BUG_ON(!card);
>>>>>>> -
>>>>>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>>>>>> +    if (!card->ext_csd.bkops_en)
>>>>>>>              return;
>>>>>>>
>>>>>>> +    mmc_claim_host(card->host);
>>>>>>> +
>>>>>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception)
>>>>>>> {
>>>>>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>> +            card->bkops_info.cancel_delayed_work = false;
>>>>>>> +            goto out;
>>>>>>> +    }
>>>>>>> +
>>>>>>> +    if (mmc_card_doing_bkops(card)) {
>>>>>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>> +            goto out;
>>>>>>> +    }
>>>>>>> +
>>>>>>>      err = mmc_read_bkops_status(card);
>>>>>>>      if (err) {
>>>>>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>>>>>                     mmc_hostname(card->host), err);
>>>>>>> -            return;
>>>>>>> +            goto out;
>>>>>>>      }
>>>>>>>
>>>>>>>      if (!card->ext_csd.raw_bkops_status)
>>>>>>> -            return;
>>>>>>> +            goto out;
>>>>>>>
>>>>>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>>>>>> +            mmc_hostname(card->host), __func__,
>>>>>>> +            card->ext_csd.raw_bkops_status);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * If the function was called due to exception but there is no
>>>>>>> need
>>>>>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed
>>>>>>> BKOPs
>>>>>>> +     * work, before going to suspend
>>>>>>> +     */
>>>>>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>>>>>          from_exception)
>>>>>>> -            return;
>>>>>>> +            goto out;
>>>>>>>
>>>>>>> -    mmc_claim_host(card->host);
>>>>>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>>>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>>>>>              use_busy_signal = true;
>>>>>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>> bool
>>>>>>> from_exception)
>>>>>>>       * bkops executed synchronously, otherwise
>>>>>>>       * the operation is in progress
>>>>>>>       */
>>>>>>> -    if (!use_busy_signal)
>>>>>>> +    if (!use_busy_signal) {
>>>>>>>              mmc_card_set_doing_bkops(card);
>>>>>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>> +            queue_work(system_nrt_wq,
>>>>>>> +                       &card->bkops_info.poll_for_completion);
>>>>>>> +    }
>>>>>>> +
>>>>>>>  out:
>>>>>>>      mmc_release_host(card->host);
>>>>>>>  }
>>>>>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>>>>>
>>>>>>> +/**
>>>>>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>>>>>> + * wait for the non-blocking BKOPS completion
>>>>>>> + * @work:   The completion polling work
>>>>>>> + *
>>>>>>> + * The on-going reading of the card status will prevent the card
>>>>>>> + * from getting into suspend while it is in the middle of
>>>>>>> + * performing BKOPS.
>>>>
>>>> Not true! Suspend will not be prevented by doing a mmc_send_status.
>>>> Moreover, I would be interested to understand more about why you need
>>>> to prevent "suspend". Please elaborate why you think this is needed.
>>> This is explained in my general comment. Let me know if it is still not
>>> clear.
>>>>
>>>>>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>>>>>> + * request we also check IF mmc_card_doing_bkops in each
>>>>>>> + * iteration.
>>>>>>> + */
>>>>>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>>>>>> +{
>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>> +                    bkops_info.poll_for_completion);
>>>>>>> +    unsigned long timeout_jiffies = jiffies +
>>>>>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>>>>>> +    u32 status;
>>>>>>> +    int err;
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * Wait for the BKOPs to complete. Keep reading the status to
>>>>>>> prevent
>>>>>>> +     * the host from getting into suspend
>>>>>>> +     */
>>>>>>> +    do {
>>>>>>> +            mmc_claim_host(card->host);
>>>>>>> +
>>>>>>> +            if (!mmc_card_doing_bkops(card))
>>>>>>> +                    goto out;
>>>>>>> +
>>>>>>> +            err = mmc_send_status(card, &status);
>>>>>>> +            if (err) {
>>>>>>> +                    pr_err("%s: error %d requesting status\n",
>>>>>>> +                           mmc_hostname(card->host), err);
>>>>>>> +                    goto out;
>>>>>>> +            }
>>>>>>> +
>>>>>>> +            /*
>>>>>>> +             * Some cards mishandle the status bits, so make sure
>>>>>>> to
>>>>>>> check
>>>>>>> +             * both the busy indication and the card state.
>>>>>>> +             */
>>>>>>> +            if ((status & R1_READY_FOR_DATA) &&
>>>>>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>>>>>> +                    pr_debug("%s: %s: completed BKOPs, exit
>>>>>>> polling\n",
>>>>>>> +                             mmc_hostname(card->host), __func__);
>>>>>>> +                    mmc_card_clr_doing_bkops(card);
>>>>>>> +                    card->bkops_info.started_delayed_bkops = false;
>>>>>>> +                    goto out;
>>>>>>> +            }
>>>>>>> +
>>>>>>> +            mmc_release_host(card->host);
>>>>>>> +
>>>>>>> +            /*
>>>>>>> +             * Sleep before checking the card status again to allow
>>>>>>> the
>>>>>>> +             * card to complete the BKOPs operation
>>>>>>> +             */
>>>>>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>>>>>> +    } while (time_before(jiffies, timeout_jiffies));
>>>>>>> +
>>>>>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>>>>>> +           mmc_hostname(card->host), __func__);
>>>>>>> +
>>>>>>> +    return;
>>>>>>> +out:
>>>>>>> +    mmc_release_host(card->host);
>>>>>>> +}
>>>>>>> +
>>>>>>> +/**
>>>>>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>>>>>> + * needed
>>>>>>> + * @work:   The idle time BKOPS work
>>>>>>> + */
>>>>>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>>>>>> +{
>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>> +                    bkops_info.dw.work);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * Prevent a race condition between mmc_stop_bkops and the
>>>>>>> delayed
>>>>>>> +     * BKOPS work in case the delayed work is executed on another
>>>>>>> CPU
>>>>>>> +     */
>>>>>>> +    if (card->bkops_info.cancel_delayed_work)
>>>>>>> +            return;
>>>>>>> +
>>>>>>> +    mmc_start_bkops(card, false);
>>>>>>> +}
>>>>>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>>>>>> +
>>>>>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>>>>>  {
>>>>>>>      complete(&mrq->completion);
>>>>>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>      int err = 0;
>>>>>>>
>>>>>>>      BUG_ON(!card);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * Notify the delayed work to be cancelled, in case it was
>>>>>>> already
>>>>>>> +     * removed from the queue, but was not started yet
>>>>>>> +     */
>>>>>>> +    card->bkops_info.cancel_delayed_work = true;
>>>>>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>>>>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>>>>>> +    if (!mmc_card_doing_bkops(card))
>>>>>>> +            goto out;
>>>>>>> +
>>>>>>>      err = mmc_interrupt_hpi(card);
>>>>>>>
>>>>>>>      /*
>>>>>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>              err = 0;
>>>>>>>      }
>>>>>>>
>>>>>>> +out:
>>>>>>>      return err;
>>>>>>>  }
>>>>>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>>>>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>>>>>> *notify_block,
>>>>>>>      switch (mode) {
>>>>>>>      case PM_HIBERNATION_PREPARE:
>>>>>>>      case PM_SUSPEND_PREPARE:
>>>>>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>>>>>> -                mmc_card_doing_bkops(host->card)) {
>>>>>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>>>>>> +                    mmc_claim_host(host);
>>>>>>>                      err = mmc_stop_bkops(host->card);
>>>>>>> +                    mmc_release_host(host);
>>>>
>>>> This code seems a bit strange. You will check for mmc_card_mmc, but
>>>> not all (e)MMC will support bkops. How about acually just checking if
>>>> bkops is "on" or "off" somehow.
>>>>
>>>> Additionally, so this piece of code shall stop an ongoing bkops before
>>>> going to suspend, so that make sense. But would it not be more
>>>> meaningfull to take care of that in mmc_suspend_host? I mean why do yo
>>>> need to do it in the PM_SUSPEND_PREPARE notification sequence
>>>> especially?
>>> This code was not added by me. I just added the
>>> mmc_claim_host(host)/mmc_release_host calls. Maybe Jaehoon, who added
>>> this
>>> code in the BKOPS patch can respond to your comment.
>>>>
>>>>>>>                      if (err) {
>>>>>>>                              pr_err("%s: didn't stop bkops\n",
>>>>>>>                                      mmc_hostname(host));
>>>>>>>                              return err;
>>>>>>>                      }
>>>>>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>>>>>              }
>>>>>>>
>>>>>>>              spin_lock_irqsave(&host->lock, flags);
>>>>>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>>>>>> index 7cc4638..dba76e3 100644
>>>>>>> --- a/drivers/mmc/core/mmc.c
>>>>>>> +++ b/drivers/mmc/core/mmc.c
>>>>>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host
>>>>>>> *host,
>>>>>>> u32 ocr,
>>>>>>>              }
>>>>>>>      }
>>>>>>>
>>>>>>> +    if (!oldcard) {
>>>>>>> +            if (card->ext_csd.bkops_en) {
>>>>>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>>>>>> +                                      mmc_start_idle_time_bkops);
>>>>>>> +
>>>>>>> INIT_WORK(&card->bkops_info.poll_for_completion,
>>>>>>> +                              mmc_bkops_completion_polling);
>>>>
>>>> I guess you don't have "removable" eMMC with BKOPS support so this
>>>> code will in practice only be executed once for an eMMC, so we are
>>>> safe. But still I am not fond of putting this code for workqueue here.
>>>> Either that should be done as a part of when the card is
>>>> created/deleted or when then host is created/deleted.
>>> I will check if there could be a better place for this.
>>>>
>>>>>>> +
>>>>>>> +                    /*
>>>>>>> +                     * Calculate the time to start the BKOPs
>>>>>>> checking.
>>>>>>> +                     * The idle time of the host controller should
>>>>>>> be
>>>>>>> taken
>>>>>>> +                     * into account in order to prevent a race
>>>>>>> condition
>>>>>>> +                     * before starting BKOPs and going into
>>>>>>> suspend.
>>>>>>> +                     * If the host controller didn't set its idle
>>>>>>> time,
>>>>>>> +                     * a default value is used.
>>>>>>> +                     */
>>>>>>> +                    card->bkops_info.delay_ms =
>>>>>>> MMC_IDLE_BKOPS_TIME_MS;
>>>>>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>>>>>> +                            card->bkops_info.delay_ms = min(
>>>>>>> +                                    card->bkops_info.delay_ms,
>>>>>>> +
>>>>>>> card->bkops_info.host_suspend_tout_ms/2);
>>>>>>> +            }
>>>>>>> +    }
>>>>>>> +
>>>>>>>      if (!oldcard)
>>>>>>>              host->card = card;
>>>>>>>
>>>>>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>>>>>> index 943550d..224e2a5 100644
>>>>>>> --- a/include/linux/mmc/card.h
>>>>>>> +++ b/include/linux/mmc/card.h
>>>>>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>>>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>>>>>  };
>>>>>>>
>>>>>>> +/**
>>>>>>> + * struct mmc_bkops_info - BKOPS data
>>>>>>> + * @dw:     Idle time bkops delayed work
>>>>>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>>>>>> + * before getting into suspend
>>>>>>> + * @delay_ms:       The time to start the BKOPS
>>>>>>> + *        delayed work once MMC thread is idle
>>>>>>> + * @poll_for_completion:    Poll on BKOPS completion
>>>>>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>>>>>> + *        should be cancelled
>>>>>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>>>>>> + *        work was scheduled
>>>>>>> + * @sectors_changed:  number of  sectors written or
>>>>>>> + *       discard since the last idle BKOPS were scheduled
>>>>>>> + */
>>>>>>> +struct mmc_bkops_info {
>>>>>>> +    struct delayed_work     dw;
>>>>>>> +    unsigned int            host_suspend_tout_ms;
>>>>
>>>> As stated earlier, what is this timeout you are referring to? What
>>>> suspend?
>>> Explained above.
>>>>
>>>>>>> +    unsigned int            delay_ms;
>>>>>>> +/*
>>>>>>> + * A default time for checking the need for non urgent BKOPS once
>>>>>>> mmcqd
>>>>>>> + * is idle.
>>>>>>> + */
>>>>>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>>>>>> +    struct work_struct      poll_for_completion;
>>>>>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>>>>>> completion */
>>>>>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>>>>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>>>>>> +    bool                    cancel_delayed_work;
>>>>>>> +    bool                    started_delayed_bkops;
>>>>>>> +    unsigned int            sectors_changed;
>>>>
>>>> Could not find "sectors_changed" being used. Maybe you forgot to
>>>> remove this from previous version of the patch.
>>> Yes, this should be removed.
>>>>
>>>>>>> +};
>>>>>>> +
>>>>>>>  /*
>>>>>>>   * MMC device
>>>>>>>   */
>>>>>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>>>>>      struct dentry           *debugfs_root;
>>>>>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical
>>>>>>> partitions */
>>>>>>>      unsigned int    nr_parts;
>>>>>>> +
>>>>>>> +    struct mmc_bkops_info   bkops_info;
>>>>>>>  };
>>>>>>>
>>>>>>>  /*
>>>>>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>>>>>> index 9b9cdaf..665d345 100644
>>>>>>> --- a/include/linux/mmc/core.h
>>>>>>> +++ b/include/linux/mmc/core.h
>>>>>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>>>>>> mmc_card *);
>>>>>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card
>>>>>>> *,
>>>>>>>      struct mmc_command *, int);
>>>>>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>>>>>> from_exception);
>>>>>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>>>>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>>>>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>>>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned
>>>>>>> int,
>>>>>>> bool);
>>>>>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>>>> member
>>>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>>>
>>>>> --
>>>>> To unsubscribe from this list: send the line "unsubscribe
>>>>> linux-kernel"
>>>>> in
>>>>> the body of a message to majordomo@vger.kernel.org
>>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>> Please read the FAQ at  http://www.tux.org/lkml/
>>>>
>>>> Finally some overall thoughts. What I would like to understand is how
>>>> we decide that the card has become "idle". I belive two values should
>>>> be considered, but are they?
>>>> 1. The card need BKOPS to be performed for some status level.
>>>> 2. Request inactivity for a certain timeout has occured.
>>>>
>>>> Have you considered to use runtime PM for the card device instead of
>>>> the workqueue?
>>>>
>>>> Kind regards
>>>> Ulf Hansson
>>>> --
>>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>>>> the body of a message to majordomo@vger.kernel.org
>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>
>>>
>>>
>>> --
>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>> member
>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-kernel"
>>> in
>>> the body of a message to majordomo@vger.kernel.org
>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>> Please read the FAQ at  http://www.tux.org/lkml/
>>
>> Kind regards
>> Ulf Hansson
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>
>
>
> --
> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
> of Code Aurora Forum, hosted by The Linux Foundation
>

Kind regards
Ulf Hansson

RE: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Maya Erez]

Hi Ulf,

Thanks for the info. We will consider our controller behavior in suspend.
Would it be acceptable by you to keep the polling for BKOPS completion under
a special CAPS2 flag?

Thanks,
Maya

-----Original Message-----
From: linux-mmc-owner@vger.kernel.org
[mailto:linux-mmc-owner@vger.kernel.org] On Behalf Of Ulf Hansson
Sent: Thursday, December 13, 2012 12:18 PM
To: merez@codeaurora.org
Cc: Jaehoon Chung; linux-mmc@vger.kernel.org; linux-arm-msm@vger.kernel.org;
open list
Subject: Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

On 12 December 2012 13:32,  <merez@codeaurora.org> wrote:
> Hi Ulf,
>
> Sorry for the late response.
> See my reply below.
>
> Thanks,
> Maya
>
> On Thu, December 6, 2012 2:18 am, Ulf Hansson wrote:
>> Hi Maya,
>>
>> On 4 December 2012 22:17,  <merez@codeaurora.org> wrote:
>>> Hi Ulf,
>>>
>>> Let me try to better explain:
>>> The idea behind the periodic BKOPS is to check the card's need for 
>>> BKOPS periodically in order to prevent an urgent BKOPS need by the card.
>>> In order to actually manage to prevent the urgent BKOPS need, the 
>>> host should give the card enough time to perform the BKOPS (when it 
>>> recognizes BKOPS need), otherwise there is no point in having the 
>>> periodic BKOPS.
>>> The above results in the following:
>>> 1. After starting non-urgent BKOPS we "delay" getting into suspend 
>>> by polling on the card's status (explanation below), in order to 
>>> give the card time to perform the BKOPS. This has no effect on the 
>>> power consumption since the same BKOPS operations that were 
>>> performed after the foregound operation just moved to another 
>>> location, meaning before going into suspend.
>>
>> I am not sure what you are talking about here, runtime suspend or 
>> system suspend? Polling the card's status will not prevent any of 
>> this. So you have got this wrong.
>
> I am referring to the runtime suspend.
> Our controller implements the runtime suspend and is not using the 
> default implementation of core/bus.c.

This is not the "default runtime suspend" for a host device, but for the
card device. Do not mix this up with runtime pm for a host device.

Right now runtime pm for the card _device_ is only enabled for SDIO.
Thus SDIO drivers can use runtime pm to actually trigger an SDIO card to be
fully suspended when it is not needed and thus save a lot of power. For
example when a WLAN interface goes up/down.

> This is the reason why in our implementation polling the card status 
> "delays" the runtime suspend while it is not the case when using the 
> default runtime suspend implementation.
> I can try to explain here what our controller is doing but since it is 
> specific to us then I guess it is not relevant to the discussion.
> Our controller is calling mmc_suspend_host in runtime suspend, which 
> issues an HPI to stop the BKOPS.

So, doing mmc_suspend_host in you runtime_suspend callback, is that really
what you want to do?

1.
You will introduce significant latencies (I have seen SD-cards which needs
more than 1 s to initialize, eMMC is better but we are anyway talking
several 100 ms) once new requests arrives after the host as entered the
runtime suspend state.

2.
SD cards has no "power off" notification, so you will actually stress test
the SD cards internal FTL to be crash safe by cutting the power to it more
often.

3.
You will prevent SD-cards from doing it's back ground operations, which is
done automatically and not like in a controlled manner as for eMMC.

So of course, you save some power, but is the consequences worth it? :-)

> Now that I understand that this code is not needed for all the host 
> drivers I will add a flag to decide if polling is required when doing 
> an unblocking BKOPS.

You must not poll to prevent this!

Instead you need to prevent the host from going into runtime suspend state,
which is simply done by pm_runtime_get_sync for the host device.
Although, it _must_ not be done for drivers not doing mmc_suspend_host in
their runtime suspend callbacks. Since then it will prevent these from doing
runtime power save actions, which is not ok.

> Other host drivers that actually suspend on runtime suspend can enable 
> this flag and allow BKOPS to be active for a longer period.
> I will prepare a new patch and send it for review.
>
>>
>>> 2. Using PM_SUSPEND_PREPARE instead of the workqueue would not be 
>>> efficient since we don't want to wait until the host is ready to get 
>>> into suspend and then prevent him from suspending by doing BKOPS 
>>> operations that can take a long time. It is better to start the 
>>> BKOPS earlier.
>>
>> I did not suggest to use PM_SUSPEND_PREPARE, but to use runtime PM 
>> for the card device. It can be an option to implement this feature on 
>> top of a workqueue. At least worth to consider.
>>
>
> We consider to call mmc_start_bkops every time MMC becomes idle, to 
> check the need for BKOPS. I will test it and include it in the next patch.
>
>>>
>>> I am not too familiar with the controllers code and also my 
>>> understanding in runtime suspend is very basic, so feel free to 
>>> correct me if I'm wrong here or the behavior in other controllers is 
>>> different from msm_sdcc.
>>> mmc_claim_host calls host->ops->enable. This API is implemented per 
>>> controller but as far as I understand it, this API must prevent 
>>> suspend, otherwise we might go into suspend while there is bus 
>>> activity. By doing get_card_status we call mmc_claim_host and this 
>>> call is the one that "delays" getting into suspend.
>>
>> host->ops->enable is the old way of implementing runtime power save
>> for host drivers. Nowadays most drivers is using runtime PM instead.
>>
>> When you say that mmc_claim_host will prevent suspend, I suppose you 
>> mean that host->ops->disable wont be called? That is definitely not 
>> the same as preventing a system suspend, and moreover it should not.
>> If you think that the host must be prevented from entering runtime 
>> power save (runtime_supend or host->ops->disable), you must elaborate 
>> more on this, because I don't understand why this is needed.
>>
> Again, this is specific to our controller, so you can just ignore that.
>
>>> If this is not the case in other controllers than the BKOPS will not 
>>> prevent the suspend and BKOPS will be interrupted.
>>> As for the effect on the battery consumption, this is probably 
>>> something specific to our controller, so sorry if I created a confusion.
>>>
>>> Additional comments inline.
>>>
>>> Thanks,
>>> Maya
>>>
>>> On Tue, December 4, 2012 1:52 am, Ulf Hansson wrote:
>>>> On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
>>>>> Hi Jaehoon,
>>>>>
>>>>> With this patch we don't expect to see any degradation. Thanks for 
>>>>> verifying that.
>>>>> The test plan would be to run the lmdd and iozone benchmarks with 
>>>>> this patch and verify that the performance is not degraded.
>>>>> I verified it with the msm_sdcc controller.
>>>>>
>>>>> Chris - We do expect it to influence the battery consumption, 
>>>>> since we now delay getting into suspend (since mmc_start_bkops 
>>>>> which is called after the delayed work is executed claims the 
>>>>> host).
>>>>> The solution for that should be done by the controller which can 
>>>>> shorten the timeout given to pm_schedule_suspend by the periodic 
>>>>> BKOPS idle time.
>>>>> Does it make sense to you?
>>>>>
>>>>> Thanks,
>>>>> Maya
>>>>> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>>>>>> Hi Maya,
>>>>>>
>>>>>> Thank you a lot for working idle time BKOPS.
>>>>>>
>>>>>> I tested with this patch. It's working fine.(Suspend/resume is 
>>>>>> also working well.) Test controller is sdhci controller.
>>>>>> When i tested the performance with iozone, i didn't find that 
>>>>>> performance is decreased.
>>>>>> Well, as Chris is mentioned, do you have any test plan?
>>>>>> So I will test more with this patch, because i want to test with 
>>>>>> dw-mmc controller, too.
>>>>>>
>>>>>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>>>>>> Devices have various maintenance operations need to perform 
>>>>>>> internally.
>>>>>>> In order to reduce latencies during time critical operations 
>>>>>>> like read and write, it is better to execute maintenance 
>>>>>>> operations in other times - when the host is not being serviced. 
>>>>>>> Such operations are called Background operations (BKOPS).
>>>>>>> The device notifies the status of the BKOPS need by updating 
>>>>>>> BKOPS_STATUS (EXT_CSD byte [246]).
>>>>>>>
>>>>>>> According to the standard a host that supports BKOPS shall check 
>>>>>>> the status periodically and start background operations as 
>>>>>>> needed, so that the device has enough time for its maintenance 
>>>>>>> operations.
>>>>>>>
>>>>>>> This patch adds support for this periodic check of the BKOPS status.
>>>>>>> Since foreground operations are of higher priority than 
>>>>>>> background operations the host will check the need for BKOPS 
>>>>>>> when it is idle, and in case of an incoming request the BKOPS 
>>>>>>> operation will be interrupted.
>>>>>>>
>>>>>>> When the mmcqd thread is idle, a delayed work is created to 
>>>>>>> check the need for BKOPS. The time to start the delayed work is 
>>>>>>> calculated based on the host controller suspend timeout, in case 
>>>>>>> it was set. If not, a default time is used.
>>>>
>>>> What host controller suspend timeout are you referring to here?
>>>>
>>>> If you are thinking of the runtime PM autosuspend timeout used in 
>>>> many host driver, then you might have missunderstand how runtime PM 
>>>> is used in host drivers.
>>>> This has nothing to do with BKOPS as such, unless you think that 
>>>> the card must be kept clocked during BKOPS operations, but then 
>>>> this needs to be stated somewhere in this patch and that is not the
case.
>>>>
>>>> Moreover, I could not find any new timeout added for the _host_ 
>>>> struct in this patch.
>>> Yes, I was referring to the runtime PM autosuspend timeout. Since we 
>>> want to give the BKOPS time to be performed before going into 
>>> suspend, we need to take this timeout into account.
>>
>> Not sure why need to consider this timeout. Anyway, if so you must 
>> instead use the runtime PM API to prevent the host from being runtime 
>> suspended, like pm_runtime_get_sync.
>>
>>>>
>>>>>>> If BKOPS are required in level 1, which is non-blocking, there 
>>>>>>> will be polling of the card status to wait for the BKOPS 
>>>>>>> completion and prevent suspend that will interrupt the BKOPS.
>>>>
>>>> Not sure of what suspend you are talking about here. But for sure 
>>>> BKOPS must _never_ prevent a system suspend.
>>>>
>>>> You might want to prevent a host from being runtime suspended 
>>>> though, but that is not accomplished in this patch.
>>> This is explained in my general comment. Let me know if it is still 
>>> not clear.
>>>>
>>>>>>> If the card raised an exception, the need for urgent BKOPS 
>>>>>>> (level
>>>>>>> 2/3)
>>>>>>> will be checked immediately and if needed, the BKOPS will be 
>>>>>>> performed without waiting for the next idle time.
>>>>>>>
>>>>>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>>>>>
>>>>>>> ---
>>>>>>> This patch is based on the periodic BKOPS implementation in 
>>>>>>> version
>>>>>>> 8
>>>>>>> of
>>>>>>> "support BKOPS feature for eMMC" patch.
>>>>>>> The patch was modified to answer the following issues:
>>>>>>> - In order to prevent a race condition between going into 
>>>>>>> suspend and starting BKOPS,
>>>>>>>   the suspend timeout of the host controller is taking into 
>>>>>>> accound in determination of the start time
>>>>>>>   of the delayed work
>>>>>>> - Since mmc_start_bkops is called from two contexts now, 
>>>>>>> mmc_claim_host was moved to the beginning of the function
>>>>>>> - Also, the check of doing_bkops should be protected when 
>>>>>>> determing if an HPI is needed due to the same reason.
>>>>>>>
>>>>>>> Changes in v3:
>>>>>>>     - Move the call to stop_bkops to block.c.
>>>>>>>       This allows us to remove the mmc_claim_host from inside 
>>>>>>> the function and doesn't cause additional degradation
>>>>>>>       due to un-neccessary calim host operation
>>>>>>>
>>>>>>> Changes in v2:
>>>>>>>     - Check the number of written / discarded sectors as the 
>>>>>>> trigger for checking the BKOPS need.
>>>>>>>     - Code review fixes
>>>>>>>
>>>>>>> ---
>>>>>>>  drivers/mmc/card/block.c |    8 ++-
>>>>>>>  drivers/mmc/card/queue.c |    2 +
>>>>>>>  drivers/mmc/core/core.c  |  178
>>>>>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>>>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>>>>>  include/linux/mmc/card.h |   35 +++++++++
>>>>>>>  include/linux/mmc/core.h |    3 +
>>>>>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>>>>>
>>>>>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c 
>>>>>>> index 172a768..40b4ae3 100644
>>>>>>> --- a/drivers/mmc/card/block.c
>>>>>>> +++ b/drivers/mmc/card/block.c
>>>>>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct 
>>>>>>> mmc_queue *mq, struct request *req)
>>>>>>>      struct mmc_blk_data *md = mq->data;
>>>>>>>      struct mmc_card *card = md->queue.card;
>>>>>>>
>>>>>>> -    if (req && !mq->mqrq_prev->req)
>>>>>>> +    if (req && !mq->mqrq_prev->req) {
>>>>>>>              /* claim host only for the first request */
>>>>>>>              mmc_claim_host(card->host);
>>>>>>> +            if (card->ext_csd.bkops_en &&
>>>>>>> +                card->bkops_info.started_delayed_bkops) {
>>>>>>> +                            
>>>>>>> + card->bkops_info.started_delayed_bkops
>>>>>>> =
>>>>>>> false;
>>>>>>> +                            mmc_stop_bkops(card);
>>>>>> We didn't need to check whether mmc_stop_bkops is success or not?
>>>>>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>>>>>
>>>>>> Best Regards,
>>>>>> Jaehoon Chung
>>>>>>
>>>>>>> +            }
>>>>>>> +    }
>>>>>>>
>>>>>>>      ret = mmc_blk_part_switch(card, md);
>>>>>>>      if (ret) {
>>>>>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c 
>>>>>>> index fadf52e..9d0c96a 100644
>>>>>>> --- a/drivers/mmc/card/queue.c
>>>>>>> +++ b/drivers/mmc/card/queue.c
>>>>>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)  {
>>>>>>>      struct mmc_queue *mq = d;
>>>>>>>      struct request_queue *q = mq->queue;
>>>>>>> +    struct mmc_card *card = mq->card;
>>>>>>>
>>>>>>>      current->flags |= PF_MEMALLOC;
>>>>>>>
>>>>>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>>>>>                              set_current_state(TASK_RUNNING);
>>>>>>>                              break;
>>>>>>>                      }
>>>>>>> +                    mmc_start_delayed_bkops(card);
>>>>>>>                      up(&mq->thread_sem);
>>>>>>>                      schedule();
>>>>>>>                      down(&mq->thread_sem);
>>>>>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>>>>>> index 06c42cf..72ae15b 100644
>>>>>>> --- a/drivers/mmc/core/core.c
>>>>>>> +++ b/drivers/mmc/core/core.c
>>>>>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>>>>>> mmc_request *mrq)
>>>>>>>  }
>>>>>>>
>>>>>>>  /**
>>>>>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>>>>>> + *      the need of non urgent BKOPS
>>>>>>> + *
>>>>>>> + * @card: MMC card to start BKOPS on
>>>>>>> + */
>>>>>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>>>>>> +{
>>>>>>> +    if (!card || !card->ext_csd.bkops_en ||
>>>>>>> mmc_card_doing_bkops(card))
>>>>>>> +            return;
>>>>>>> +
>>>>>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>>>>>> +             mmc_hostname(card->host), __func__);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * cancel_delayed_bkops_work will prevent a race condition
>>>>>>> between
>>>>>>> +     * fetching a request by the mmcqd and the delayed work, in
>>>>>>> case
>>>>>>> +     * it was removed from the queue work but not started yet
>>>>>>> +     */
>>>>>>> +    card->bkops_info.cancel_delayed_work = false;
>>>>>>> +    card->bkops_info.started_delayed_bkops = true;
>>>>>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>>>>>> +                       msecs_to_jiffies(
>>>>>>> +                               card->bkops_info.delay_ms));
>>>>>>> +}
>>>>>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>>>>>> +
>>>>>>> +/**
>>>>>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>>>>>   *  @card: MMC card to start BKOPS
>>>>>>> - *  @form_exception: A flag to indicate if this function was
>>>>>>> + *  @from_exception: A flag to indicate if this function was
>>>>>>>   *                   called due to an exception raised by the card
>>>>>>>   *
>>>>>>>   *  Start background operations whenever requested.
>>>>>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>> bool
>>>>>>> from_exception)
>>>>>>>      bool use_busy_signal;
>>>>>>>
>>>>>>>      BUG_ON(!card);
>>>>>>> -
>>>>>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>>>>>> +    if (!card->ext_csd.bkops_en)
>>>>>>>              return;
>>>>>>>
>>>>>>> +    mmc_claim_host(card->host);
>>>>>>> +
>>>>>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception)
>>>>>>> {
>>>>>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>> +            card->bkops_info.cancel_delayed_work = false;
>>>>>>> +            goto out;
>>>>>>> +    }
>>>>>>> +
>>>>>>> +    if (mmc_card_doing_bkops(card)) {
>>>>>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>> +            goto out;
>>>>>>> +    }
>>>>>>> +
>>>>>>>      err = mmc_read_bkops_status(card);
>>>>>>>      if (err) {
>>>>>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>>>>>                     mmc_hostname(card->host), err);
>>>>>>> -            return;
>>>>>>> +            goto out;
>>>>>>>      }
>>>>>>>
>>>>>>>      if (!card->ext_csd.raw_bkops_status)
>>>>>>> -            return;
>>>>>>> +            goto out;
>>>>>>>
>>>>>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>>>>>> +            mmc_hostname(card->host), __func__,
>>>>>>> +            card->ext_csd.raw_bkops_status);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * If the function was called due to exception but there is no
>>>>>>> need
>>>>>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed
>>>>>>> BKOPs
>>>>>>> +     * work, before going to suspend
>>>>>>> +     */
>>>>>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>>>>>          from_exception)
>>>>>>> -            return;
>>>>>>> +            goto out;
>>>>>>>
>>>>>>> -    mmc_claim_host(card->host);
>>>>>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>>>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>>>>>              use_busy_signal = true;
>>>>>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>> bool
>>>>>>> from_exception)
>>>>>>>       * bkops executed synchronously, otherwise
>>>>>>>       * the operation is in progress
>>>>>>>       */
>>>>>>> -    if (!use_busy_signal)
>>>>>>> +    if (!use_busy_signal) {
>>>>>>>              mmc_card_set_doing_bkops(card);
>>>>>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>> +            queue_work(system_nrt_wq,
>>>>>>> +                       &card->bkops_info.poll_for_completion);
>>>>>>> +    }
>>>>>>> +
>>>>>>>  out:
>>>>>>>      mmc_release_host(card->host);
>>>>>>>  }
>>>>>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>>>>>
>>>>>>> +/**
>>>>>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>>>>>> + * wait for the non-blocking BKOPS completion
>>>>>>> + * @work:   The completion polling work
>>>>>>> + *
>>>>>>> + * The on-going reading of the card status will prevent the card
>>>>>>> + * from getting into suspend while it is in the middle of
>>>>>>> + * performing BKOPS.
>>>>
>>>> Not true! Suspend will not be prevented by doing a mmc_send_status.
>>>> Moreover, I would be interested to understand more about why you need
>>>> to prevent "suspend". Please elaborate why you think this is needed.
>>> This is explained in my general comment. Let me know if it is still not
>>> clear.
>>>>
>>>>>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>>>>>> + * request we also check IF mmc_card_doing_bkops in each
>>>>>>> + * iteration.
>>>>>>> + */
>>>>>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>>>>>> +{
>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>> +                    bkops_info.poll_for_completion);
>>>>>>> +    unsigned long timeout_jiffies = jiffies +
>>>>>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>>>>>> +    u32 status;
>>>>>>> +    int err;
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * Wait for the BKOPs to complete. Keep reading the status to
>>>>>>> prevent
>>>>>>> +     * the host from getting into suspend
>>>>>>> +     */
>>>>>>> +    do {
>>>>>>> +            mmc_claim_host(card->host);
>>>>>>> +
>>>>>>> +            if (!mmc_card_doing_bkops(card))
>>>>>>> +                    goto out;
>>>>>>> +
>>>>>>> +            err = mmc_send_status(card, &status);
>>>>>>> +            if (err) {
>>>>>>> +                    pr_err("%s: error %d requesting status\n",
>>>>>>> +                           mmc_hostname(card->host), err);
>>>>>>> +                    goto out;
>>>>>>> +            }
>>>>>>> +
>>>>>>> +            /*
>>>>>>> +             * Some cards mishandle the status bits, so make sure
>>>>>>> to
>>>>>>> check
>>>>>>> +             * both the busy indication and the card state.
>>>>>>> +             */
>>>>>>> +            if ((status & R1_READY_FOR_DATA) &&
>>>>>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>>>>>> +                    pr_debug("%s: %s: completed BKOPs, exit
>>>>>>> polling\n",
>>>>>>> +                             mmc_hostname(card->host), __func__);
>>>>>>> +                    mmc_card_clr_doing_bkops(card);
>>>>>>> +                    card->bkops_info.started_delayed_bkops = false;
>>>>>>> +                    goto out;
>>>>>>> +            }
>>>>>>> +
>>>>>>> +            mmc_release_host(card->host);
>>>>>>> +
>>>>>>> +            /*
>>>>>>> +             * Sleep before checking the card status again to allow
>>>>>>> the
>>>>>>> +             * card to complete the BKOPs operation
>>>>>>> +             */
>>>>>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>>>>>> +    } while (time_before(jiffies, timeout_jiffies));
>>>>>>> +
>>>>>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>>>>>> +           mmc_hostname(card->host), __func__);
>>>>>>> +
>>>>>>> +    return;
>>>>>>> +out:
>>>>>>> +    mmc_release_host(card->host);
>>>>>>> +}
>>>>>>> +
>>>>>>> +/**
>>>>>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>>>>>> + * needed
>>>>>>> + * @work:   The idle time BKOPS work
>>>>>>> + */
>>>>>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>>>>>> +{
>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>> +                    bkops_info.dw.work);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * Prevent a race condition between mmc_stop_bkops and the
>>>>>>> delayed
>>>>>>> +     * BKOPS work in case the delayed work is executed on another
>>>>>>> CPU
>>>>>>> +     */
>>>>>>> +    if (card->bkops_info.cancel_delayed_work)
>>>>>>> +            return;
>>>>>>> +
>>>>>>> +    mmc_start_bkops(card, false);
>>>>>>> +}
>>>>>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>>>>>> +
>>>>>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>>>>>  {
>>>>>>>      complete(&mrq->completion);
>>>>>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>      int err = 0;
>>>>>>>
>>>>>>>      BUG_ON(!card);
>>>>>>> +
>>>>>>> +    /*
>>>>>>> +     * Notify the delayed work to be cancelled, in case it was
>>>>>>> already
>>>>>>> +     * removed from the queue, but was not started yet
>>>>>>> +     */
>>>>>>> +    card->bkops_info.cancel_delayed_work = true;
>>>>>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>>>>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>>>>>> +    if (!mmc_card_doing_bkops(card))
>>>>>>> +            goto out;
>>>>>>> +
>>>>>>>      err = mmc_interrupt_hpi(card);
>>>>>>>
>>>>>>>      /*
>>>>>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>              err = 0;
>>>>>>>      }
>>>>>>>
>>>>>>> +out:
>>>>>>>      return err;
>>>>>>>  }
>>>>>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>>>>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>>>>>> *notify_block,
>>>>>>>      switch (mode) {
>>>>>>>      case PM_HIBERNATION_PREPARE:
>>>>>>>      case PM_SUSPEND_PREPARE:
>>>>>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>>>>>> -                mmc_card_doing_bkops(host->card)) {
>>>>>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>>>>>> +                    mmc_claim_host(host);
>>>>>>>                      err = mmc_stop_bkops(host->card);
>>>>>>> +                    mmc_release_host(host);
>>>>
>>>> This code seems a bit strange. You will check for mmc_card_mmc, but
>>>> not all (e)MMC will support bkops. How about acually just checking if
>>>> bkops is "on" or "off" somehow.
>>>>
>>>> Additionally, so this piece of code shall stop an ongoing bkops before
>>>> going to suspend, so that make sense. But would it not be more
>>>> meaningfull to take care of that in mmc_suspend_host? I mean why do yo
>>>> need to do it in the PM_SUSPEND_PREPARE notification sequence
>>>> especially?
>>> This code was not added by me. I just added the
>>> mmc_claim_host(host)/mmc_release_host calls. Maybe Jaehoon, who added
>>> this
>>> code in the BKOPS patch can respond to your comment.
>>>>
>>>>>>>                      if (err) {
>>>>>>>                              pr_err("%s: didn't stop bkops\n",
>>>>>>>                                      mmc_hostname(host));
>>>>>>>                              return err;
>>>>>>>                      }
>>>>>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>>>>>              }
>>>>>>>
>>>>>>>              spin_lock_irqsave(&host->lock, flags);
>>>>>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>>>>>> index 7cc4638..dba76e3 100644
>>>>>>> --- a/drivers/mmc/core/mmc.c
>>>>>>> +++ b/drivers/mmc/core/mmc.c
>>>>>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host
>>>>>>> *host,
>>>>>>> u32 ocr,
>>>>>>>              }
>>>>>>>      }
>>>>>>>
>>>>>>> +    if (!oldcard) {
>>>>>>> +            if (card->ext_csd.bkops_en) {
>>>>>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>>>>>> +                                      mmc_start_idle_time_bkops);
>>>>>>> +
>>>>>>> INIT_WORK(&card->bkops_info.poll_for_completion,
>>>>>>> +                              mmc_bkops_completion_polling);
>>>>
>>>> I guess you don't have "removable" eMMC with BKOPS support so this
>>>> code will in practice only be executed once for an eMMC, so we are
>>>> safe. But still I am not fond of putting this code for workqueue here.
>>>> Either that should be done as a part of when the card is
>>>> created/deleted or when then host is created/deleted.
>>> I will check if there could be a better place for this.
>>>>
>>>>>>> +
>>>>>>> +                    /*
>>>>>>> +                     * Calculate the time to start the BKOPs
>>>>>>> checking.
>>>>>>> +                     * The idle time of the host controller should
>>>>>>> be
>>>>>>> taken
>>>>>>> +                     * into account in order to prevent a race
>>>>>>> condition
>>>>>>> +                     * before starting BKOPs and going into
>>>>>>> suspend.
>>>>>>> +                     * If the host controller didn't set its idle
>>>>>>> time,
>>>>>>> +                     * a default value is used.
>>>>>>> +                     */
>>>>>>> +                    card->bkops_info.delay_ms =
>>>>>>> MMC_IDLE_BKOPS_TIME_MS;
>>>>>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>>>>>> +                            card->bkops_info.delay_ms = min(
>>>>>>> +                                    card->bkops_info.delay_ms,
>>>>>>> +
>>>>>>> card->bkops_info.host_suspend_tout_ms/2);
>>>>>>> +            }
>>>>>>> +    }
>>>>>>> +
>>>>>>>      if (!oldcard)
>>>>>>>              host->card = card;
>>>>>>>
>>>>>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>>>>>> index 943550d..224e2a5 100644
>>>>>>> --- a/include/linux/mmc/card.h
>>>>>>> +++ b/include/linux/mmc/card.h
>>>>>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>>>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>>>>>  };
>>>>>>>
>>>>>>> +/**
>>>>>>> + * struct mmc_bkops_info - BKOPS data
>>>>>>> + * @dw:     Idle time bkops delayed work
>>>>>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>>>>>> + * before getting into suspend
>>>>>>> + * @delay_ms:       The time to start the BKOPS
>>>>>>> + *        delayed work once MMC thread is idle
>>>>>>> + * @poll_for_completion:    Poll on BKOPS completion
>>>>>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>>>>>> + *        should be cancelled
>>>>>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>>>>>> + *        work was scheduled
>>>>>>> + * @sectors_changed:  number of  sectors written or
>>>>>>> + *       discard since the last idle BKOPS were scheduled
>>>>>>> + */
>>>>>>> +struct mmc_bkops_info {
>>>>>>> +    struct delayed_work     dw;
>>>>>>> +    unsigned int            host_suspend_tout_ms;
>>>>
>>>> As stated earlier, what is this timeout you are referring to? What
>>>> suspend?
>>> Explained above.
>>>>
>>>>>>> +    unsigned int            delay_ms;
>>>>>>> +/*
>>>>>>> + * A default time for checking the need for non urgent BKOPS once
>>>>>>> mmcqd
>>>>>>> + * is idle.
>>>>>>> + */
>>>>>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>>>>>> +    struct work_struct      poll_for_completion;
>>>>>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>>>>>> completion */
>>>>>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>>>>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>>>>>> +    bool                    cancel_delayed_work;
>>>>>>> +    bool                    started_delayed_bkops;
>>>>>>> +    unsigned int            sectors_changed;
>>>>
>>>> Could not find "sectors_changed" being used. Maybe you forgot to
>>>> remove this from previous version of the patch.
>>> Yes, this should be removed.
>>>>
>>>>>>> +};
>>>>>>> +
>>>>>>>  /*
>>>>>>>   * MMC device
>>>>>>>   */
>>>>>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>>>>>      struct dentry           *debugfs_root;
>>>>>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical
>>>>>>> partitions */
>>>>>>>      unsigned int    nr_parts;
>>>>>>> +
>>>>>>> +    struct mmc_bkops_info   bkops_info;
>>>>>>>  };
>>>>>>>
>>>>>>>  /*
>>>>>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>>>>>> index 9b9cdaf..665d345 100644
>>>>>>> --- a/include/linux/mmc/core.h
>>>>>>> +++ b/include/linux/mmc/core.h
>>>>>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>>>>>> mmc_card *);
>>>>>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card
>>>>>>> *,
>>>>>>>      struct mmc_command *, int);
>>>>>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>>>>>> from_exception);
>>>>>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>>>>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>>>>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>>>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned
>>>>>>> int,
>>>>>>> bool);
>>>>>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>>>> member
>>>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>>>
>>>>> --
>>>>> To unsubscribe from this list: send the line "unsubscribe
>>>>> linux-kernel"
>>>>> in
>>>>> the body of a message to majordomo@vger.kernel.org
>>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>> Please read the FAQ at  http://www.tux.org/lkml/
>>>>
>>>> Finally some overall thoughts. What I would like to understand is how
>>>> we decide that the card has become "idle". I belive two values should
>>>> be considered, but are they?
>>>> 1. The card need BKOPS to be performed for some status level.
>>>> 2. Request inactivity for a certain timeout has occured.
>>>>
>>>> Have you considered to use runtime PM for the card device instead of
>>>> the workqueue?
>>>>
>>>> Kind regards
>>>> Ulf Hansson
>>>> --
>>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>>>> the body of a message to majordomo@vger.kernel.org
>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>
>>>
>>>
>>> --
>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>> member
>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-kernel"
>>> in
>>> the body of a message to majordomo@vger.kernel.org
>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>> Please read the FAQ at  http://www.tux.org/lkml/
>>
>> Kind regards
>> Ulf Hansson
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>
>
>
> --
> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
> of Code Aurora Forum, hosted by The Linux Foundation
>

Kind regards
Ulf Hansson
--
To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Ulf Hansson]

On 21 December 2012 09:35, Maya Erez <merez@codeaurora.org> wrote:
> Hi Ulf,
>
> Thanks for the info. We will consider our controller behavior in suspend.
> Would it be acceptable by you to keep the polling for BKOPS completion under
> a special CAPS2 flag?

Not sure what you propose here. I guess some host cap would be needed
to be able to cope with those drivers which uses runtime PM for normal
suspend.

But, the "polling method" as such shall not be done just because of
preventing those drivers entering runtime susend state.
pm_runtime_get* must be used here, I think.
Then of course you need to poll for the BKOPS status.

>
> Thanks,
> Maya
>
> -----Original Message-----
> From: linux-mmc-owner@vger.kernel.org
> [mailto:linux-mmc-owner@vger.kernel.org] On Behalf Of Ulf Hansson
> Sent: Thursday, December 13, 2012 12:18 PM
> To: merez@codeaurora.org
> Cc: Jaehoon Chung; linux-mmc@vger.kernel.org; linux-arm-msm@vger.kernel.org;
> open list
> Subject: Re: [PATCH v3] mmc: core: Add support for idle time BKOPS
>
> On 12 December 2012 13:32,  <merez@codeaurora.org> wrote:
>> Hi Ulf,
>>
>> Sorry for the late response.
>> See my reply below.
>>
>> Thanks,
>> Maya
>>
>> On Thu, December 6, 2012 2:18 am, Ulf Hansson wrote:
>>> Hi Maya,
>>>
>>> On 4 December 2012 22:17,  <merez@codeaurora.org> wrote:
>>>> Hi Ulf,
>>>>
>>>> Let me try to better explain:
>>>> The idea behind the periodic BKOPS is to check the card's need for
>>>> BKOPS periodically in order to prevent an urgent BKOPS need by the card.
>>>> In order to actually manage to prevent the urgent BKOPS need, the
>>>> host should give the card enough time to perform the BKOPS (when it
>>>> recognizes BKOPS need), otherwise there is no point in having the
>>>> periodic BKOPS.
>>>> The above results in the following:
>>>> 1. After starting non-urgent BKOPS we "delay" getting into suspend
>>>> by polling on the card's status (explanation below), in order to
>>>> give the card time to perform the BKOPS. This has no effect on the
>>>> power consumption since the same BKOPS operations that were
>>>> performed after the foregound operation just moved to another
>>>> location, meaning before going into suspend.
>>>
>>> I am not sure what you are talking about here, runtime suspend or
>>> system suspend? Polling the card's status will not prevent any of
>>> this. So you have got this wrong.
>>
>> I am referring to the runtime suspend.
>> Our controller implements the runtime suspend and is not using the
>> default implementation of core/bus.c.
>
> This is not the "default runtime suspend" for a host device, but for the
> card device. Do not mix this up with runtime pm for a host device.
>
> Right now runtime pm for the card _device_ is only enabled for SDIO.
> Thus SDIO drivers can use runtime pm to actually trigger an SDIO card to be
> fully suspended when it is not needed and thus save a lot of power. For
> example when a WLAN interface goes up/down.
>
>> This is the reason why in our implementation polling the card status
>> "delays" the runtime suspend while it is not the case when using the
>> default runtime suspend implementation.
>> I can try to explain here what our controller is doing but since it is
>> specific to us then I guess it is not relevant to the discussion.
>> Our controller is calling mmc_suspend_host in runtime suspend, which
>> issues an HPI to stop the BKOPS.
>
> So, doing mmc_suspend_host in you runtime_suspend callback, is that really
> what you want to do?
>
> 1.
> You will introduce significant latencies (I have seen SD-cards which needs
> more than 1 s to initialize, eMMC is better but we are anyway talking
> several 100 ms) once new requests arrives after the host as entered the
> runtime suspend state.
>
> 2.
> SD cards has no "power off" notification, so you will actually stress test
> the SD cards internal FTL to be crash safe by cutting the power to it more
> often.
>
> 3.
> You will prevent SD-cards from doing it's back ground operations, which is
> done automatically and not like in a controlled manner as for eMMC.
>
> So of course, you save some power, but is the consequences worth it? :-)
>
>> Now that I understand that this code is not needed for all the host
>> drivers I will add a flag to decide if polling is required when doing
>> an unblocking BKOPS.
>
> You must not poll to prevent this!
>
> Instead you need to prevent the host from going into runtime suspend state,
> which is simply done by pm_runtime_get_sync for the host device.
> Although, it _must_ not be done for drivers not doing mmc_suspend_host in
> their runtime suspend callbacks. Since then it will prevent these from doing
> runtime power save actions, which is not ok.
>
>> Other host drivers that actually suspend on runtime suspend can enable
>> this flag and allow BKOPS to be active for a longer period.
>> I will prepare a new patch and send it for review.
>>
>>>
>>>> 2. Using PM_SUSPEND_PREPARE instead of the workqueue would not be
>>>> efficient since we don't want to wait until the host is ready to get
>>>> into suspend and then prevent him from suspending by doing BKOPS
>>>> operations that can take a long time. It is better to start the
>>>> BKOPS earlier.
>>>
>>> I did not suggest to use PM_SUSPEND_PREPARE, but to use runtime PM
>>> for the card device. It can be an option to implement this feature on
>>> top of a workqueue. At least worth to consider.
>>>
>>
>> We consider to call mmc_start_bkops every time MMC becomes idle, to
>> check the need for BKOPS. I will test it and include it in the next patch.
>>
>>>>
>>>> I am not too familiar with the controllers code and also my
>>>> understanding in runtime suspend is very basic, so feel free to
>>>> correct me if I'm wrong here or the behavior in other controllers is
>>>> different from msm_sdcc.
>>>> mmc_claim_host calls host->ops->enable. This API is implemented per
>>>> controller but as far as I understand it, this API must prevent
>>>> suspend, otherwise we might go into suspend while there is bus
>>>> activity. By doing get_card_status we call mmc_claim_host and this
>>>> call is the one that "delays" getting into suspend.
>>>
>>> host->ops->enable is the old way of implementing runtime power save
>>> for host drivers. Nowadays most drivers is using runtime PM instead.
>>>
>>> When you say that mmc_claim_host will prevent suspend, I suppose you
>>> mean that host->ops->disable wont be called? That is definitely not
>>> the same as preventing a system suspend, and moreover it should not.
>>> If you think that the host must be prevented from entering runtime
>>> power save (runtime_supend or host->ops->disable), you must elaborate
>>> more on this, because I don't understand why this is needed.
>>>
>> Again, this is specific to our controller, so you can just ignore that.
>>
>>>> If this is not the case in other controllers than the BKOPS will not
>>>> prevent the suspend and BKOPS will be interrupted.
>>>> As for the effect on the battery consumption, this is probably
>>>> something specific to our controller, so sorry if I created a confusion.
>>>>
>>>> Additional comments inline.
>>>>
>>>> Thanks,
>>>> Maya
>>>>
>>>> On Tue, December 4, 2012 1:52 am, Ulf Hansson wrote:
>>>>> On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
>>>>>> Hi Jaehoon,
>>>>>>
>>>>>> With this patch we don't expect to see any degradation. Thanks for
>>>>>> verifying that.
>>>>>> The test plan would be to run the lmdd and iozone benchmarks with
>>>>>> this patch and verify that the performance is not degraded.
>>>>>> I verified it with the msm_sdcc controller.
>>>>>>
>>>>>> Chris - We do expect it to influence the battery consumption,
>>>>>> since we now delay getting into suspend (since mmc_start_bkops
>>>>>> which is called after the delayed work is executed claims the
>>>>>> host).
>>>>>> The solution for that should be done by the controller which can
>>>>>> shorten the timeout given to pm_schedule_suspend by the periodic
>>>>>> BKOPS idle time.
>>>>>> Does it make sense to you?
>>>>>>
>>>>>> Thanks,
>>>>>> Maya
>>>>>> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>>>>>>> Hi Maya,
>>>>>>>
>>>>>>> Thank you a lot for working idle time BKOPS.
>>>>>>>
>>>>>>> I tested with this patch. It's working fine.(Suspend/resume is
>>>>>>> also working well.) Test controller is sdhci controller.
>>>>>>> When i tested the performance with iozone, i didn't find that
>>>>>>> performance is decreased.
>>>>>>> Well, as Chris is mentioned, do you have any test plan?
>>>>>>> So I will test more with this patch, because i want to test with
>>>>>>> dw-mmc controller, too.
>>>>>>>
>>>>>>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>>>>>>> Devices have various maintenance operations need to perform
>>>>>>>> internally.
>>>>>>>> In order to reduce latencies during time critical operations
>>>>>>>> like read and write, it is better to execute maintenance
>>>>>>>> operations in other times - when the host is not being serviced.
>>>>>>>> Such operations are called Background operations (BKOPS).
>>>>>>>> The device notifies the status of the BKOPS need by updating
>>>>>>>> BKOPS_STATUS (EXT_CSD byte [246]).
>>>>>>>>
>>>>>>>> According to the standard a host that supports BKOPS shall check
>>>>>>>> the status periodically and start background operations as
>>>>>>>> needed, so that the device has enough time for its maintenance
>>>>>>>> operations.
>>>>>>>>
>>>>>>>> This patch adds support for this periodic check of the BKOPS status.
>>>>>>>> Since foreground operations are of higher priority than
>>>>>>>> background operations the host will check the need for BKOPS
>>>>>>>> when it is idle, and in case of an incoming request the BKOPS
>>>>>>>> operation will be interrupted.
>>>>>>>>
>>>>>>>> When the mmcqd thread is idle, a delayed work is created to
>>>>>>>> check the need for BKOPS. The time to start the delayed work is
>>>>>>>> calculated based on the host controller suspend timeout, in case
>>>>>>>> it was set. If not, a default time is used.
>>>>>
>>>>> What host controller suspend timeout are you referring to here?
>>>>>
>>>>> If you are thinking of the runtime PM autosuspend timeout used in
>>>>> many host driver, then you might have missunderstand how runtime PM
>>>>> is used in host drivers.
>>>>> This has nothing to do with BKOPS as such, unless you think that
>>>>> the card must be kept clocked during BKOPS operations, but then
>>>>> this needs to be stated somewhere in this patch and that is not the
> case.
>>>>>
>>>>> Moreover, I could not find any new timeout added for the _host_
>>>>> struct in this patch.
>>>> Yes, I was referring to the runtime PM autosuspend timeout. Since we
>>>> want to give the BKOPS time to be performed before going into
>>>> suspend, we need to take this timeout into account.
>>>
>>> Not sure why need to consider this timeout. Anyway, if so you must
>>> instead use the runtime PM API to prevent the host from being runtime
>>> suspended, like pm_runtime_get_sync.
>>>
>>>>>
>>>>>>>> If BKOPS are required in level 1, which is non-blocking, there
>>>>>>>> will be polling of the card status to wait for the BKOPS
>>>>>>>> completion and prevent suspend that will interrupt the BKOPS.
>>>>>
>>>>> Not sure of what suspend you are talking about here. But for sure
>>>>> BKOPS must _never_ prevent a system suspend.
>>>>>
>>>>> You might want to prevent a host from being runtime suspended
>>>>> though, but that is not accomplished in this patch.
>>>> This is explained in my general comment. Let me know if it is still
>>>> not clear.
>>>>>
>>>>>>>> If the card raised an exception, the need for urgent BKOPS
>>>>>>>> (level
>>>>>>>> 2/3)
>>>>>>>> will be checked immediately and if needed, the BKOPS will be
>>>>>>>> performed without waiting for the next idle time.
>>>>>>>>
>>>>>>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>>>>>>
>>>>>>>> ---
>>>>>>>> This patch is based on the periodic BKOPS implementation in
>>>>>>>> version
>>>>>>>> 8
>>>>>>>> of
>>>>>>>> "support BKOPS feature for eMMC" patch.
>>>>>>>> The patch was modified to answer the following issues:
>>>>>>>> - In order to prevent a race condition between going into
>>>>>>>> suspend and starting BKOPS,
>>>>>>>>   the suspend timeout of the host controller is taking into
>>>>>>>> accound in determination of the start time
>>>>>>>>   of the delayed work
>>>>>>>> - Since mmc_start_bkops is called from two contexts now,
>>>>>>>> mmc_claim_host was moved to the beginning of the function
>>>>>>>> - Also, the check of doing_bkops should be protected when
>>>>>>>> determing if an HPI is needed due to the same reason.
>>>>>>>>
>>>>>>>> Changes in v3:
>>>>>>>>     - Move the call to stop_bkops to block.c.
>>>>>>>>       This allows us to remove the mmc_claim_host from inside
>>>>>>>> the function and doesn't cause additional degradation
>>>>>>>>       due to un-neccessary calim host operation
>>>>>>>>
>>>>>>>> Changes in v2:
>>>>>>>>     - Check the number of written / discarded sectors as the
>>>>>>>> trigger for checking the BKOPS need.
>>>>>>>>     - Code review fixes
>>>>>>>>
>>>>>>>> ---
>>>>>>>>  drivers/mmc/card/block.c |    8 ++-
>>>>>>>>  drivers/mmc/card/queue.c |    2 +
>>>>>>>>  drivers/mmc/core/core.c  |  178
>>>>>>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>>>>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>>>>>>  include/linux/mmc/card.h |   35 +++++++++
>>>>>>>>  include/linux/mmc/core.h |    3 +
>>>>>>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>>>>>>
>>>>>>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>>>>>>> index 172a768..40b4ae3 100644
>>>>>>>> --- a/drivers/mmc/card/block.c
>>>>>>>> +++ b/drivers/mmc/card/block.c
>>>>>>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct
>>>>>>>> mmc_queue *mq, struct request *req)
>>>>>>>>      struct mmc_blk_data *md = mq->data;
>>>>>>>>      struct mmc_card *card = md->queue.card;
>>>>>>>>
>>>>>>>> -    if (req && !mq->mqrq_prev->req)
>>>>>>>> +    if (req && !mq->mqrq_prev->req) {
>>>>>>>>              /* claim host only for the first request */
>>>>>>>>              mmc_claim_host(card->host);
>>>>>>>> +            if (card->ext_csd.bkops_en &&
>>>>>>>> +                card->bkops_info.started_delayed_bkops) {
>>>>>>>> +
>>>>>>>> + card->bkops_info.started_delayed_bkops
>>>>>>>> =
>>>>>>>> false;
>>>>>>>> +                            mmc_stop_bkops(card);
>>>>>>> We didn't need to check whether mmc_stop_bkops is success or not?
>>>>>>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>>>>>>
>>>>>>> Best Regards,
>>>>>>> Jaehoon Chung
>>>>>>>
>>>>>>>> +            }
>>>>>>>> +    }
>>>>>>>>
>>>>>>>>      ret = mmc_blk_part_switch(card, md);
>>>>>>>>      if (ret) {
>>>>>>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>>>>>>> index fadf52e..9d0c96a 100644
>>>>>>>> --- a/drivers/mmc/card/queue.c
>>>>>>>> +++ b/drivers/mmc/card/queue.c
>>>>>>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)  {
>>>>>>>>      struct mmc_queue *mq = d;
>>>>>>>>      struct request_queue *q = mq->queue;
>>>>>>>> +    struct mmc_card *card = mq->card;
>>>>>>>>
>>>>>>>>      current->flags |= PF_MEMALLOC;
>>>>>>>>
>>>>>>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>>>>>>                              set_current_state(TASK_RUNNING);
>>>>>>>>                              break;
>>>>>>>>                      }
>>>>>>>> +                    mmc_start_delayed_bkops(card);
>>>>>>>>                      up(&mq->thread_sem);
>>>>>>>>                      schedule();
>>>>>>>>                      down(&mq->thread_sem);
>>>>>>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>>>>>>> index 06c42cf..72ae15b 100644
>>>>>>>> --- a/drivers/mmc/core/core.c
>>>>>>>> +++ b/drivers/mmc/core/core.c
>>>>>>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>>>>>>> mmc_request *mrq)
>>>>>>>>  }
>>>>>>>>
>>>>>>>>  /**
>>>>>>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>>>>>>> + *      the need of non urgent BKOPS
>>>>>>>> + *
>>>>>>>> + * @card: MMC card to start BKOPS on
>>>>>>>> + */
>>>>>>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>>>>>>> +{
>>>>>>>> +    if (!card || !card->ext_csd.bkops_en ||
>>>>>>>> mmc_card_doing_bkops(card))
>>>>>>>> +            return;
>>>>>>>> +
>>>>>>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>>>>>>> +             mmc_hostname(card->host), __func__);
>>>>>>>> +
>>>>>>>> +    /*
>>>>>>>> +     * cancel_delayed_bkops_work will prevent a race condition
>>>>>>>> between
>>>>>>>> +     * fetching a request by the mmcqd and the delayed work, in
>>>>>>>> case
>>>>>>>> +     * it was removed from the queue work but not started yet
>>>>>>>> +     */
>>>>>>>> +    card->bkops_info.cancel_delayed_work = false;
>>>>>>>> +    card->bkops_info.started_delayed_bkops = true;
>>>>>>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>>>>>>> +                       msecs_to_jiffies(
>>>>>>>> +                               card->bkops_info.delay_ms));
>>>>>>>> +}
>>>>>>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>>>>>>> +
>>>>>>>> +/**
>>>>>>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>>>>>>   *  @card: MMC card to start BKOPS
>>>>>>>> - *  @form_exception: A flag to indicate if this function was
>>>>>>>> + *  @from_exception: A flag to indicate if this function was
>>>>>>>>   *                   called due to an exception raised by the card
>>>>>>>>   *
>>>>>>>>   *  Start background operations whenever requested.
>>>>>>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>>> bool
>>>>>>>> from_exception)
>>>>>>>>      bool use_busy_signal;
>>>>>>>>
>>>>>>>>      BUG_ON(!card);
>>>>>>>> -
>>>>>>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>>>>>>> +    if (!card->ext_csd.bkops_en)
>>>>>>>>              return;
>>>>>>>>
>>>>>>>> +    mmc_claim_host(card->host);
>>>>>>>> +
>>>>>>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception)
>>>>>>>> {
>>>>>>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>>> +            card->bkops_info.cancel_delayed_work = false;
>>>>>>>> +            goto out;
>>>>>>>> +    }
>>>>>>>> +
>>>>>>>> +    if (mmc_card_doing_bkops(card)) {
>>>>>>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>>> +            goto out;
>>>>>>>> +    }
>>>>>>>> +
>>>>>>>>      err = mmc_read_bkops_status(card);
>>>>>>>>      if (err) {
>>>>>>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>>>>>>                     mmc_hostname(card->host), err);
>>>>>>>> -            return;
>>>>>>>> +            goto out;
>>>>>>>>      }
>>>>>>>>
>>>>>>>>      if (!card->ext_csd.raw_bkops_status)
>>>>>>>> -            return;
>>>>>>>> +            goto out;
>>>>>>>>
>>>>>>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>>>>>>> +            mmc_hostname(card->host), __func__,
>>>>>>>> +            card->ext_csd.raw_bkops_status);
>>>>>>>> +
>>>>>>>> +    /*
>>>>>>>> +     * If the function was called due to exception but there is no
>>>>>>>> need
>>>>>>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed
>>>>>>>> BKOPs
>>>>>>>> +     * work, before going to suspend
>>>>>>>> +     */
>>>>>>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>>>>>>          from_exception)
>>>>>>>> -            return;
>>>>>>>> +            goto out;
>>>>>>>>
>>>>>>>> -    mmc_claim_host(card->host);
>>>>>>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>>>>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>>>>>>              use_busy_signal = true;
>>>>>>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>>> bool
>>>>>>>> from_exception)
>>>>>>>>       * bkops executed synchronously, otherwise
>>>>>>>>       * the operation is in progress
>>>>>>>>       */
>>>>>>>> -    if (!use_busy_signal)
>>>>>>>> +    if (!use_busy_signal) {
>>>>>>>>              mmc_card_set_doing_bkops(card);
>>>>>>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>>> +            queue_work(system_nrt_wq,
>>>>>>>> +                       &card->bkops_info.poll_for_completion);
>>>>>>>> +    }
>>>>>>>> +
>>>>>>>>  out:
>>>>>>>>      mmc_release_host(card->host);
>>>>>>>>  }
>>>>>>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>>>>>>
>>>>>>>> +/**
>>>>>>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>>>>>>> + * wait for the non-blocking BKOPS completion
>>>>>>>> + * @work:   The completion polling work
>>>>>>>> + *
>>>>>>>> + * The on-going reading of the card status will prevent the card
>>>>>>>> + * from getting into suspend while it is in the middle of
>>>>>>>> + * performing BKOPS.
>>>>>
>>>>> Not true! Suspend will not be prevented by doing a mmc_send_status.
>>>>> Moreover, I would be interested to understand more about why you need
>>>>> to prevent "suspend". Please elaborate why you think this is needed.
>>>> This is explained in my general comment. Let me know if it is still not
>>>> clear.
>>>>>
>>>>>>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>>>>>>> + * request we also check IF mmc_card_doing_bkops in each
>>>>>>>> + * iteration.
>>>>>>>> + */
>>>>>>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>>>>>>> +{
>>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>>> +                    bkops_info.poll_for_completion);
>>>>>>>> +    unsigned long timeout_jiffies = jiffies +
>>>>>>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>>>>>>> +    u32 status;
>>>>>>>> +    int err;
>>>>>>>> +
>>>>>>>> +    /*
>>>>>>>> +     * Wait for the BKOPs to complete. Keep reading the status to
>>>>>>>> prevent
>>>>>>>> +     * the host from getting into suspend
>>>>>>>> +     */
>>>>>>>> +    do {
>>>>>>>> +            mmc_claim_host(card->host);
>>>>>>>> +
>>>>>>>> +            if (!mmc_card_doing_bkops(card))
>>>>>>>> +                    goto out;
>>>>>>>> +
>>>>>>>> +            err = mmc_send_status(card, &status);
>>>>>>>> +            if (err) {
>>>>>>>> +                    pr_err("%s: error %d requesting status\n",
>>>>>>>> +                           mmc_hostname(card->host), err);
>>>>>>>> +                    goto out;
>>>>>>>> +            }
>>>>>>>> +
>>>>>>>> +            /*
>>>>>>>> +             * Some cards mishandle the status bits, so make sure
>>>>>>>> to
>>>>>>>> check
>>>>>>>> +             * both the busy indication and the card state.
>>>>>>>> +             */
>>>>>>>> +            if ((status & R1_READY_FOR_DATA) &&
>>>>>>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>>>>>>> +                    pr_debug("%s: %s: completed BKOPs, exit
>>>>>>>> polling\n",
>>>>>>>> +                             mmc_hostname(card->host), __func__);
>>>>>>>> +                    mmc_card_clr_doing_bkops(card);
>>>>>>>> +                    card->bkops_info.started_delayed_bkops = false;
>>>>>>>> +                    goto out;
>>>>>>>> +            }
>>>>>>>> +
>>>>>>>> +            mmc_release_host(card->host);
>>>>>>>> +
>>>>>>>> +            /*
>>>>>>>> +             * Sleep before checking the card status again to allow
>>>>>>>> the
>>>>>>>> +             * card to complete the BKOPs operation
>>>>>>>> +             */
>>>>>>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>>>>>>> +    } while (time_before(jiffies, timeout_jiffies));
>>>>>>>> +
>>>>>>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>>>>>>> +           mmc_hostname(card->host), __func__);
>>>>>>>> +
>>>>>>>> +    return;
>>>>>>>> +out:
>>>>>>>> +    mmc_release_host(card->host);
>>>>>>>> +}
>>>>>>>> +
>>>>>>>> +/**
>>>>>>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>>>>>>> + * needed
>>>>>>>> + * @work:   The idle time BKOPS work
>>>>>>>> + */
>>>>>>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>>>>>>> +{
>>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>>> +                    bkops_info.dw.work);
>>>>>>>> +
>>>>>>>> +    /*
>>>>>>>> +     * Prevent a race condition between mmc_stop_bkops and the
>>>>>>>> delayed
>>>>>>>> +     * BKOPS work in case the delayed work is executed on another
>>>>>>>> CPU
>>>>>>>> +     */
>>>>>>>> +    if (card->bkops_info.cancel_delayed_work)
>>>>>>>> +            return;
>>>>>>>> +
>>>>>>>> +    mmc_start_bkops(card, false);
>>>>>>>> +}
>>>>>>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>>>>>>> +
>>>>>>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>>>>>>  {
>>>>>>>>      complete(&mrq->completion);
>>>>>>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>>      int err = 0;
>>>>>>>>
>>>>>>>>      BUG_ON(!card);
>>>>>>>> +
>>>>>>>> +    /*
>>>>>>>> +     * Notify the delayed work to be cancelled, in case it was
>>>>>>>> already
>>>>>>>> +     * removed from the queue, but was not started yet
>>>>>>>> +     */
>>>>>>>> +    card->bkops_info.cancel_delayed_work = true;
>>>>>>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>>>>>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>>>>>>> +    if (!mmc_card_doing_bkops(card))
>>>>>>>> +            goto out;
>>>>>>>> +
>>>>>>>>      err = mmc_interrupt_hpi(card);
>>>>>>>>
>>>>>>>>      /*
>>>>>>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>>              err = 0;
>>>>>>>>      }
>>>>>>>>
>>>>>>>> +out:
>>>>>>>>      return err;
>>>>>>>>  }
>>>>>>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>>>>>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>>>>>>> *notify_block,
>>>>>>>>      switch (mode) {
>>>>>>>>      case PM_HIBERNATION_PREPARE:
>>>>>>>>      case PM_SUSPEND_PREPARE:
>>>>>>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>>>>>>> -                mmc_card_doing_bkops(host->card)) {
>>>>>>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>>>>>>> +                    mmc_claim_host(host);
>>>>>>>>                      err = mmc_stop_bkops(host->card);
>>>>>>>> +                    mmc_release_host(host);
>>>>>
>>>>> This code seems a bit strange. You will check for mmc_card_mmc, but
>>>>> not all (e)MMC will support bkops. How about acually just checking if
>>>>> bkops is "on" or "off" somehow.
>>>>>
>>>>> Additionally, so this piece of code shall stop an ongoing bkops before
>>>>> going to suspend, so that make sense. But would it not be more
>>>>> meaningfull to take care of that in mmc_suspend_host? I mean why do yo
>>>>> need to do it in the PM_SUSPEND_PREPARE notification sequence
>>>>> especially?
>>>> This code was not added by me. I just added the
>>>> mmc_claim_host(host)/mmc_release_host calls. Maybe Jaehoon, who added
>>>> this
>>>> code in the BKOPS patch can respond to your comment.
>>>>>
>>>>>>>>                      if (err) {
>>>>>>>>                              pr_err("%s: didn't stop bkops\n",
>>>>>>>>                                      mmc_hostname(host));
>>>>>>>>                              return err;
>>>>>>>>                      }
>>>>>>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>>>>>>              }
>>>>>>>>
>>>>>>>>              spin_lock_irqsave(&host->lock, flags);
>>>>>>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>>>>>>> index 7cc4638..dba76e3 100644
>>>>>>>> --- a/drivers/mmc/core/mmc.c
>>>>>>>> +++ b/drivers/mmc/core/mmc.c
>>>>>>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host
>>>>>>>> *host,
>>>>>>>> u32 ocr,
>>>>>>>>              }
>>>>>>>>      }
>>>>>>>>
>>>>>>>> +    if (!oldcard) {
>>>>>>>> +            if (card->ext_csd.bkops_en) {
>>>>>>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>>>>>>> +                                      mmc_start_idle_time_bkops);
>>>>>>>> +
>>>>>>>> INIT_WORK(&card->bkops_info.poll_for_completion,
>>>>>>>> +                              mmc_bkops_completion_polling);
>>>>>
>>>>> I guess you don't have "removable" eMMC with BKOPS support so this
>>>>> code will in practice only be executed once for an eMMC, so we are
>>>>> safe. But still I am not fond of putting this code for workqueue here.
>>>>> Either that should be done as a part of when the card is
>>>>> created/deleted or when then host is created/deleted.
>>>> I will check if there could be a better place for this.
>>>>>
>>>>>>>> +
>>>>>>>> +                    /*
>>>>>>>> +                     * Calculate the time to start the BKOPs
>>>>>>>> checking.
>>>>>>>> +                     * The idle time of the host controller should
>>>>>>>> be
>>>>>>>> taken
>>>>>>>> +                     * into account in order to prevent a race
>>>>>>>> condition
>>>>>>>> +                     * before starting BKOPs and going into
>>>>>>>> suspend.
>>>>>>>> +                     * If the host controller didn't set its idle
>>>>>>>> time,
>>>>>>>> +                     * a default value is used.
>>>>>>>> +                     */
>>>>>>>> +                    card->bkops_info.delay_ms =
>>>>>>>> MMC_IDLE_BKOPS_TIME_MS;
>>>>>>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>>>>>>> +                            card->bkops_info.delay_ms = min(
>>>>>>>> +                                    card->bkops_info.delay_ms,
>>>>>>>> +
>>>>>>>> card->bkops_info.host_suspend_tout_ms/2);
>>>>>>>> +            }
>>>>>>>> +    }
>>>>>>>> +
>>>>>>>>      if (!oldcard)
>>>>>>>>              host->card = card;
>>>>>>>>
>>>>>>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>>>>>>> index 943550d..224e2a5 100644
>>>>>>>> --- a/include/linux/mmc/card.h
>>>>>>>> +++ b/include/linux/mmc/card.h
>>>>>>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>>>>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>>>>>>  };
>>>>>>>>
>>>>>>>> +/**
>>>>>>>> + * struct mmc_bkops_info - BKOPS data
>>>>>>>> + * @dw:     Idle time bkops delayed work
>>>>>>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>>>>>>> + * before getting into suspend
>>>>>>>> + * @delay_ms:       The time to start the BKOPS
>>>>>>>> + *        delayed work once MMC thread is idle
>>>>>>>> + * @poll_for_completion:    Poll on BKOPS completion
>>>>>>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>>>>>>> + *        should be cancelled
>>>>>>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>>>>>>> + *        work was scheduled
>>>>>>>> + * @sectors_changed:  number of  sectors written or
>>>>>>>> + *       discard since the last idle BKOPS were scheduled
>>>>>>>> + */
>>>>>>>> +struct mmc_bkops_info {
>>>>>>>> +    struct delayed_work     dw;
>>>>>>>> +    unsigned int            host_suspend_tout_ms;
>>>>>
>>>>> As stated earlier, what is this timeout you are referring to? What
>>>>> suspend?
>>>> Explained above.
>>>>>
>>>>>>>> +    unsigned int            delay_ms;
>>>>>>>> +/*
>>>>>>>> + * A default time for checking the need for non urgent BKOPS once
>>>>>>>> mmcqd
>>>>>>>> + * is idle.
>>>>>>>> + */
>>>>>>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>>>>>>> +    struct work_struct      poll_for_completion;
>>>>>>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>>>>>>> completion */
>>>>>>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>>>>>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>>>>>>> +    bool                    cancel_delayed_work;
>>>>>>>> +    bool                    started_delayed_bkops;
>>>>>>>> +    unsigned int            sectors_changed;
>>>>>
>>>>> Could not find "sectors_changed" being used. Maybe you forgot to
>>>>> remove this from previous version of the patch.
>>>> Yes, this should be removed.
>>>>>
>>>>>>>> +};
>>>>>>>> +
>>>>>>>>  /*
>>>>>>>>   * MMC device
>>>>>>>>   */
>>>>>>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>>>>>>      struct dentry           *debugfs_root;
>>>>>>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical
>>>>>>>> partitions */
>>>>>>>>      unsigned int    nr_parts;
>>>>>>>> +
>>>>>>>> +    struct mmc_bkops_info   bkops_info;
>>>>>>>>  };
>>>>>>>>
>>>>>>>>  /*
>>>>>>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>>>>>>> index 9b9cdaf..665d345 100644
>>>>>>>> --- a/include/linux/mmc/core.h
>>>>>>>> +++ b/include/linux/mmc/core.h
>>>>>>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>>>>>>> mmc_card *);
>>>>>>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card
>>>>>>>> *,
>>>>>>>>      struct mmc_command *, int);
>>>>>>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>>>>>>> from_exception);
>>>>>>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>>>>>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>>>>>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>>>>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned
>>>>>>>> int,
>>>>>>>> bool);
>>>>>>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> --
>>>>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>>>>> member
>>>>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>>>>
>>>>>> --
>>>>>> To unsubscribe from this list: send the line "unsubscribe
>>>>>> linux-kernel"
>>>>>> in
>>>>>> the body of a message to majordomo@vger.kernel.org
>>>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>>> Please read the FAQ at  http://www.tux.org/lkml/
>>>>>
>>>>> Finally some overall thoughts. What I would like to understand is how
>>>>> we decide that the card has become "idle". I belive two values should
>>>>> be considered, but are they?
>>>>> 1. The card need BKOPS to be performed for some status level.
>>>>> 2. Request inactivity for a certain timeout has occured.
>>>>>
>>>>> Have you considered to use runtime PM for the card device instead of
>>>>> the workqueue?
>>>>>
>>>>> Kind regards
>>>>> Ulf Hansson
>>>>> --
>>>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>>>>> the body of a message to majordomo@vger.kernel.org
>>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>>
>>>>
>>>>
>>>> --
>>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>>> member
>>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>>
>>>> --
>>>> To unsubscribe from this list: send the line "unsubscribe linux-kernel"
>>>> in
>>>> the body of a message to majordomo@vger.kernel.org
>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>> Please read the FAQ at  http://www.tux.org/lkml/
>>>
>>> Kind regards
>>> Ulf Hansson
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>>> the body of a message to majordomo@vger.kernel.org
>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>
>>
>>
>> --
>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
>> of Code Aurora Forum, hosted by The Linux Foundation
>>
>
> Kind regards
> Ulf Hansson
> --
> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>

Kind regards
Ulf Hansson

Re: [PATCH v3] mmc: core: Add support for idle time BKOPS

[Jaehoon Chung]

Hi All,

Sorry for reply..I didn't fully read about this patch history.
So i will resend the my opinion after reading the mail-history

Best Regards,
Jaehoon Chung

On 12/21/2012 06:56 PM, Ulf Hansson wrote:
> On 21 December 2012 09:35, Maya Erez <merez@codeaurora.org> wrote:
>> Hi Ulf,
>>
>> Thanks for the info. We will consider our controller behavior in suspend.
>> Would it be acceptable by you to keep the polling for BKOPS completion under
>> a special CAPS2 flag?
> 
> Not sure what you propose here. I guess some host cap would be needed
> to be able to cope with those drivers which uses runtime PM for normal
> suspend.
> 
> But, the "polling method" as such shall not be done just because of
> preventing those drivers entering runtime susend state.
> pm_runtime_get* must be used here, I think.
> Then of course you need to poll for the BKOPS status.
> 
>>
>> Thanks,
>> Maya
>>
>> -----Original Message-----
>> From: linux-mmc-owner@vger.kernel.org
>> [mailto:linux-mmc-owner@vger.kernel.org] On Behalf Of Ulf Hansson
>> Sent: Thursday, December 13, 2012 12:18 PM
>> To: merez@codeaurora.org
>> Cc: Jaehoon Chung; linux-mmc@vger.kernel.org; linux-arm-msm@vger.kernel.org;
>> open list
>> Subject: Re: [PATCH v3] mmc: core: Add support for idle time BKOPS
>>
>> On 12 December 2012 13:32,  <merez@codeaurora.org> wrote:
>>> Hi Ulf,
>>>
>>> Sorry for the late response.
>>> See my reply below.
>>>
>>> Thanks,
>>> Maya
>>>
>>> On Thu, December 6, 2012 2:18 am, Ulf Hansson wrote:
>>>> Hi Maya,
>>>>
>>>> On 4 December 2012 22:17,  <merez@codeaurora.org> wrote:
>>>>> Hi Ulf,
>>>>>
>>>>> Let me try to better explain:
>>>>> The idea behind the periodic BKOPS is to check the card's need for
>>>>> BKOPS periodically in order to prevent an urgent BKOPS need by the card.
>>>>> In order to actually manage to prevent the urgent BKOPS need, the
>>>>> host should give the card enough time to perform the BKOPS (when it
>>>>> recognizes BKOPS need), otherwise there is no point in having the
>>>>> periodic BKOPS.
>>>>> The above results in the following:
>>>>> 1. After starting non-urgent BKOPS we "delay" getting into suspend
>>>>> by polling on the card's status (explanation below), in order to
>>>>> give the card time to perform the BKOPS. This has no effect on the
>>>>> power consumption since the same BKOPS operations that were
>>>>> performed after the foregound operation just moved to another
>>>>> location, meaning before going into suspend.
>>>>
>>>> I am not sure what you are talking about here, runtime suspend or
>>>> system suspend? Polling the card's status will not prevent any of
>>>> this. So you have got this wrong.
>>>
>>> I am referring to the runtime suspend.
>>> Our controller implements the runtime suspend and is not using the
>>> default implementation of core/bus.c.
>>
>> This is not the "default runtime suspend" for a host device, but for the
>> card device. Do not mix this up with runtime pm for a host device.
>>
>> Right now runtime pm for the card _device_ is only enabled for SDIO.
>> Thus SDIO drivers can use runtime pm to actually trigger an SDIO card to be
>> fully suspended when it is not needed and thus save a lot of power. For
>> example when a WLAN interface goes up/down.
>>
>>> This is the reason why in our implementation polling the card status
>>> "delays" the runtime suspend while it is not the case when using the
>>> default runtime suspend implementation.
>>> I can try to explain here what our controller is doing but since it is
>>> specific to us then I guess it is not relevant to the discussion.
>>> Our controller is calling mmc_suspend_host in runtime suspend, which
>>> issues an HPI to stop the BKOPS.
>>
>> So, doing mmc_suspend_host in you runtime_suspend callback, is that really
>> what you want to do?
>>
>> 1.
>> You will introduce significant latencies (I have seen SD-cards which needs
>> more than 1 s to initialize, eMMC is better but we are anyway talking
>> several 100 ms) once new requests arrives after the host as entered the
>> runtime suspend state.
>>
>> 2.
>> SD cards has no "power off" notification, so you will actually stress test
>> the SD cards internal FTL to be crash safe by cutting the power to it more
>> often.
>>
>> 3.
>> You will prevent SD-cards from doing it's back ground operations, which is
>> done automatically and not like in a controlled manner as for eMMC.
>>
>> So of course, you save some power, but is the consequences worth it? :-)
>>
>>> Now that I understand that this code is not needed for all the host
>>> drivers I will add a flag to decide if polling is required when doing
>>> an unblocking BKOPS.
>>
>> You must not poll to prevent this!
>>
>> Instead you need to prevent the host from going into runtime suspend state,
>> which is simply done by pm_runtime_get_sync for the host device.
>> Although, it _must_ not be done for drivers not doing mmc_suspend_host in
>> their runtime suspend callbacks. Since then it will prevent these from doing
>> runtime power save actions, which is not ok.
>>
>>> Other host drivers that actually suspend on runtime suspend can enable
>>> this flag and allow BKOPS to be active for a longer period.
>>> I will prepare a new patch and send it for review.
>>>
>>>>
>>>>> 2. Using PM_SUSPEND_PREPARE instead of the workqueue would not be
>>>>> efficient since we don't want to wait until the host is ready to get
>>>>> into suspend and then prevent him from suspending by doing BKOPS
>>>>> operations that can take a long time. It is better to start the
>>>>> BKOPS earlier.
>>>>
>>>> I did not suggest to use PM_SUSPEND_PREPARE, but to use runtime PM
>>>> for the card device. It can be an option to implement this feature on
>>>> top of a workqueue. At least worth to consider.
>>>>
>>>
>>> We consider to call mmc_start_bkops every time MMC becomes idle, to
>>> check the need for BKOPS. I will test it and include it in the next patch.
>>>
>>>>>
>>>>> I am not too familiar with the controllers code and also my
>>>>> understanding in runtime suspend is very basic, so feel free to
>>>>> correct me if I'm wrong here or the behavior in other controllers is
>>>>> different from msm_sdcc.
>>>>> mmc_claim_host calls host->ops->enable. This API is implemented per
>>>>> controller but as far as I understand it, this API must prevent
>>>>> suspend, otherwise we might go into suspend while there is bus
>>>>> activity. By doing get_card_status we call mmc_claim_host and this
>>>>> call is the one that "delays" getting into suspend.
>>>>
>>>> host->ops->enable is the old way of implementing runtime power save
>>>> for host drivers. Nowadays most drivers is using runtime PM instead.
>>>>
>>>> When you say that mmc_claim_host will prevent suspend, I suppose you
>>>> mean that host->ops->disable wont be called? That is definitely not
>>>> the same as preventing a system suspend, and moreover it should not.
>>>> If you think that the host must be prevented from entering runtime
>>>> power save (runtime_supend or host->ops->disable), you must elaborate
>>>> more on this, because I don't understand why this is needed.
>>>>
>>> Again, this is specific to our controller, so you can just ignore that.
>>>
>>>>> If this is not the case in other controllers than the BKOPS will not
>>>>> prevent the suspend and BKOPS will be interrupted.
>>>>> As for the effect on the battery consumption, this is probably
>>>>> something specific to our controller, so sorry if I created a confusion.
>>>>>
>>>>> Additional comments inline.
>>>>>
>>>>> Thanks,
>>>>> Maya
>>>>>
>>>>> On Tue, December 4, 2012 1:52 am, Ulf Hansson wrote:
>>>>>> On 3 December 2012 10:49,  <merez@codeaurora.org> wrote:
>>>>>>> Hi Jaehoon,
>>>>>>>
>>>>>>> With this patch we don't expect to see any degradation. Thanks for
>>>>>>> verifying that.
>>>>>>> The test plan would be to run the lmdd and iozone benchmarks with
>>>>>>> this patch and verify that the performance is not degraded.
>>>>>>> I verified it with the msm_sdcc controller.
>>>>>>>
>>>>>>> Chris - We do expect it to influence the battery consumption,
>>>>>>> since we now delay getting into suspend (since mmc_start_bkops
>>>>>>> which is called after the delayed work is executed claims the
>>>>>>> host).
>>>>>>> The solution for that should be done by the controller which can
>>>>>>> shorten the timeout given to pm_schedule_suspend by the periodic
>>>>>>> BKOPS idle time.
>>>>>>> Does it make sense to you?
>>>>>>>
>>>>>>> Thanks,
>>>>>>> Maya
>>>>>>> On Thu, November 29, 2012 4:40 am, Jaehoon Chung wrote:
>>>>>>>> Hi Maya,
>>>>>>>>
>>>>>>>> Thank you a lot for working idle time BKOPS.
>>>>>>>>
>>>>>>>> I tested with this patch. It's working fine.(Suspend/resume is
>>>>>>>> also working well.) Test controller is sdhci controller.
>>>>>>>> When i tested the performance with iozone, i didn't find that
>>>>>>>> performance is decreased.
>>>>>>>> Well, as Chris is mentioned, do you have any test plan?
>>>>>>>> So I will test more with this patch, because i want to test with
>>>>>>>> dw-mmc controller, too.
>>>>>>>>
>>>>>>>> On 11/25/2012 08:56 PM, Maya Erez wrote:
>>>>>>>>> Devices have various maintenance operations need to perform
>>>>>>>>> internally.
>>>>>>>>> In order to reduce latencies during time critical operations
>>>>>>>>> like read and write, it is better to execute maintenance
>>>>>>>>> operations in other times - when the host is not being serviced.
>>>>>>>>> Such operations are called Background operations (BKOPS).
>>>>>>>>> The device notifies the status of the BKOPS need by updating
>>>>>>>>> BKOPS_STATUS (EXT_CSD byte [246]).
>>>>>>>>>
>>>>>>>>> According to the standard a host that supports BKOPS shall check
>>>>>>>>> the status periodically and start background operations as
>>>>>>>>> needed, so that the device has enough time for its maintenance
>>>>>>>>> operations.
>>>>>>>>>
>>>>>>>>> This patch adds support for this periodic check of the BKOPS status.
>>>>>>>>> Since foreground operations are of higher priority than
>>>>>>>>> background operations the host will check the need for BKOPS
>>>>>>>>> when it is idle, and in case of an incoming request the BKOPS
>>>>>>>>> operation will be interrupted.
>>>>>>>>>
>>>>>>>>> When the mmcqd thread is idle, a delayed work is created to
>>>>>>>>> check the need for BKOPS. The time to start the delayed work is
>>>>>>>>> calculated based on the host controller suspend timeout, in case
>>>>>>>>> it was set. If not, a default time is used.
>>>>>>
>>>>>> What host controller suspend timeout are you referring to here?
>>>>>>
>>>>>> If you are thinking of the runtime PM autosuspend timeout used in
>>>>>> many host driver, then you might have missunderstand how runtime PM
>>>>>> is used in host drivers.
>>>>>> This has nothing to do with BKOPS as such, unless you think that
>>>>>> the card must be kept clocked during BKOPS operations, but then
>>>>>> this needs to be stated somewhere in this patch and that is not the
>> case.
>>>>>>
>>>>>> Moreover, I could not find any new timeout added for the _host_
>>>>>> struct in this patch.
>>>>> Yes, I was referring to the runtime PM autosuspend timeout. Since we
>>>>> want to give the BKOPS time to be performed before going into
>>>>> suspend, we need to take this timeout into account.
>>>>
>>>> Not sure why need to consider this timeout. Anyway, if so you must
>>>> instead use the runtime PM API to prevent the host from being runtime
>>>> suspended, like pm_runtime_get_sync.
>>>>
>>>>>>
>>>>>>>>> If BKOPS are required in level 1, which is non-blocking, there
>>>>>>>>> will be polling of the card status to wait for the BKOPS
>>>>>>>>> completion and prevent suspend that will interrupt the BKOPS.
>>>>>>
>>>>>> Not sure of what suspend you are talking about here. But for sure
>>>>>> BKOPS must _never_ prevent a system suspend.
>>>>>>
>>>>>> You might want to prevent a host from being runtime suspended
>>>>>> though, but that is not accomplished in this patch.
>>>>> This is explained in my general comment. Let me know if it is still
>>>>> not clear.
>>>>>>
>>>>>>>>> If the card raised an exception, the need for urgent BKOPS
>>>>>>>>> (level
>>>>>>>>> 2/3)
>>>>>>>>> will be checked immediately and if needed, the BKOPS will be
>>>>>>>>> performed without waiting for the next idle time.
>>>>>>>>>
>>>>>>>>> Signed-off-by: Maya Erez <merez@codeaurora.org>
>>>>>>>>>
>>>>>>>>> ---
>>>>>>>>> This patch is based on the periodic BKOPS implementation in
>>>>>>>>> version
>>>>>>>>> 8
>>>>>>>>> of
>>>>>>>>> "support BKOPS feature for eMMC" patch.
>>>>>>>>> The patch was modified to answer the following issues:
>>>>>>>>> - In order to prevent a race condition between going into
>>>>>>>>> suspend and starting BKOPS,
>>>>>>>>>   the suspend timeout of the host controller is taking into
>>>>>>>>> accound in determination of the start time
>>>>>>>>>   of the delayed work
>>>>>>>>> - Since mmc_start_bkops is called from two contexts now,
>>>>>>>>> mmc_claim_host was moved to the beginning of the function
>>>>>>>>> - Also, the check of doing_bkops should be protected when
>>>>>>>>> determing if an HPI is needed due to the same reason.
>>>>>>>>>
>>>>>>>>> Changes in v3:
>>>>>>>>>     - Move the call to stop_bkops to block.c.
>>>>>>>>>       This allows us to remove the mmc_claim_host from inside
>>>>>>>>> the function and doesn't cause additional degradation
>>>>>>>>>       due to un-neccessary calim host operation
>>>>>>>>>
>>>>>>>>> Changes in v2:
>>>>>>>>>     - Check the number of written / discarded sectors as the
>>>>>>>>> trigger for checking the BKOPS need.
>>>>>>>>>     - Code review fixes
>>>>>>>>>
>>>>>>>>> ---
>>>>>>>>>  drivers/mmc/card/block.c |    8 ++-
>>>>>>>>>  drivers/mmc/card/queue.c |    2 +
>>>>>>>>>  drivers/mmc/core/core.c  |  178
>>>>>>>>> +++++++++++++++++++++++++++++++++++++++++++---
>>>>>>>>>  drivers/mmc/core/mmc.c   |   23 ++++++
>>>>>>>>>  include/linux/mmc/card.h |   35 +++++++++
>>>>>>>>>  include/linux/mmc/core.h |    3 +
>>>>>>>>>  6 files changed, 237 insertions(+), 12 deletions(-)
>>>>>>>>>
>>>>>>>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
>>>>>>>>> index 172a768..40b4ae3 100644
>>>>>>>>> --- a/drivers/mmc/card/block.c
>>>>>>>>> +++ b/drivers/mmc/card/block.c
>>>>>>>>> @@ -1394,9 +1394,15 @@ static int mmc_blk_issue_rq(struct
>>>>>>>>> mmc_queue *mq, struct request *req)
>>>>>>>>>      struct mmc_blk_data *md = mq->data;
>>>>>>>>>      struct mmc_card *card = md->queue.card;
>>>>>>>>>
>>>>>>>>> -    if (req && !mq->mqrq_prev->req)
>>>>>>>>> +    if (req && !mq->mqrq_prev->req) {
>>>>>>>>>              /* claim host only for the first request */
>>>>>>>>>              mmc_claim_host(card->host);
>>>>>>>>> +            if (card->ext_csd.bkops_en &&
>>>>>>>>> +                card->bkops_info.started_delayed_bkops) {
>>>>>>>>> +
>>>>>>>>> + card->bkops_info.started_delayed_bkops
>>>>>>>>> =
>>>>>>>>> false;
>>>>>>>>> +                            mmc_stop_bkops(card);
>>>>>>>> We didn't need to check whether mmc_stop_bkops is success or not?
>>>>>>>> If mmc_stop_bkops() is failed, then bkops is continuously running.
>>>>>>>>
>>>>>>>> Best Regards,
>>>>>>>> Jaehoon Chung
>>>>>>>>
>>>>>>>>> +            }
>>>>>>>>> +    }
>>>>>>>>>
>>>>>>>>>      ret = mmc_blk_part_switch(card, md);
>>>>>>>>>      if (ret) {
>>>>>>>>> diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
>>>>>>>>> index fadf52e..9d0c96a 100644
>>>>>>>>> --- a/drivers/mmc/card/queue.c
>>>>>>>>> +++ b/drivers/mmc/card/queue.c
>>>>>>>>> @@ -51,6 +51,7 @@ static int mmc_queue_thread(void *d)  {
>>>>>>>>>      struct mmc_queue *mq = d;
>>>>>>>>>      struct request_queue *q = mq->queue;
>>>>>>>>> +    struct mmc_card *card = mq->card;
>>>>>>>>>
>>>>>>>>>      current->flags |= PF_MEMALLOC;
>>>>>>>>>
>>>>>>>>> @@ -83,6 +84,7 @@ static int mmc_queue_thread(void *d)
>>>>>>>>>                              set_current_state(TASK_RUNNING);
>>>>>>>>>                              break;
>>>>>>>>>                      }
>>>>>>>>> +                    mmc_start_delayed_bkops(card);
>>>>>>>>>                      up(&mq->thread_sem);
>>>>>>>>>                      schedule();
>>>>>>>>>                      down(&mq->thread_sem);
>>>>>>>>> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
>>>>>>>>> index 06c42cf..72ae15b 100644
>>>>>>>>> --- a/drivers/mmc/core/core.c
>>>>>>>>> +++ b/drivers/mmc/core/core.c
>>>>>>>>> @@ -253,9 +253,36 @@ mmc_start_request(struct mmc_host *host, struct
>>>>>>>>> mmc_request *mrq)
>>>>>>>>>  }
>>>>>>>>>
>>>>>>>>>  /**
>>>>>>>>> + * mmc_start_delayed_bkops() - Start a delayed work to check for
>>>>>>>>> + *      the need of non urgent BKOPS
>>>>>>>>> + *
>>>>>>>>> + * @card: MMC card to start BKOPS on
>>>>>>>>> + */
>>>>>>>>> +void mmc_start_delayed_bkops(struct mmc_card *card)
>>>>>>>>> +{
>>>>>>>>> +    if (!card || !card->ext_csd.bkops_en ||
>>>>>>>>> mmc_card_doing_bkops(card))
>>>>>>>>> +            return;
>>>>>>>>> +
>>>>>>>>> +    pr_debug("%s: %s: queueing delayed_bkops_work\n",
>>>>>>>>> +             mmc_hostname(card->host), __func__);
>>>>>>>>> +
>>>>>>>>> +    /*
>>>>>>>>> +     * cancel_delayed_bkops_work will prevent a race condition
>>>>>>>>> between
>>>>>>>>> +     * fetching a request by the mmcqd and the delayed work, in
>>>>>>>>> case
>>>>>>>>> +     * it was removed from the queue work but not started yet
>>>>>>>>> +     */
>>>>>>>>> +    card->bkops_info.cancel_delayed_work = false;
>>>>>>>>> +    card->bkops_info.started_delayed_bkops = true;
>>>>>>>>> +    queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
>>>>>>>>> +                       msecs_to_jiffies(
>>>>>>>>> +                               card->bkops_info.delay_ms));
>>>>>>>>> +}
>>>>>>>>> +EXPORT_SYMBOL(mmc_start_delayed_bkops);
>>>>>>>>> +
>>>>>>>>> +/**
>>>>>>>>>   *  mmc_start_bkops - start BKOPS for supported cards
>>>>>>>>>   *  @card: MMC card to start BKOPS
>>>>>>>>> - *  @form_exception: A flag to indicate if this function was
>>>>>>>>> + *  @from_exception: A flag to indicate if this function was
>>>>>>>>>   *                   called due to an exception raised by the card
>>>>>>>>>   *
>>>>>>>>>   *  Start background operations whenever requested.
>>>>>>>>> @@ -269,25 +296,47 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>>>> bool
>>>>>>>>> from_exception)
>>>>>>>>>      bool use_busy_signal;
>>>>>>>>>
>>>>>>>>>      BUG_ON(!card);
>>>>>>>>> -
>>>>>>>>> -    if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
>>>>>>>>> +    if (!card->ext_csd.bkops_en)
>>>>>>>>>              return;
>>>>>>>>>
>>>>>>>>> +    mmc_claim_host(card->host);
>>>>>>>>> +
>>>>>>>>> +    if ((card->bkops_info.cancel_delayed_work) && !from_exception)
>>>>>>>>> {
>>>>>>>>> +            pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
>>>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>>>> +            card->bkops_info.cancel_delayed_work = false;
>>>>>>>>> +            goto out;
>>>>>>>>> +    }
>>>>>>>>> +
>>>>>>>>> +    if (mmc_card_doing_bkops(card)) {
>>>>>>>>> +            pr_debug("%s: %s: already doing bkops, exit\n",
>>>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>>>> +            goto out;
>>>>>>>>> +    }
>>>>>>>>> +
>>>>>>>>>      err = mmc_read_bkops_status(card);
>>>>>>>>>      if (err) {
>>>>>>>>>              pr_err("%s: Failed to read bkops status: %d\n",
>>>>>>>>>                     mmc_hostname(card->host), err);
>>>>>>>>> -            return;
>>>>>>>>> +            goto out;
>>>>>>>>>      }
>>>>>>>>>
>>>>>>>>>      if (!card->ext_csd.raw_bkops_status)
>>>>>>>>> -            return;
>>>>>>>>> +            goto out;
>>>>>>>>>
>>>>>>>>> +    pr_info("%s: %s: card->ext_csd.raw_bkops_status = 0x%x\n",
>>>>>>>>> +            mmc_hostname(card->host), __func__,
>>>>>>>>> +            card->ext_csd.raw_bkops_status);
>>>>>>>>> +
>>>>>>>>> +    /*
>>>>>>>>> +     * If the function was called due to exception but there is no
>>>>>>>>> need
>>>>>>>>> +     * for urgent BKOPS, BKOPs will be performed by the delayed
>>>>>>>>> BKOPs
>>>>>>>>> +     * work, before going to suspend
>>>>>>>>> +     */
>>>>>>>>>      if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
>>>>>>>>>          from_exception)
>>>>>>>>> -            return;
>>>>>>>>> +            goto out;
>>>>>>>>>
>>>>>>>>> -    mmc_claim_host(card->host);
>>>>>>>>>      if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
>>>>>>>>>              timeout = MMC_BKOPS_MAX_TIMEOUT;
>>>>>>>>>              use_busy_signal = true;
>>>>>>>>> @@ -309,13 +358,108 @@ void mmc_start_bkops(struct mmc_card *card,
>>>>>>>>> bool
>>>>>>>>> from_exception)
>>>>>>>>>       * bkops executed synchronously, otherwise
>>>>>>>>>       * the operation is in progress
>>>>>>>>>       */
>>>>>>>>> -    if (!use_busy_signal)
>>>>>>>>> +    if (!use_busy_signal) {
>>>>>>>>>              mmc_card_set_doing_bkops(card);
>>>>>>>>> +            pr_debug("%s: %s: starting the polling thread\n",
>>>>>>>>> +                     mmc_hostname(card->host), __func__);
>>>>>>>>> +            queue_work(system_nrt_wq,
>>>>>>>>> +                       &card->bkops_info.poll_for_completion);
>>>>>>>>> +    }
>>>>>>>>> +
>>>>>>>>>  out:
>>>>>>>>>      mmc_release_host(card->host);
>>>>>>>>>  }
>>>>>>>>>  EXPORT_SYMBOL(mmc_start_bkops);
>>>>>>>>>
>>>>>>>>> +/**
>>>>>>>>> + * mmc_bkops_completion_polling() - Poll on the card status to
>>>>>>>>> + * wait for the non-blocking BKOPS completion
>>>>>>>>> + * @work:   The completion polling work
>>>>>>>>> + *
>>>>>>>>> + * The on-going reading of the card status will prevent the card
>>>>>>>>> + * from getting into suspend while it is in the middle of
>>>>>>>>> + * performing BKOPS.
>>>>>>
>>>>>> Not true! Suspend will not be prevented by doing a mmc_send_status.
>>>>>> Moreover, I would be interested to understand more about why you need
>>>>>> to prevent "suspend". Please elaborate why you think this is needed.
>>>>> This is explained in my general comment. Let me know if it is still not
>>>>> clear.
>>>>>>
>>>>>>>>> + * Since the non blocking BKOPS can be interrupted by a fetched
>>>>>>>>> + * request we also check IF mmc_card_doing_bkops in each
>>>>>>>>> + * iteration.
>>>>>>>>> + */
>>>>>>>>> +void mmc_bkops_completion_polling(struct work_struct *work)
>>>>>>>>> +{
>>>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>>>> +                    bkops_info.poll_for_completion);
>>>>>>>>> +    unsigned long timeout_jiffies = jiffies +
>>>>>>>>> +            msecs_to_jiffies(BKOPS_COMPLETION_POLLING_TIMEOUT_MS);
>>>>>>>>> +    u32 status;
>>>>>>>>> +    int err;
>>>>>>>>> +
>>>>>>>>> +    /*
>>>>>>>>> +     * Wait for the BKOPs to complete. Keep reading the status to
>>>>>>>>> prevent
>>>>>>>>> +     * the host from getting into suspend
>>>>>>>>> +     */
>>>>>>>>> +    do {
>>>>>>>>> +            mmc_claim_host(card->host);
>>>>>>>>> +
>>>>>>>>> +            if (!mmc_card_doing_bkops(card))
>>>>>>>>> +                    goto out;
>>>>>>>>> +
>>>>>>>>> +            err = mmc_send_status(card, &status);
>>>>>>>>> +            if (err) {
>>>>>>>>> +                    pr_err("%s: error %d requesting status\n",
>>>>>>>>> +                           mmc_hostname(card->host), err);
>>>>>>>>> +                    goto out;
>>>>>>>>> +            }
>>>>>>>>> +
>>>>>>>>> +            /*
>>>>>>>>> +             * Some cards mishandle the status bits, so make sure
>>>>>>>>> to
>>>>>>>>> check
>>>>>>>>> +             * both the busy indication and the card state.
>>>>>>>>> +             */
>>>>>>>>> +            if ((status & R1_READY_FOR_DATA) &&
>>>>>>>>> +                (R1_CURRENT_STATE(status) != R1_STATE_PRG)) {
>>>>>>>>> +                    pr_debug("%s: %s: completed BKOPs, exit
>>>>>>>>> polling\n",
>>>>>>>>> +                             mmc_hostname(card->host), __func__);
>>>>>>>>> +                    mmc_card_clr_doing_bkops(card);
>>>>>>>>> +                    card->bkops_info.started_delayed_bkops = false;
>>>>>>>>> +                    goto out;
>>>>>>>>> +            }
>>>>>>>>> +
>>>>>>>>> +            mmc_release_host(card->host);
>>>>>>>>> +
>>>>>>>>> +            /*
>>>>>>>>> +             * Sleep before checking the card status again to allow
>>>>>>>>> the
>>>>>>>>> +             * card to complete the BKOPs operation
>>>>>>>>> +             */
>>>>>>>>> +            msleep(BKOPS_COMPLETION_POLLING_INTERVAL_MS);
>>>>>>>>> +    } while (time_before(jiffies, timeout_jiffies));
>>>>>>>>> +
>>>>>>>>> +    pr_err("%s: %s: exit polling due to timeout\n",
>>>>>>>>> +           mmc_hostname(card->host), __func__);
>>>>>>>>> +
>>>>>>>>> +    return;
>>>>>>>>> +out:
>>>>>>>>> +    mmc_release_host(card->host);
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +/**
>>>>>>>>> + * mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
>>>>>>>>> + * needed
>>>>>>>>> + * @work:   The idle time BKOPS work
>>>>>>>>> + */
>>>>>>>>> +void mmc_start_idle_time_bkops(struct work_struct *work)
>>>>>>>>> +{
>>>>>>>>> +    struct mmc_card *card = container_of(work, struct mmc_card,
>>>>>>>>> +                    bkops_info.dw.work);
>>>>>>>>> +
>>>>>>>>> +    /*
>>>>>>>>> +     * Prevent a race condition between mmc_stop_bkops and the
>>>>>>>>> delayed
>>>>>>>>> +     * BKOPS work in case the delayed work is executed on another
>>>>>>>>> CPU
>>>>>>>>> +     */
>>>>>>>>> +    if (card->bkops_info.cancel_delayed_work)
>>>>>>>>> +            return;
>>>>>>>>> +
>>>>>>>>> +    mmc_start_bkops(card, false);
>>>>>>>>> +}
>>>>>>>>> +EXPORT_SYMBOL(mmc_start_idle_time_bkops);
>>>>>>>>> +
>>>>>>>>>  static void mmc_wait_done(struct mmc_request *mrq)
>>>>>>>>>  {
>>>>>>>>>      complete(&mrq->completion);
>>>>>>>>> @@ -582,6 +726,17 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>>>      int err = 0;
>>>>>>>>>
>>>>>>>>>      BUG_ON(!card);
>>>>>>>>> +
>>>>>>>>> +    /*
>>>>>>>>> +     * Notify the delayed work to be cancelled, in case it was
>>>>>>>>> already
>>>>>>>>> +     * removed from the queue, but was not started yet
>>>>>>>>> +     */
>>>>>>>>> +    card->bkops_info.cancel_delayed_work = true;
>>>>>>>>> +    if (delayed_work_pending(&card->bkops_info.dw))
>>>>>>>>> +            cancel_delayed_work_sync(&card->bkops_info.dw);
>>>>>>>>> +    if (!mmc_card_doing_bkops(card))
>>>>>>>>> +            goto out;
>>>>>>>>> +
>>>>>>>>>      err = mmc_interrupt_hpi(card);
>>>>>>>>>
>>>>>>>>>      /*
>>>>>>>>> @@ -593,6 +748,7 @@ int mmc_stop_bkops(struct mmc_card *card)
>>>>>>>>>              err = 0;
>>>>>>>>>      }
>>>>>>>>>
>>>>>>>>> +out:
>>>>>>>>>      return err;
>>>>>>>>>  }
>>>>>>>>>  EXPORT_SYMBOL(mmc_stop_bkops);
>>>>>>>>> @@ -2506,15 +2662,15 @@ int mmc_pm_notify(struct notifier_block
>>>>>>>>> *notify_block,
>>>>>>>>>      switch (mode) {
>>>>>>>>>      case PM_HIBERNATION_PREPARE:
>>>>>>>>>      case PM_SUSPEND_PREPARE:
>>>>>>>>> -            if (host->card && mmc_card_mmc(host->card) &&
>>>>>>>>> -                mmc_card_doing_bkops(host->card)) {
>>>>>>>>> +            if (host->card && mmc_card_mmc(host->card)) {
>>>>>>>>> +                    mmc_claim_host(host);
>>>>>>>>>                      err = mmc_stop_bkops(host->card);
>>>>>>>>> +                    mmc_release_host(host);
>>>>>>
>>>>>> This code seems a bit strange. You will check for mmc_card_mmc, but
>>>>>> not all (e)MMC will support bkops. How about acually just checking if
>>>>>> bkops is "on" or "off" somehow.
>>>>>>
>>>>>> Additionally, so this piece of code shall stop an ongoing bkops before
>>>>>> going to suspend, so that make sense. But would it not be more
>>>>>> meaningfull to take care of that in mmc_suspend_host? I mean why do yo
>>>>>> need to do it in the PM_SUSPEND_PREPARE notification sequence
>>>>>> especially?
>>>>> This code was not added by me. I just added the
>>>>> mmc_claim_host(host)/mmc_release_host calls. Maybe Jaehoon, who added
>>>>> this
>>>>> code in the BKOPS patch can respond to your comment.
>>>>>>
>>>>>>>>>                      if (err) {
>>>>>>>>>                              pr_err("%s: didn't stop bkops\n",
>>>>>>>>>                                      mmc_hostname(host));
>>>>>>>>>                              return err;
>>>>>>>>>                      }
>>>>>>>>> -                    mmc_card_clr_doing_bkops(host->card);
>>>>>>>>>              }
>>>>>>>>>
>>>>>>>>>              spin_lock_irqsave(&host->lock, flags);
>>>>>>>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
>>>>>>>>> index 7cc4638..dba76e3 100644
>>>>>>>>> --- a/drivers/mmc/core/mmc.c
>>>>>>>>> +++ b/drivers/mmc/core/mmc.c
>>>>>>>>> @@ -1258,6 +1258,29 @@ static int mmc_init_card(struct mmc_host
>>>>>>>>> *host,
>>>>>>>>> u32 ocr,
>>>>>>>>>              }
>>>>>>>>>      }
>>>>>>>>>
>>>>>>>>> +    if (!oldcard) {
>>>>>>>>> +            if (card->ext_csd.bkops_en) {
>>>>>>>>> +                    INIT_DELAYED_WORK(&card->bkops_info.dw,
>>>>>>>>> +                                      mmc_start_idle_time_bkops);
>>>>>>>>> +
>>>>>>>>> INIT_WORK(&card->bkops_info.poll_for_completion,
>>>>>>>>> +                              mmc_bkops_completion_polling);
>>>>>>
>>>>>> I guess you don't have "removable" eMMC with BKOPS support so this
>>>>>> code will in practice only be executed once for an eMMC, so we are
>>>>>> safe. But still I am not fond of putting this code for workqueue here.
>>>>>> Either that should be done as a part of when the card is
>>>>>> created/deleted or when then host is created/deleted.
>>>>> I will check if there could be a better place for this.
>>>>>>
>>>>>>>>> +
>>>>>>>>> +                    /*
>>>>>>>>> +                     * Calculate the time to start the BKOPs
>>>>>>>>> checking.
>>>>>>>>> +                     * The idle time of the host controller should
>>>>>>>>> be
>>>>>>>>> taken
>>>>>>>>> +                     * into account in order to prevent a race
>>>>>>>>> condition
>>>>>>>>> +                     * before starting BKOPs and going into
>>>>>>>>> suspend.
>>>>>>>>> +                     * If the host controller didn't set its idle
>>>>>>>>> time,
>>>>>>>>> +                     * a default value is used.
>>>>>>>>> +                     */
>>>>>>>>> +                    card->bkops_info.delay_ms =
>>>>>>>>> MMC_IDLE_BKOPS_TIME_MS;
>>>>>>>>> +                    if (card->bkops_info.host_suspend_tout_ms)
>>>>>>>>> +                            card->bkops_info.delay_ms = min(
>>>>>>>>> +                                    card->bkops_info.delay_ms,
>>>>>>>>> +
>>>>>>>>> card->bkops_info.host_suspend_tout_ms/2);
>>>>>>>>> +            }
>>>>>>>>> +    }
>>>>>>>>> +
>>>>>>>>>      if (!oldcard)
>>>>>>>>>              host->card = card;
>>>>>>>>>
>>>>>>>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
>>>>>>>>> index 943550d..224e2a5 100644
>>>>>>>>> --- a/include/linux/mmc/card.h
>>>>>>>>> +++ b/include/linux/mmc/card.h
>>>>>>>>> @@ -208,6 +208,39 @@ struct mmc_part {
>>>>>>>>>  #define MMC_BLK_DATA_AREA_GP        (1<<2)
>>>>>>>>>  };
>>>>>>>>>
>>>>>>>>> +/**
>>>>>>>>> + * struct mmc_bkops_info - BKOPS data
>>>>>>>>> + * @dw:     Idle time bkops delayed work
>>>>>>>>> + * @host_suspend_tout_ms:   The host controller idle time,
>>>>>>>>> + * before getting into suspend
>>>>>>>>> + * @delay_ms:       The time to start the BKOPS
>>>>>>>>> + *        delayed work once MMC thread is idle
>>>>>>>>> + * @poll_for_completion:    Poll on BKOPS completion
>>>>>>>>> + * @cancel_delayed_work: A flag to indicate if the delayed work
>>>>>>>>> + *        should be cancelled
>>>>>>>>> + * @started_delayed_bkops:  A flag to indicate if the delayed
>>>>>>>>> + *        work was scheduled
>>>>>>>>> + * @sectors_changed:  number of  sectors written or
>>>>>>>>> + *       discard since the last idle BKOPS were scheduled
>>>>>>>>> + */
>>>>>>>>> +struct mmc_bkops_info {
>>>>>>>>> +    struct delayed_work     dw;
>>>>>>>>> +    unsigned int            host_suspend_tout_ms;
>>>>>>
>>>>>> As stated earlier, what is this timeout you are referring to? What
>>>>>> suspend?
>>>>> Explained above.
>>>>>>
>>>>>>>>> +    unsigned int            delay_ms;
>>>>>>>>> +/*
>>>>>>>>> + * A default time for checking the need for non urgent BKOPS once
>>>>>>>>> mmcqd
>>>>>>>>> + * is idle.
>>>>>>>>> + */
>>>>>>>>> +#define MMC_IDLE_BKOPS_TIME_MS 2000
>>>>>>>>> +    struct work_struct      poll_for_completion;
>>>>>>>>> +/* Polling timeout and interval for waiting on non-blocking BKOPs
>>>>>>>>> completion */
>>>>>>>>> +#define BKOPS_COMPLETION_POLLING_TIMEOUT_MS 10000 /* in ms */
>>>>>>>>> +#define BKOPS_COMPLETION_POLLING_INTERVAL_MS 1000 /* in ms */
>>>>>>>>> +    bool                    cancel_delayed_work;
>>>>>>>>> +    bool                    started_delayed_bkops;
>>>>>>>>> +    unsigned int            sectors_changed;
>>>>>>
>>>>>> Could not find "sectors_changed" being used. Maybe you forgot to
>>>>>> remove this from previous version of the patch.
>>>>> Yes, this should be removed.
>>>>>>
>>>>>>>>> +};
>>>>>>>>> +
>>>>>>>>>  /*
>>>>>>>>>   * MMC device
>>>>>>>>>   */
>>>>>>>>> @@ -276,6 +309,8 @@ struct mmc_card {
>>>>>>>>>      struct dentry           *debugfs_root;
>>>>>>>>>      struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical
>>>>>>>>> partitions */
>>>>>>>>>      unsigned int    nr_parts;
>>>>>>>>> +
>>>>>>>>> +    struct mmc_bkops_info   bkops_info;
>>>>>>>>>  };
>>>>>>>>>
>>>>>>>>>  /*
>>>>>>>>> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
>>>>>>>>> index 9b9cdaf..665d345 100644
>>>>>>>>> --- a/include/linux/mmc/core.h
>>>>>>>>> +++ b/include/linux/mmc/core.h
>>>>>>>>> @@ -145,6 +145,9 @@ extern int mmc_app_cmd(struct mmc_host *, struct
>>>>>>>>> mmc_card *);
>>>>>>>>>  extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card
>>>>>>>>> *,
>>>>>>>>>      struct mmc_command *, int);
>>>>>>>>>  extern void mmc_start_bkops(struct mmc_card *card, bool
>>>>>>>>> from_exception);
>>>>>>>>> +extern void mmc_start_delayed_bkops(struct mmc_card *card);
>>>>>>>>> +extern void mmc_start_idle_time_bkops(struct work_struct *work);
>>>>>>>>> +extern void mmc_bkops_completion_polling(struct work_struct *work);
>>>>>>>>>  extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned
>>>>>>>>> int,
>>>>>>>>> bool);
>>>>>>>>>  extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> --
>>>>>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>>>>>> member
>>>>>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>>>>>
>>>>>>> --
>>>>>>> To unsubscribe from this list: send the line "unsubscribe
>>>>>>> linux-kernel"
>>>>>>> in
>>>>>>> the body of a message to majordomo@vger.kernel.org
>>>>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>>>> Please read the FAQ at  http://www.tux.org/lkml/
>>>>>>
>>>>>> Finally some overall thoughts. What I would like to understand is how
>>>>>> we decide that the card has become "idle". I belive two values should
>>>>>> be considered, but are they?
>>>>>> 1. The card need BKOPS to be performed for some status level.
>>>>>> 2. Request inactivity for a certain timeout has occured.
>>>>>>
>>>>>> Have you considered to use runtime PM for the card device instead of
>>>>>> the workqueue?
>>>>>>
>>>>>> Kind regards
>>>>>> Ulf Hansson
>>>>>> --
>>>>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>>>>>> the body of a message to majordomo@vger.kernel.org
>>>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
>>>>> member
>>>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>>>
>>>>> --
>>>>> To unsubscribe from this list: send the line "unsubscribe linux-kernel"
>>>>> in
>>>>> the body of a message to majordomo@vger.kernel.org
>>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>> Please read the FAQ at  http://www.tux.org/lkml/
>>>>
>>>> Kind regards
>>>> Ulf Hansson
>>>> --
>>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>>>> the body of a message to majordomo@vger.kernel.org
>>>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>>>
>>>
>>>
>>> --
>>> QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a member
>>> of Code Aurora Forum, hosted by The Linux Foundation
>>>
>>
>> Kind regards
>> Ulf Hansson
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>
> 
> Kind regards
> Ulf Hansson
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
> 

[PATCH 1/3] mmc: Support FFU for eMMC v5.0

[Avi Shchislowski]

Add eMMC5.0 ffu ext_csd fields

Signed-off-by: Avi Shchislowski <avi.shchislowski@sandisk.com>
Signed-off-by: Alex Lemberg <alex.lemberg@sandisk.com>


diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 1eda8dd..3b86ed3 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -603,6 +603,15 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
 		card->ext_csd.data_sector_size = 512;
 	}
 
+	/* eMMC v5 or later */
+	if (card->ext_csd.rev >= 7) {
+		card->ext_csd.ffu_capable =
+			((ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) == 0x1) &&
+			((ext_csd[EXT_CSD_FW_CONFIG] & 0x1) == 0x0);
+		card->ext_csd.ffu_mode_op = ext_csd[EXT_CSD_FFU_FEATURES];
+	} else {
+		card->ext_csd.ffu_capable = false;
+	}
 out:
 	return err;
 }
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index d424b9d..dd01efe 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -81,6 +81,8 @@ struct mmc_ext_csd {
 	bool			hpi_en;			/* HPI enablebit */
 	bool			hpi;			/* HPI support bit */
 	unsigned int		hpi_cmd;		/* cmd used as HPI */
+	bool			ffu_capable;		/* FFU support */
+	bool			ffu_mode_op;		/* FFU mode operation */
 	bool			bkops;		/* background support bit */
 	bool			bkops_en;	/* background enable bit */
 	unsigned int            data_sector_size;       /* 512 bytes or 4KB */
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 64ec963..787787b 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -272,6 +272,9 @@ struct _mmc_csd {
  * EXT_CSD fields
  */
 
+#define EXT_CSD_FFU_STATUS		26	/* R */
+#define EXT_CSD_MODE_OPERATION_CODES	29	/* W */
+#define EXT_CSD_MODE_CONFIG		30	/* R/W */
 #define EXT_CSD_FLUSH_CACHE		32      /* W */
 #define EXT_CSD_CACHE_CTRL		33      /* R/W */
 #define EXT_CSD_POWER_OFF_NOTIFICATION	34	/* R/W */
@@ -290,6 +293,7 @@ struct _mmc_csd {
 #define EXT_CSD_SANITIZE_START		165     /* W */
 #define EXT_CSD_WR_REL_PARAM		166	/* RO */
 #define EXT_CSD_RPMB_MULT		168	/* RO */
+#define EXT_CSD_FW_CONFIG		169	/* R/W */
 #define EXT_CSD_BOOT_WP			173	/* R/W */
 #define EXT_CSD_ERASE_GROUP_DEF		175	/* R/W */
 #define EXT_CSD_PART_CONFIG		179	/* R/W */
@@ -326,6 +330,11 @@ struct _mmc_csd {
 #define EXT_CSD_GENERIC_CMD6_TIME	248	/* RO */
 #define EXT_CSD_CACHE_SIZE		249	/* RO, 4 bytes */
 #define EXT_CSD_PWR_CL_DDR_200_360	253	/* RO */
+#define EXT_CSD_NUM_OF_FW_SEC_PROG	302	/* RO, 4 bytes */
+#define EXT_CSD_FFU_ARG			487	/* RO, 4 bytes */
+#define EXT_CSD_OPERATION_CODE_TIMEOUT	491	/* RO */
+#define EXT_CSD_FFU_FEATURES		492	/* RO */
+#define EXT_CSD_SUPPORTED_MODE		493	/* RO */
 #define EXT_CSD_TAG_UNIT_SIZE		498	/* RO */
 #define EXT_CSD_DATA_TAG_SUPPORT	499	/* RO */
 #define EXT_CSD_MAX_PACKED_WRITES	500	/* RO */
-- 
1.7.9.5

Re: [PATCH 1/3] mmc: Support FFU for eMMC v5.0

[Jaehoon Chung]

Hi,

how did you make the patch?
This patch didn't apply at Ulf's repository.


On 11/11/2014 02:13 AM, Avi Shchislowski wrote:
> 
> Add eMMC5.0 ffu ext_csd fields
> 
> Signed-off-by: Avi Shchislowski <avi.shchislowski@sandisk.com>
> Signed-off-by: Alex Lemberg <alex.lemberg@sandisk.com>
> 
> 
> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
> index 1eda8dd..3b86ed3 100644
> --- a/drivers/mmc/core/mmc.c
> +++ b/drivers/mmc/core/mmc.c
> @@ -603,6 +603,15 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
>  		card->ext_csd.data_sector_size = 512;
>  	}
>  
> +	/* eMMC v5 or later */
> +	if (card->ext_csd.rev >= 7) {
> +		card->ext_csd.ffu_capable =
> +			((ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) == 0x1) &&
> +			((ext_csd[EXT_CSD_FW_CONFIG] & 0x1) == 0x0);

if (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&  !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1))
		card->ext_csd.ffu_capable = true;

> +		card->ext_csd.ffu_mode_op = ext_csd[EXT_CSD_FFU_FEATURES];
> +	} else {
> +		card->ext_csd.ffu_capable = false;

Can be set to false by default before checking whether card is eMMC v5.0 or not.

card->ext_csd.ffu_capable = false;

if (card->ext_csd.rev >= 7) {
	...
}

Best Regards,
Jaehoon Chung

> +	}
>  out:
>  	return err;
>  }
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index d424b9d..dd01efe 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -81,6 +81,8 @@ struct mmc_ext_csd {
>  	bool			hpi_en;			/* HPI enablebit */
>  	bool			hpi;			/* HPI support bit */
>  	unsigned int		hpi_cmd;		/* cmd used as HPI */
> +	bool			ffu_capable;		/* FFU support */
> +	bool			ffu_mode_op;		/* FFU mode operation */
>  	bool			bkops;		/* background support bit */
>  	bool			bkops_en;	/* background enable bit */
>  	unsigned int            data_sector_size;       /* 512 bytes or 4KB */
> diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
> index 64ec963..787787b 100644
> --- a/include/linux/mmc/mmc.h
> +++ b/include/linux/mmc/mmc.h
> @@ -272,6 +272,9 @@ struct _mmc_csd {
>   * EXT_CSD fields
>   */
>  
> +#define EXT_CSD_FFU_STATUS		26	/* R */
> +#define EXT_CSD_MODE_OPERATION_CODES	29	/* W */
> +#define EXT_CSD_MODE_CONFIG		30	/* R/W */
>  #define EXT_CSD_FLUSH_CACHE		32      /* W */
>  #define EXT_CSD_CACHE_CTRL		33      /* R/W */
>  #define EXT_CSD_POWER_OFF_NOTIFICATION	34	/* R/W */
> @@ -290,6 +293,7 @@ struct _mmc_csd {
>  #define EXT_CSD_SANITIZE_START		165     /* W */
>  #define EXT_CSD_WR_REL_PARAM		166	/* RO */
>  #define EXT_CSD_RPMB_MULT		168	/* RO */
> +#define EXT_CSD_FW_CONFIG		169	/* R/W */
>  #define EXT_CSD_BOOT_WP			173	/* R/W */
>  #define EXT_CSD_ERASE_GROUP_DEF		175	/* R/W */
>  #define EXT_CSD_PART_CONFIG		179	/* R/W */
> @@ -326,6 +330,11 @@ struct _mmc_csd {
>  #define EXT_CSD_GENERIC_CMD6_TIME	248	/* RO */
>  #define EXT_CSD_CACHE_SIZE		249	/* RO, 4 bytes */
>  #define EXT_CSD_PWR_CL_DDR_200_360	253	/* RO */
> +#define EXT_CSD_NUM_OF_FW_SEC_PROG	302	/* RO, 4 bytes */
> +#define EXT_CSD_FFU_ARG			487	/* RO, 4 bytes */
> +#define EXT_CSD_OPERATION_CODE_TIMEOUT	491	/* RO */
> +#define EXT_CSD_FFU_FEATURES		492	/* RO */
> +#define EXT_CSD_SUPPORTED_MODE		493	/* RO */
>  #define EXT_CSD_TAG_UNIT_SIZE		498	/* RO */
>  #define EXT_CSD_DATA_TAG_SUPPORT	499	/* RO */
>  #define EXT_CSD_MAX_PACKED_WRITES	500	/* RO */
> 

RE: [PATCH 1/3] mmc: Support FFU for eMMC v5.0

[Avi Shchislowski]

Hi 
I used the "git send-email..."

Thanks


>-----Original Message-----
>From: Jaehoon Chung [mailto:jh80.chung@samsung.com]
>Sent: Tuesday, November 11, 2014 5:08 AM
>To: Avi Shchislowski; ulf.hansson@linaro.org
>Cc: 'Chris Ball'; linux-mmc@vger.kernel.org; Alex Lemberg;
>gwendal@google.com; open list; CPGS
>Subject: Re: [PATCH 1/3] mmc: Support FFU for eMMC v5.0
>
>Hi,
>
>how did you make the patch?
>This patch didn't apply at Ulf's repository.
>
>
>On 11/11/2014 02:13 AM, Avi Shchislowski wrote:
>>
>> Add eMMC5.0 ffu ext_csd fields
>>
>> Signed-off-by: Avi Shchislowski <avi.shchislowski@sandisk.com>
>> Signed-off-by: Alex Lemberg <alex.lemberg@sandisk.com>
>>
>>
>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c index
>> 1eda8dd..3b86ed3 100644
>> --- a/drivers/mmc/core/mmc.c
>> +++ b/drivers/mmc/core/mmc.c
>> @@ -603,6 +603,15 @@ static int mmc_read_ext_csd(struct mmc_card
>*card, u8 *ext_csd)
>>  		card->ext_csd.data_sector_size = 512;
>>  	}
>>
>> +	/* eMMC v5 or later */
>> +	if (card->ext_csd.rev >= 7) {
>> +		card->ext_csd.ffu_capable =
>> +			((ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) ==
>0x1) &&
>> +			((ext_csd[EXT_CSD_FW_CONFIG] & 0x1) == 0x0);
>
>if (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1)
>&&  !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1))
>		card->ext_csd.ffu_capable = true;
>
>> +		card->ext_csd.ffu_mode_op =
>ext_csd[EXT_CSD_FFU_FEATURES];
>> +	} else {
>> +		card->ext_csd.ffu_capable = false;
>
>Can be set to false by default before checking whether card is eMMC v5.0 or
>not.
>
>card->ext_csd.ffu_capable = false;
>
>if (card->ext_csd.rev >= 7) {
>	...
>}
>
>Best Regards,
>Jaehoon Chung
>
>> +	}
>>  out:
>>  	return err;
>>  }
>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h index
>> d424b9d..dd01efe 100644
>> --- a/include/linux/mmc/card.h
>> +++ b/include/linux/mmc/card.h
>> @@ -81,6 +81,8 @@ struct mmc_ext_csd {
>>  	bool			hpi_en;			/* HPI
>enablebit */
>>  	bool			hpi;			/* HPI support bit */
>>  	unsigned int		hpi_cmd;		/* cmd used as HPI */
>> +	bool			ffu_capable;		/* FFU support */
>> +	bool			ffu_mode_op;		/* FFU mode
>operation */
>>  	bool			bkops;		/* background support bit */
>>  	bool			bkops_en;	/* background enable bit */
>>  	unsigned int            data_sector_size;       /* 512 bytes or 4KB */
>> diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h index
>> 64ec963..787787b 100644
>> --- a/include/linux/mmc/mmc.h
>> +++ b/include/linux/mmc/mmc.h
>> @@ -272,6 +272,9 @@ struct _mmc_csd {
>>   * EXT_CSD fields
>>   */
>>
>> +#define EXT_CSD_FFU_STATUS		26	/* R */
>> +#define EXT_CSD_MODE_OPERATION_CODES	29	/* W */
>> +#define EXT_CSD_MODE_CONFIG		30	/* R/W */
>>  #define EXT_CSD_FLUSH_CACHE		32      /* W */
>>  #define EXT_CSD_CACHE_CTRL		33      /* R/W */
>>  #define EXT_CSD_POWER_OFF_NOTIFICATION	34	/* R/W */
>> @@ -290,6 +293,7 @@ struct _mmc_csd {
>>  #define EXT_CSD_SANITIZE_START		165     /* W */
>>  #define EXT_CSD_WR_REL_PARAM		166	/* RO */
>>  #define EXT_CSD_RPMB_MULT		168	/* RO */
>> +#define EXT_CSD_FW_CONFIG		169	/* R/W */
>>  #define EXT_CSD_BOOT_WP			173	/* R/W */
>>  #define EXT_CSD_ERASE_GROUP_DEF		175	/* R/W */
>>  #define EXT_CSD_PART_CONFIG		179	/* R/W */
>> @@ -326,6 +330,11 @@ struct _mmc_csd {
>>  #define EXT_CSD_GENERIC_CMD6_TIME	248	/* RO */
>>  #define EXT_CSD_CACHE_SIZE		249	/* RO, 4 bytes */
>>  #define EXT_CSD_PWR_CL_DDR_200_360	253	/* RO */
>> +#define EXT_CSD_NUM_OF_FW_SEC_PROG	302	/* RO, 4 bytes
>*/
>> +#define EXT_CSD_FFU_ARG			487	/* RO, 4 bytes
>*/
>> +#define EXT_CSD_OPERATION_CODE_TIMEOUT	491	/* RO */
>> +#define EXT_CSD_FFU_FEATURES		492	/* RO */
>> +#define EXT_CSD_SUPPORTED_MODE		493	/* RO */
>>  #define EXT_CSD_TAG_UNIT_SIZE		498	/* RO */
>>  #define EXT_CSD_DATA_TAG_SUPPORT	499	/* RO */
>>  #define EXT_CSD_MAX_PACKED_WRITES	500	/* RO */
>>

[PATCH 2/3] mmc: Support FFU for eMMC v5.0

[Avi Shchislowski]

eMMC5.0 FFU is using some of pre-existing mmc_test.c functionality.
In order to prevent code duplication, some code of mmc_test.c was moved to core.c and modified.

Signed-off-by: Avi Shchislowski <avi.shchislowski@sandisk.com>
Signed-off-by: Alex Lemberg <alex.lemberg@sandisk.com>

diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 0c0fc52..e6ee0a8 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -13,6 +13,7 @@
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
+#include <linux/mmc/core.h>
 #include <linux/slab.h>
 
 #include <linux/scatterlist.h>
@@ -189,43 +190,8 @@ static void mmc_test_prepare_mrq(struct mmc_test_card *test,
 	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
 	unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
 {
-	BUG_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop);
-
-	if (blocks > 1) {
-		mrq->cmd->opcode = write ?
-			MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
-	} else {
-		mrq->cmd->opcode = write ?
-			MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
-	}
-
-	mrq->cmd->arg = dev_addr;
-	if (!mmc_card_blockaddr(test->card))
-		mrq->cmd->arg <<= 9;
-
-	mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
-
-	if (blocks == 1)
-		mrq->stop = NULL;
-	else {
-		mrq->stop->opcode = MMC_STOP_TRANSMISSION;
-		mrq->stop->arg = 0;
-		mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
-	}
-
-	mrq->data->blksz = blksz;
-	mrq->data->blocks = blocks;
-	mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
-	mrq->data->sg = sg;
-	mrq->data->sg_len = sg_len;
-
-	mmc_set_data_timeout(mrq->data, test->card);
-}
-
-static int mmc_test_busy(struct mmc_command *cmd)
-{
-	return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
-		(R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
+	mmc_prepare_mrq(test->card, mrq, sg, sg_len,
+		dev_addr, blocks, blksz, write);
 }
 
 /*
@@ -233,30 +199,9 @@ static int mmc_test_busy(struct mmc_command *cmd)
  */
 static int mmc_test_wait_busy(struct mmc_test_card *test)
 {
-	int ret, busy;
-	struct mmc_command cmd = {0};
-
-	busy = 0;
-	do {
-		memset(&cmd, 0, sizeof(struct mmc_command));
-
-		cmd.opcode = MMC_SEND_STATUS;
-		cmd.arg = test->card->rca << 16;
-		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
-
-		ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
-		if (ret)
-			break;
-
-		if (!busy && mmc_test_busy(&cmd)) {
-			busy = 1;
-			if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
-				pr_info("%s: Warning: Host did not "
-					"wait for busy state to end.\n",
-					mmc_hostname(test->card->host));
-		}
-	} while (mmc_test_busy(&cmd));
+	int ret;
 
+	ret = mmc_wait_busy(test->card);
 	return ret;
 }
 
@@ -693,19 +638,9 @@ static int mmc_test_check_result(struct mmc_test_card *test,
 {
 	int ret;
 
-	BUG_ON(!mrq || !mrq->cmd || !mrq->data);
-
 	ret = 0;
 
-	if (!ret && mrq->cmd->error)
-		ret = mrq->cmd->error;
-	if (!ret && mrq->data->error)
-		ret = mrq->data->error;
-	if (!ret && mrq->stop && mrq->stop->error)
-		ret = mrq->stop->error;
-	if (!ret && mrq->data->bytes_xfered !=
-		mrq->data->blocks * mrq->data->blksz)
-		ret = RESULT_FAIL;
+	ret = mmc_check_result(mrq);
 
 	if (ret == -EINVAL)
 		ret = RESULT_UNSUP_HOST;
@@ -844,23 +779,13 @@ static int mmc_test_simple_transfer(struct mmc_test_card *test,
 	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
 	unsigned blocks, unsigned blksz, int write)
 {
-	struct mmc_request mrq = {0};
-	struct mmc_command cmd = {0};
-	struct mmc_command stop = {0};
-	struct mmc_data data = {0};
-
-	mrq.cmd = &cmd;
-	mrq.data = &data;
-	mrq.stop = &stop;
+	int ret;
 
-	mmc_test_prepare_mrq(test, &mrq, sg, sg_len, dev_addr,
+	ret = mmc_simple_transfer(test->card, sg, sg_len, dev_addr,
 		blocks, blksz, write);
-
-	mmc_wait_for_req(test->card->host, &mrq);
-
-	mmc_test_wait_busy(test);
-
-	return mmc_test_check_result(test, &mrq);
+	if (ret == -EINVAL)
+		ret = RESULT_UNSUP_HOST;
+	return ret;
 }
 
 /*
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index d03a080..132da0c 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -2658,6 +2658,134 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 	return 0;
 }
 #endif
+/*
+ * Fill in the mmc_request structure given a set of transfer parameters.
+ */
+void mmc_prepare_mrq(struct mmc_card *card,
+	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
+	unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
+{
+	BUG_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop);
+
+	if (blocks > 1) {
+		mrq->cmd->opcode = write ?
+			MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
+	} else {
+		mrq->cmd->opcode = write ?
+			MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
+	}
+
+	mrq->cmd->arg = dev_addr;
+	if (!mmc_card_blockaddr(card))
+		mrq->cmd->arg <<= 9;
+
+	mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
+
+	if (blocks == 1)
+		mrq->stop = NULL;
+	else {
+		mrq->stop->opcode = MMC_STOP_TRANSMISSION;
+		mrq->stop->arg = 0;
+		mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
+	}
+
+	mrq->data->blksz = blksz;
+	mrq->data->blocks = blocks;
+	mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
+	mrq->data->sg = sg;
+	mrq->data->sg_len = sg_len;
+
+	mmc_set_data_timeout(mrq->data, card);
+}
+EXPORT_SYMBOL(mmc_prepare_mrq);
+
+static int mmc_busy(struct mmc_command *cmd)
+{
+	return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
+		(R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
+}
+
+/*
+ * Wait for the card to finish the busy state
+ */
+int mmc_wait_busy(struct mmc_card *card)
+{
+	int ret, busy = 0;
+	struct mmc_command cmd = {0};
+
+	memset(&cmd, 0, sizeof(struct mmc_command));
+	cmd.opcode = MMC_SEND_STATUS;
+	cmd.arg = card->rca << 16;
+	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
+
+	do {
+		ret = mmc_wait_for_cmd(card->host, &cmd, 0);
+		if (ret)
+			break;
+
+		if (!busy && mmc_busy(&cmd)) {
+			busy = 1;
+			if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) {
+				pr_warn("%s: Warning: Host did not "
+					"wait for busy state to end.\n",
+					mmc_hostname(card->host));
+			}
+		}
+
+	} while (mmc_busy(&cmd));
+
+	return ret;
+}
+EXPORT_SYMBOL(mmc_wait_busy);
+
+int mmc_check_result(struct mmc_request *mrq)
+{
+	int ret;
+
+	BUG_ON(!mrq || !mrq->cmd || !mrq->data);
+
+	ret = 0;
+
+	if (!ret && mrq->cmd->error)
+		ret = mrq->cmd->error;
+	if (!ret && mrq->data->error)
+		ret = mrq->data->error;
+	if (!ret && mrq->stop && mrq->stop->error)
+		ret = mrq->stop->error;
+	if (!ret && mrq->data->bytes_xfered !=
+		mrq->data->blocks * mrq->data->blksz)
+		ret = -EPERM;
+
+	return ret;
+}
+EXPORT_SYMBOL(mmc_check_result);
+
+/*
++ * transfer with certain parameters
+ */
+int mmc_simple_transfer(struct mmc_card *card,
+	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
+	unsigned blocks, unsigned blksz, int write)
+{
+	struct mmc_request mrq = {0};
+	struct mmc_command cmd = {0};
+	struct mmc_command stop = {0};
+	struct mmc_data data = {0};
+
+	mrq.cmd = &cmd;
+	mrq.data = &data;
+	mrq.stop = &stop;
+
+	mmc_prepare_mrq(card, &mrq, sg, sg_len, dev_addr,
+		blocks, blksz, write);
+
+	mmc_wait_for_req(card->host, &mrq);
+
+	mmc_wait_busy(card);
+
+	return mmc_check_result(&mrq);
+}
+EXPORT_SYMBOL(mmc_simple_transfer);
 
 /**
  * mmc_init_context_info() - init synchronization context
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index f206e29..92540d0 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -196,6 +196,14 @@ extern void mmc_put_card(struct mmc_card *card);
 extern int mmc_flush_cache(struct mmc_card *);
 
 extern int mmc_detect_card_removed(struct mmc_host *host);
+extern void mmc_prepare_mrq(struct mmc_card *card,
+	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
+	unsigned dev_addr, unsigned blocks, unsigned blksz, int write);
+extern int mmc_wait_busy(struct mmc_card *card);
+extern int mmc_check_result(struct mmc_request *mrq);
+extern int mmc_simple_transfer(struct mmc_card *card,
+	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
+	unsigned blocks, unsigned blksz, int write);
 
 /**
  *	mmc_claim_host - exclusively claim a host
-- 
1.7.9.5

Re: [PATCH 2/3] mmc: Support FFU for eMMC v5.0

[Jaehoon Chung]

Hi,

On 11/11/2014 02:18 AM, Avi Shchislowski wrote:
> eMMC5.0 FFU is using some of pre-existing mmc_test.c functionality.
> In order to prevent code duplication, some code of mmc_test.c was moved to core.c and modified.
> 
> Signed-off-by: Avi Shchislowski <avi.shchislowski@sandisk.com>
> Signed-off-by: Alex Lemberg <alex.lemberg@sandisk.com>
> 
> diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
> index 0c0fc52..e6ee0a8 100644
> --- a/drivers/mmc/card/mmc_test.c
> +++ b/drivers/mmc/card/mmc_test.c
> @@ -13,6 +13,7 @@
>  #include <linux/mmc/card.h>
>  #include <linux/mmc/host.h>
>  #include <linux/mmc/mmc.h>
> +#include <linux/mmc/core.h>
>  #include <linux/slab.h>
>  
>  #include <linux/scatterlist.h>
> @@ -189,43 +190,8 @@ static void mmc_test_prepare_mrq(struct mmc_test_card *test,
>  	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
>  	unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
>  {
> -	BUG_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop);
> -
> -	if (blocks > 1) {
> -		mrq->cmd->opcode = write ?
> -			MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
> -	} else {
> -		mrq->cmd->opcode = write ?
> -			MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
> -	}
> -
> -	mrq->cmd->arg = dev_addr;
> -	if (!mmc_card_blockaddr(test->card))
> -		mrq->cmd->arg <<= 9;
> -
> -	mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
> -
> -	if (blocks == 1)
> -		mrq->stop = NULL;
> -	else {
> -		mrq->stop->opcode = MMC_STOP_TRANSMISSION;
> -		mrq->stop->arg = 0;
> -		mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
> -	}
> -
> -	mrq->data->blksz = blksz;
> -	mrq->data->blocks = blocks;
> -	mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
> -	mrq->data->sg = sg;
> -	mrq->data->sg_len = sg_len;
> -
> -	mmc_set_data_timeout(mrq->data, test->card);
> -}
> -
> -static int mmc_test_busy(struct mmc_command *cmd)
> -{
> -	return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
> -		(R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
> +	mmc_prepare_mrq(test->card, mrq, sg, sg_len,
> +		dev_addr, blocks, blksz, write);
>  }
>  
>  /*
> @@ -233,30 +199,9 @@ static int mmc_test_busy(struct mmc_command *cmd)
>   */
>  static int mmc_test_wait_busy(struct mmc_test_card *test)
>  {
> -	int ret, busy;
> -	struct mmc_command cmd = {0};
> -
> -	busy = 0;
> -	do {
> -		memset(&cmd, 0, sizeof(struct mmc_command));
> -
> -		cmd.opcode = MMC_SEND_STATUS;
> -		cmd.arg = test->card->rca << 16;
> -		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
> -
> -		ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
> -		if (ret)
> -			break;
> -
> -		if (!busy && mmc_test_busy(&cmd)) {
> -			busy = 1;
> -			if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
> -				pr_info("%s: Warning: Host did not "
> -					"wait for busy state to end.\n",
> -					mmc_hostname(test->card->host));
> -		}
> -	} while (mmc_test_busy(&cmd));
> +	int ret;
>  
> +	ret = mmc_wait_busy(test->card);

return mmc_wait_busy(test->card);

And mmc_test_wait_busy is wrapper function?
Why do you use the wrapper function?

>  	return ret;
>  }
>  
> @@ -693,19 +638,9 @@ static int mmc_test_check_result(struct mmc_test_card *test,
>  {
>  	int ret;
>  
> -	BUG_ON(!mrq || !mrq->cmd || !mrq->data);
> -
>  	ret = 0;
>  
> -	if (!ret && mrq->cmd->error)
> -		ret = mrq->cmd->error;
> -	if (!ret && mrq->data->error)
> -		ret = mrq->data->error;
> -	if (!ret && mrq->stop && mrq->stop->error)
> -		ret = mrq->stop->error;
> -	if (!ret && mrq->data->bytes_xfered !=
> -		mrq->data->blocks * mrq->data->blksz)
> -		ret = RESULT_FAIL;
> +	ret = mmc_check_result(mrq);
>  
>  	if (ret == -EINVAL)
>  		ret = RESULT_UNSUP_HOST;
> @@ -844,23 +779,13 @@ static int mmc_test_simple_transfer(struct mmc_test_card *test,
>  	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
>  	unsigned blocks, unsigned blksz, int write)
>  {
> -	struct mmc_request mrq = {0};
> -	struct mmc_command cmd = {0};
> -	struct mmc_command stop = {0};
> -	struct mmc_data data = {0};
> -
> -	mrq.cmd = &cmd;
> -	mrq.data = &data;
> -	mrq.stop = &stop;
> +	int ret;
>  
> -	mmc_test_prepare_mrq(test, &mrq, sg, sg_len, dev_addr,
> +	ret = mmc_simple_transfer(test->card, sg, sg_len, dev_addr,
>  		blocks, blksz, write);
> -
> -	mmc_wait_for_req(test->card->host, &mrq);
> -
> -	mmc_test_wait_busy(test);
> -
> -	return mmc_test_check_result(test, &mrq);
> +	if (ret == -EINVAL)
> +		ret = RESULT_UNSUP_HOST;
> +	return ret;
>  }
>  
>  /*
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index d03a080..132da0c 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -2658,6 +2658,134 @@ int mmc_pm_notify(struct notifier_block *notify_block,
>  	return 0;
>  }
>  #endif
> +/*
> + * Fill in the mmc_request structure given a set of transfer parameters.
> + */
> +void mmc_prepare_mrq(struct mmc_card *card,
> +	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
> +	unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
> +{
> +	BUG_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop);
> +
> +	if (blocks > 1) {
> +		mrq->cmd->opcode = write ?
> +			MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
> +	} else {
> +		mrq->cmd->opcode = write ?
> +			MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
> +	}
> +
> +	mrq->cmd->arg = dev_addr;
> +	if (!mmc_card_blockaddr(card))
> +		mrq->cmd->arg <<= 9;
> +
> +	mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
> +
> +	if (blocks == 1)
> +		mrq->stop = NULL;
> +	else {
> +		mrq->stop->opcode = MMC_STOP_TRANSMISSION;
> +		mrq->stop->arg = 0;
> +		mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
> +	}
> +
> +	mrq->data->blksz = blksz;
> +	mrq->data->blocks = blocks;
> +	mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
> +	mrq->data->sg = sg;
> +	mrq->data->sg_len = sg_len;
> +
> +	mmc_set_data_timeout(mrq->data, card);
> +}
> +EXPORT_SYMBOL(mmc_prepare_mrq);
> +
> +static int mmc_busy(struct mmc_command *cmd)
> +{
> +	return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
> +		(R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
> +}

What's function?

> +
> +/*
> + * Wait for the card to finish the busy state
> + */
> +int mmc_wait_busy(struct mmc_card *card)
> +{
> +	int ret, busy = 0;
> +	struct mmc_command cmd = {0};
> +
> +	memset(&cmd, 0, sizeof(struct mmc_command));
> +	cmd.opcode = MMC_SEND_STATUS;
> +	cmd.arg = card->rca << 16;
> +	cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
> +
> +	do {
> +		ret = mmc_wait_for_cmd(card->host, &cmd, 0);
> +		if (ret)
> +			break;
> +
> +		if (!busy && mmc_busy(&cmd)) {
> +			busy = 1;
> +			if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) {
> +				pr_warn("%s: Warning: Host did not "
> +					"wait for busy state to end.\n",
> +					mmc_hostname(card->host));
> +			}
> +		}
> +
> +	} while (mmc_busy(&cmd));
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL(mmc_wait_busy);
> +
> +int mmc_check_result(struct mmc_request *mrq)
> +{
> +	int ret;
> +
> +	BUG_ON(!mrq || !mrq->cmd || !mrq->data);
> +
> +	ret = 0;

Why do you initialized at here? 
if ret is 0, why do you check "if (!ret && xxxx)" at the below condition?

> +
> +	if (!ret && mrq->cmd->error)
> +		ret = mrq->cmd->error;
> +	if (!ret && mrq->data->error)
> +		ret = mrq->data->error;
> +	if (!ret && mrq->stop && mrq->stop->error)
> +		ret = mrq->stop->error;
> +	if (!ret && mrq->data->bytes_xfered !=
> +		mrq->data->blocks * mrq->data->blksz)
> +		ret = -EPERM;
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL(mmc_check_result);
> +
> +/*
> ++ * transfer with certain parameters
> + */
> +int mmc_simple_transfer(struct mmc_card *card,
> +	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
> +	unsigned blocks, unsigned blksz, int write)
> +{
> +	struct mmc_request mrq = {0};
> +	struct mmc_command cmd = {0};
> +	struct mmc_command stop = {0};
> +	struct mmc_data data = {0};
> +
> +	mrq.cmd = &cmd;
> +	mrq.data = &data;
> +	mrq.stop = &stop;
> +
> +	mmc_prepare_mrq(card, &mrq, sg, sg_len, dev_addr,
> +		blocks, blksz, write);
> +
> +	mmc_wait_for_req(card->host, &mrq);
> +
> +	mmc_wait_busy(card);
> +
> +	return mmc_check_result(&mrq);
> +}
> +EXPORT_SYMBOL(mmc_simple_transfer);
>  
>  /**
>   * mmc_init_context_info() - init synchronization context
> diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
> index f206e29..92540d0 100644
> --- a/include/linux/mmc/core.h
> +++ b/include/linux/mmc/core.h
> @@ -196,6 +196,14 @@ extern void mmc_put_card(struct mmc_card *card);
>  extern int mmc_flush_cache(struct mmc_card *);
>  
>  extern int mmc_detect_card_removed(struct mmc_host *host);
> +extern void mmc_prepare_mrq(struct mmc_card *card,
> +	struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
> +	unsigned dev_addr, unsigned blocks, unsigned blksz, int write);
> +extern int mmc_wait_busy(struct mmc_card *card);
> +extern int mmc_check_result(struct mmc_request *mrq);
> +extern int mmc_simple_transfer(struct mmc_card *card,
> +	struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
> +	unsigned blocks, unsigned blksz, int write);
>  
>  /**
>   *	mmc_claim_host - exclusively claim a host
>