mmc: Add Command Queue support
Subsystems (6)
Adrian Hunter
maintainercover mmc: Add Command Queue support
Hi
Here are patches to enable hardware command queue (Command Queue Engine or CQE) and software command queue.
Ritesh Harjani graciously agreed the use of their driver which has been re-named CQHCI to match the JEDEC specification and has some more features added.
The first 13 patches enable software command queue. Earlier versions have been submitted before.
The hardware command queue patches are now functionally complete, enabling all block requests (read/write/discard/flush) as well as re-tuning and recovery.
The patches can also be found here:
http://git.infradead.org/users/ahunter/linux-sdhci.git/shortlog/refs/heads/cqe
Adrian Hunter (38):
mmc: block: Use local var for mqrq_cur
mmc: queue: Share mmc request array between partitions
mmc: block: Introduce queue semantics
mmc: core: Do not prepare a new request twice
mmc: mmc: Add functions to enable / disable the Command Queue
mmc: mmc_test: Disable Command Queue while mmc_test is used
mmc: block: Disable Command Queue while RPMB is used
mmc: core: Export mmc_retune_hold() and mmc_retune_release()
mmc: queue: Add a function to control wake-up on new requests
mmc: block: Change mmc_apply_rel_rw() to get block address from the request
mmc: block: Factor out data preparation
mmc: block: Add Software Command Queuing
mmc: mmc: Enable Software Command Queuing
mmc: core: Factor out debug prints from mmc_start_request()
mmc: core: Factor out mrq preparation from mmc_start_request()
mmc: core: Add mmc_retune_hold_now()
mmc: core: Add members to mmc_request and mmc_data for CQE's
mmc: host: Add CQE interface
mmc: core: Turn off CQE before sending commands
mmc: core: Add support for handling CQE requests
mmc: mmc: Enable CQE's
mmc: block: Prepare CQE data
mmc: block: Add CQE support
mmc: sdhci: Improve debug print format
mmc: sdhci: Add response register to register dump
mmc: sdhci: Improve register dump print format
mmc: sdhci: Export sdhci_dumpregs
mmc: sdhci: Get rid of 'extern' in header file
mmc: sdhci: Add sdhci_cleanup_host
mmc: sdhci: Factor out sdhci_set_default_irqs
mmc: sdhci: Add CQE support
mmc: sdhci-pci: Let devices define how to add the host
mmc: sdhci-pci: Do not use suspend/resume callbacks with runtime pm
mmc: sdhci-pci: Conditionally compile pm sleep functions
mmc: sdhci-pci: Let suspend/resume callbacks replace default callbacks
mmc: sdhci-pci: Add runtime suspend/resume callbacks
mmc: sdhci-pci: Move a function to avoid later forward declaration
mmc: sdhci-pci: Add CQHCI support for Intel GLK
Venkat Gopalakrishnan (1):
mmc: cqhci: support for command queue enabled host
Documentation/mmc/mmc-dev-attrs.txt | 1 + drivers/mmc/core/block.c | 1021 ++++++++++++++++++++++++++---- drivers/mmc/core/block.h | 7 + drivers/mmc/core/bus.c | 7 + drivers/mmc/core/core.c | 212 ++++++- drivers/mmc/core/host.c | 8 + drivers/mmc/core/host.h | 1 + drivers/mmc/core/mmc.c | 41 +- drivers/mmc/core/mmc_ops.c | 28 + drivers/mmc/core/mmc_ops.h | 2 + drivers/mmc/core/mmc_test.c | 22 +- drivers/mmc/core/queue.c | 630 +++++++++++++++---- drivers/mmc/core/queue.h | 68 +- drivers/mmc/host/Kconfig | 14 + drivers/mmc/host/Makefile | 1 + drivers/mmc/host/cqhci.c | 1148 ++++++++++++++++++++++++++++++++++ drivers/mmc/host/cqhci.h | 228 +++++++ drivers/mmc/host/sdhci-pci-core.c | 499 ++++++++++----- drivers/mmc/host/sdhci-pci-o2micro.c | 4 +- drivers/mmc/host/sdhci-pci.h | 11 + drivers/mmc/host/sdhci.c | 324 +++++++--- drivers/mmc/host/sdhci.h | 54 +- include/linux/mmc/card.h | 8 + include/linux/mmc/core.h | 20 +- include/linux/mmc/host.h | 25 + include/trace/events/mmc.h | 17 +- 26 files changed, 3871 insertions(+), 530 deletions(-) create mode 100644 drivers/mmc/host/cqhci.c create mode 100644 drivers/mmc/host/cqhci.h
Regards
Adrian
Adrian Hunter
maintainerRFC PATCH 1/39 mmc: block: Use local var for mqrq_cur
A subsequent patch will remove 'mq->mqrq_cur'. Prepare for that by assigning it to a local variable.
--- drivers/mmc/core/block.c | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-)
drivers/mmc/core/block.c +14 -12
@@ -1605,7 +1605,8 @@ static void mmc_blk_rw_cmd_abort(struct mmc_card *card, struct request *req)* @mq: the queue with the card and host to restart * @req: a new request that want to be started after the current one */ -static void mmc_blk_rw_try_restart (struct mmc_queue *mq,struct request *req) +static void mmc_blk_rw_try_restart (struct mmc_queue *mq,struct request *req, +struct mmc_queue_req *mqrq) {if (!req)return ;
@@ -1619,8 +1620,8 @@ static void mmc_blk_rw_try_restart(struct mmc_queue *mq, struct request *req)return ; }/* Else proceed and try to restart the current async request */ -mmc_blk_rw_rq_prep (mq->mqrq_cur, mq->card,0 , mq); -mmc_start_areq (mq->card->host, &mq->mqrq_cur->areq,NULL ); +mmc_blk_rw_rq_prep (mqrq, mq->card,0 , mq); +mmc_start_areq (mq->card->host, &mqrq->areq,NULL ); }static void mmc_blk_issue_rw_rq (struct mmc_queue *mq,struct request *new_req)
@@ -1630,6 +1631,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)struct mmc_blk_request *brq;int disable_multi =0 , retry =0 , type, retune_retry_done =0 ;enum mmc_blk_status status; +struct mmc_queue_req *mqrq_cur = mq->mqrq_cur;struct mmc_queue_req *mq_rq;struct request *old_req;struct mmc_async_req *new_areq;
@@ -1653,8 +1655,8 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)return ; } -mmc_blk_rw_rq_prep (mq->mqrq_cur, card,0 , mq); - new_areq = &mq->mqrq_cur->areq; +mmc_blk_rw_rq_prep (mqrq_cur, card,0 , mq); + new_areq = &mqrq_cur->areq; }else new_areq =NULL ;
@@ -1707,11 +1709,11 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) req_pending =mmc_blk_rw_cmd_err (md, card, brq, old_req, req_pending);if (mmc_blk_reset (md, card->host, type)) {mmc_blk_rw_cmd_abort (card, old_req); -mmc_blk_rw_try_restart (mq, new_req); +mmc_blk_rw_try_restart (mq, new_req, mqrq_cur);return ; }if (!req_pending) { -mmc_blk_rw_try_restart (mq, new_req); +mmc_blk_rw_try_restart (mq, new_req, mqrq_cur);return ; }break ;
@@ -1724,7 +1726,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)if (!mmc_blk_reset (md, card->host, type))break ;mmc_blk_rw_cmd_abort (card, old_req); -mmc_blk_rw_try_restart (mq, new_req); +mmc_blk_rw_try_restart (mq, new_req, mqrq_cur);return ;case MMC_BLK_DATA_ERR : {int err;
@@ -1734,7 +1736,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)break ;if (err == -ENODEV ) {mmc_blk_rw_cmd_abort (card, old_req); -mmc_blk_rw_try_restart (mq, new_req); +mmc_blk_rw_try_restart (mq, new_req, mqrq_cur);return ; }/* Fall through */
@@ -1755,19 +1757,19 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) req_pending =blk_end_request (old_req, -EIO , brq->data.blksz);if (!req_pending) { -mmc_blk_rw_try_restart (mq, new_req); +mmc_blk_rw_try_restart (mq, new_req, mqrq_cur);return ; }break ;case MMC_BLK_NOMEDIUM :mmc_blk_rw_cmd_abort (card, old_req); -mmc_blk_rw_try_restart (mq, new_req); +mmc_blk_rw_try_restart (mq, new_req, mqrq_cur);return ;default :pr_err ("%s: Unhandled return value (%d)" , old_req->rq_disk->disk_name, status);mmc_blk_rw_cmd_abort (card, old_req); -mmc_blk_rw_try_restart (mq, new_req); +mmc_blk_rw_try_restart (mq, new_req, mqrq_cur);return ; }
Signature · 1 line
1.9.1
Re: [PATCH RFC 01/39] mmc: block: Use local var for mqrq_cur
Quoted 4 lines · Adrian Hunter
A subsequent patch will remove '
mq->mqrq_cur'. Prepare for that by assigning it to a local variable.Signed-off-by Adrian Hunter <[email protected]>
My patch series also totally kill off mq->mqrq_cur and prev instead using a pool (with queue depth items) of pre-allocated struct mmc_queue_req, see "mmc: queue: get/put struct mmc_queue_req"
So I guess we agree that getting rid of the prev/cur thing is something we can agree to do as a first step?
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 2/39 mmc: queue: Share mmc request array between partitions
In reply to Adrian HuntereMMC can have multiple internal partitions that are represented as separate disks / queues. However switching between partitions is only done when the queue is empty. Consequently the array of mmc requests that are queued can be shared between partitions saving memory.
Keep a pointer to the mmc request queue on the card, and use that instead of allocating a new one for each partition.
--- drivers/mmc/core/block.c | 11 ++- drivers/mmc/core/queue.c | 235 ++++++++++++++++++++++++++++------------------- drivers/mmc/core/queue.h | 2 + include/linux/mmc/card.h | 5 + 4 files changed, 156 insertions(+), 97 deletions(-)
drivers/mmc/core/block.c +10 -1
@@ -2187,6 +2187,7 @@ static int mmc_blk_probe(struct mmc_card *card) {struct mmc_blk_data *md, *part_md;char cap_str[10 ]; +int ret;/* * Check that the card supports the command class(es) we need.
@@ -2196,9 +2197,15 @@ static int mmc_blk_probe(struct mmc_card *card)mmc_fixup_device (card, blk_fixups); + ret =mmc_queue_alloc_shared_queue (card); +if (ret) +return ret; + md =mmc_blk_alloc (card); -if (IS_ERR (md)) +if (IS_ERR (md)) { +mmc_queue_free_shared_queue (card);return PTR_ERR (md); + }string_get_size ((u64 )get_capacity (md->disk),512 ,STRING_UNITS_2 , cap_str,sizeof (cap_str));
@@ -2236,6 +2243,7 @@ static int mmc_blk_probe(struct mmc_card *card) out:mmc_blk_remove_parts (card, md);mmc_blk_remove_req (md); +mmc_queue_free_shared_queue (card);return 0 ; }
@@ -2253,6 +2261,7 @@ static void mmc_blk_remove(struct mmc_card *card)pm_runtime_put_noidle (&card->dev);mmc_blk_remove_req (md);dev_set_drvdata (&card->dev,NULL ); +mmc_queue_free_shared_queue (card); }static int _mmc_blk_suspend (struct mmc_card *card)
drivers/mmc/core/queue.c +139 -96
319 lines not on this page · raw message
drivers/mmc/core/queue.h +2 -0
@@ -51,6 +51,8 @@ struct mmc_queue {int qdepth; }; +extern int mmc_queue_alloc_shared_queue (struct mmc_card *card); +extern void mmc_queue_free_shared_queue (struct mmc_card *card);extern int mmc_init_queue (struct mmc_queue *,struct mmc_card *,spinlock_t *,const char *);extern void mmc_cleanup_queue (struct mmc_queue *);
include/linux/mmc/card.h +5 -0
@@ -208,6 +208,7 @@ struct sdio_cis {struct mmc_host ;struct sdio_func ;struct sdio_func_tuple ; +struct mmc_queue_req ;#define SDIO_MAX_FUNCS 7
@@ -300,6 +301,10 @@ struct mmc_card {struct dentry *debugfs_root;struct mmc_part part[MMC_NUM_PHY_PARTITION ];/* physical partitions */ unsigned int nr_parts; + +struct mmc_queue_req *mqrq;/* Shared queue structure */ +unsigned int bouncesz;/* Bounce buffer size */ +int qdepth;/* Shared queue depth */ };static inline bool mmc_large_sector (struct mmc_card *card)
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 3/39 mmc: block: Introduce queue semantics
In reply to Adrian HunterChange from viewing the requests in progress as 'current' and 'previous', to viewing them as a queue. The current request is allocated to the first free slot. The presence of incomplete requests is determined from the count (mq->qcnt) of entries in the queue. Non-read-write requests (i.e. discards and flushes) are not added to the queue at all and require no special handling. Also no special handling is needed for the MMC_BLK_NEW_REQUEST case.
As well as allowing an arbitrarily sized queue, the queue thread function is significantly simpler.
--- drivers/mmc/core/block.c | 42 ++++++++++++++++----------- drivers/mmc/core/queue.c | 74 ++++++++++++++++++++++++++++++------------------ drivers/mmc/core/queue.h | 10 +++++-- 3 files changed, 79 insertions(+), 47 deletions(-)
drivers/mmc/core/block.c +25 -17
@@ -134,6 +134,13 @@ static inline int mmc_blk_part_switch(struct mmc_card *card, struct mmc_blk_data *md);static int get_card_status (struct mmc_card *card,u32 *status,int retries); +static void mmc_blk_requeue (struct request_queue *q,struct request *req) +{ +spin_lock_irq (q->queue_lock); +blk_requeue_request (q, req); +spin_unlock_irq (q->queue_lock); +} +static struct mmc_blk_data *mmc_blk_get (struct gendisk *disk) {struct mmc_blk_data *md;
@@ -1631,14 +1638,23 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)struct mmc_blk_request *brq;int disable_multi =0 , retry =0 , type, retune_retry_done =0 ;enum mmc_blk_status status; -struct mmc_queue_req *mqrq_cur = mq->mqrq_cur; +struct mmc_queue_req *mqrq_cur =NULL ;struct mmc_queue_req *mq_rq;struct request *old_req;struct mmc_async_req *new_areq;struct mmc_async_req *old_areq;bool req_pending = true; -if (!new_req && !mq->mqrq_prev->req) +if (new_req) { + mqrq_cur =mmc_queue_req_find (mq, new_req); +if (!mqrq_cur) { +WARN_ON (1 ); +mmc_blk_requeue (mq->queue, new_req); + new_req =NULL ; + } + } + +if (!mq->qcnt)return ; do {
@@ -1667,8 +1683,6 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)* and there is nothing more to do until it is * complete. */ -if (status ==MMC_BLK_NEW_REQUEST ) - mq->new_request = true;return ; }
@@ -1785,6 +1799,8 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) mq_rq->brq.retune_retry_done = retune_retry_done; } }while (req_pending); + +mmc_queue_req_free (mq, mq_rq); }void mmc_blk_issue_rq (struct mmc_queue *mq,struct request *req)
@@ -1792,9 +1808,8 @@ void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)int ret;struct mmc_blk_data *md = mq->blkdata;struct mmc_card *card = md->queue.card; -bool req_is_special =mmc_req_is_special (req); -if (req && !mq->mqrq_prev->req) +if (req && !mq->qcnt)/* claim host only for the first request */ mmc_get_card (card);
@@ -1806,20 +1821,19 @@ void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) goto out; } - mq->new_request = false;if (req &&req_op (req) ==REQ_OP_DISCARD ) {/* complete ongoing async transfer before issuing discard */ -if (card->host->areq) +if (mq->qcnt)mmc_blk_issue_rw_rq (mq,NULL );mmc_blk_issue_discard_rq (mq, req); }else if (req &&req_op (req) ==REQ_OP_SECURE_ERASE ) {/* complete ongoing async transfer before issuing secure erase*/ -if (card->host->areq) +if (mq->qcnt)mmc_blk_issue_rw_rq (mq,NULL );mmc_blk_issue_secdiscard_rq (mq, req); }else if (req &&req_op (req) ==REQ_OP_FLUSH ) {/* complete ongoing async transfer before issuing flush */ -if (card->host->areq) +if (mq->qcnt)mmc_blk_issue_rw_rq (mq,NULL );mmc_blk_issue_flush (mq, req); }else {
@@ -1827,13 +1841,7 @@ void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) } out: -if ((!req && !mq->new_request) || req_is_special) -/* -* Release host when there are no more requests -* and after special request(discard, flush) is done. -* In case sepecial request, there is no reentry to -* the 'mmc_blk_issue_rq' with 'mqrq_prev->req'. -*/ +if (!mq->qcnt)mmc_put_card (card); }
drivers/mmc/core/queue.c +47 -27
119 lines not on this page · raw message
drivers/mmc/core/queue.h +7 -3
@@ -34,21 +34,21 @@ struct mmc_queue_req {struct scatterlist *bounce_sg;unsigned int bounce_sg_len;struct mmc_async_req areq; +int task_id; };struct mmc_queue {struct mmc_card *card;struct task_struct *thread;struct semaphore thread_sem; -bool new_request;bool suspended;bool asleep;struct mmc_blk_data *blkdata;struct request_queue *queue;struct mmc_queue_req *mqrq; -struct mmc_queue_req *mqrq_cur; -struct mmc_queue_req *mqrq_prev;int qdepth; +int qcnt; +unsigned long qslots; };extern int mmc_queue_alloc_shared_queue (struct mmc_card *card);
@@ -66,4 +66,8 @@ extern unsigned int mmc_queue_map_sg(struct mmc_queue *,extern int mmc_access_rpmb (struct mmc_queue *); +extern struct mmc_queue_req *mmc_queue_req_find (struct mmc_queue *, +struct request *); +extern void mmc_queue_req_free (struct mmc_queue *,struct mmc_queue_req *); +#endif
Signature · 1 line
1.9.1
Re: [PATCH RFC 03/39] mmc: block: Introduce queue semantics
Quoted 8 lines · Adrian Hunter
Change from viewing the requests in progress as 'current' and 'previous', to viewing them as a queue. The current request is allocated to the first free slot. The presence of incomplete requests is determined from the count (
mq->qcnt) of entries in the queue. Non-read-write requests (i.e. discards and flushes) are not added to the queue at all and require no special handling. Also no special handling is needed for theMMC_BLK_NEW_REQUESTcase.
Quoted 4 lines
As well as allowing an arbitrarily sized queue, the queue thread function is significantly simpler.
Signed-off-by Adrian Hunter <[email protected]>
This patch appears to be doing the same thing as my patch "mmc: queue: get/put struct mmc_queue_req"
I just happen to feel that mmc_queue_req_get() vs mmc_queue_req_put() is a more intuitive naming. If I wanted to be overspecific I would say "mmc_queue_req_pool_get()" and "mmc_queue_req_pool_put()".
On top of that, this patch adds the task_id and qcount business to see if things are complete. This is closely related to the mechanism of a polling loop that my patch set is getting us rid of: I stop issueing NULL requests altogether and this way we get rid of a big chunk of the problems you are addressing here, like this:
Quoted 3 lines
drivers/mmc/core/queue.c +1
-1-if (mq->mqrq_prev->req) +if (mq->qcnt) cntx->is_waiting_last_req = true;
(...)
drivers/mmc/core/queue.c static int mmc_queue_thread(void *d) · line 111
Quoted 4 lines
drivers/mmc/core/queue.c +1
-3-if (req || mq->mqrq_prev->req) { -bool req_is_special =mmc_req_is_special (req); - +if (req || mq->qcnt) {
As you will see, I take it further, the above will become just:
if (req).
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 4/39 mmc: core: Do not prepare a new request twice
In reply to Adrian Huntermmc_start_req() assumes it is never called with the new request already prepared. That is true if the queue consists of only 2 requests, but is not true for a longer queue. e.g. mmc_start_req() has a current and previous request but still exits to queue a new request if the queue size is greater than 2. In that case, when mmc_start_req() is called again, the current request will have been prepared already. Fix by flagging if the request has been prepared.
That also means ensuring that struct mmc_async_req is always initialized to zero, which wasn't the case in mmc_test.
--- drivers/mmc/core/core.c | 12 +++++++++--- drivers/mmc/core/mmc_test.c | 8 ++++---- include/linux/mmc/host.h | 1 + 3 files changed, 14 insertions(+), 7 deletions(-)
drivers/mmc/core/core.c +9 -3
@@ -686,8 +686,10 @@ struct mmc_async_req *mmc_start_areq(struct mmc_host *host,struct mmc_async_req *data = host->areq;/* Prepare a new request */ -if (areq) +if (areq && !areq->pre_req_done) { + areq->pre_req_done = true;mmc_pre_req (host, areq->mrq); + }/* Finalize previous request */ status =mmc_finalize_areq (host);
@@ -704,12 +706,16 @@ struct mmc_async_req *mmc_start_areq(struct mmc_host *host, start_err =__mmc_start_data_req (host, areq->mrq);/* Postprocess the old request at this point */ -if (host->areq) +if (host->areq) { + host->areq->pre_req_done = false;mmc_post_req (host, host->areq->mrq,0 ); + }/* Cancel a prepared request if it was not started. */ -if ((status !=MMC_BLK_SUCCESS || start_err) && areq) +if ((status !=MMC_BLK_SUCCESS || start_err) && areq) { + areq->pre_req_done = false;mmc_post_req (host, areq->mrq, -EINVAL ); + }if (status !=MMC_BLK_SUCCESS ) host->areq =NULL ;
drivers/mmc/core/mmc_test.c +4 -4
@@ -831,7 +831,10 @@ static int mmc_test_nonblock_transfer(struct mmc_test_card *test,struct mmc_command stop2;struct mmc_data data2; -struct mmc_test_async_req test_areq[2 ]; +struct mmc_test_async_req test_areq[2 ] = { + { .test = test }, + { .test = test }, + };struct mmc_async_req *done_areq;struct mmc_async_req *cur_areq = &test_areq[0 ].areq;struct mmc_async_req *other_areq = &test_areq[1 ].areq;
@@ -839,9 +842,6 @@ static int mmc_test_nonblock_transfer(struct mmc_test_card *test,int i;int ret =RESULT_OK ; - test_areq[0 ].test = test; - test_areq[1 ].test = test; -mmc_test_nonblock_reset (&mrq1, &cmd1, &stop1, &data1);mmc_test_nonblock_reset (&mrq2, &cmd2, &stop2, &data2);
include/linux/mmc/host.h +1 -0
@@ -168,6 +168,7 @@ struct mmc_async_req {* Returns 0 if success otherwise non zero. */ enum mmc_blk_status (*err_check)(struct mmc_card *,struct mmc_async_req *); +bool pre_req_done; };/**
Signature · 1 line
1.9.1
Re: [PATCH RFC 04/39] mmc: core: Do not prepare a new request twice
Quoted 8 lines · Adrian Hunter
mmc_start_req()assumes it is never called with the new request already prepared. That is true if the queue consists of only 2 requests, but is not true for a longer queue. e.g.mmc_start_req()has a current and previous request but still exits to queue a new request if the queue size is greater than 2. In that case, whenmmc_start_req()is called again, the current request will have been prepared already. Fix by flagging if the request has been prepared.
Quoted 5 lines
That also means ensuring that struct
mmc_async_reqis always initialized to zero, which wasn't the case inmmc_test.Signed-off-by Adrian Hunter <[email protected]>Reviewed-by Harjani Ritesh <[email protected]>
I disagree with this patch, because it makes things even more complex, with .pre_req_done:
Quoted 2 lines
drivers/mmc/core/core.c +2
-0+if (areq && !areq->pre_req_done) { + areq->pre_req_done = true;
(...)
Quoted 2 lines
drivers/mmc/core/core.c +2
-0+if (host->areq) { + host->areq->pre_req_done = false;
(...)
drivers/mmc/core/core.c struct mmc_async_req { · line 168
Quoted 4 lines
drivers/mmc/core/core.c +3
-0+if ((status !=MMC_BLK_SUCCESS || start_err) && areq) { + areq->pre_req_done = false;@@ -168,6 +168,7 @@ struct mmc_async_req { +bool pre_req_done;
We already have a crazy amount of states, which is something I try to address in my patch set where I kill off the context and instead model things in a different way:
Today what happens is that we call mmc_pre_req(), wait for the previous request to complete, get the status, and if it happens to be bad, we call mmc_post_req() and return back to the block queue.
But why do we do that? Why are we not just leaving the request prepared? After all it is just a cache flusg that happens in the mmc_pre_req()... so you are addressing that in the patch, which is nice in a way.
But in my patch set, we get rid of the whole problem, because I just redefine things by introducing a completion in the areq. When that completion is complete, we can always issue a new request, because that completion is not done until all retry and trying with single writes and error handling etc is already done.
What I don't like about this is that it takes the dataflow and states that I'm trying to simplify by removing the NULL flushing, and makes it even more complex with yet another state.
I haven't read all patches yet, but I feel it is better to do command queueing on top of my patches, that is, except for the last one that switch to using blk-mq - it's just an RFC.
Maybe I change my mind when I've read it all through, but I generally feel I simplify the data flow, while this complicates the data flow, but I admit that that position is a bit subjective.
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 5/39 mmc: mmc: Add functions to enable / disable the Command Queue
In reply to Adrian HunterAdd helper functions to enable or disable the Command Queue.
--- Documentation/mmc/mmc-dev-attrs.txt | 1 + drivers/mmc/core/mmc.c | 2 ++ drivers/mmc/core/mmc_ops.c | 28 ++++++++++++++++++++++++++++ drivers/mmc/core/mmc_ops.h | 2 ++ include/linux/mmc/card.h | 1 + 5 files changed, 34 insertions(+)
Documentation/mmc/mmc-dev-attrs.txt +1 -0
@@ -30,6 +30,7 @@ All attributes are read-only. rel_sectors Reliable write sector count ocr Operation Conditions Register dsr Driver Stage Register + cmdq_en Command Queue enabled: 1 => enabled, 0 => not enabled Note on Erase Size and Preferred Erase Size:
drivers/mmc/core/mmc.c +2 -0
@@ -800,6 +800,7 @@ static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)MMC_DEV_ATTR (raw_rpmb_size_mult,"%#x\n" , card->ext_csd.raw_rpmb_size_mult);MMC_DEV_ATTR (rel_sectors,"%#x\n" , card->ext_csd.rel_sectors);MMC_DEV_ATTR (ocr,"%08x\n" , card->ocr); +MMC_DEV_ATTR (cmdq_en,"%d\n" , card->ext_csd.cmdq_en); static ssize_t mmc_fwrev_show(struct device *dev, struct device_attribute *attr,
@@ -855,6 +856,7 @@ static ssize_t mmc_dsr_show(struct device *dev, &dev_attr_rel_sectors.attr, &dev_attr_ocr.attr, &dev_attr_dsr.attr, + &dev_attr_cmdq_en.attr,NULL , };ATTRIBUTE_GROUPS (mmc_std);
drivers/mmc/core/mmc_ops.c +28 -0
@@ -838,3 +838,31 @@ int mmc_can_ext_csd(struct mmc_card *card) {return (card && card->csd.mmca_vsn >CSD_SPEC_VER_3 ); } + +static int mmc_cmdq_switch (struct mmc_card *card,bool enable) +{ +u8 val = enable ?EXT_CSD_CMDQ_MODE_ENABLED :0 ; +int err; + +if (!card->ext_csd.cmdq_support) +return -EOPNOTSUPP ; + + err =mmc_switch (card,EXT_CSD_CMD_SET_NORMAL ,EXT_CSD_CMDQ_MODE_EN , + val, card->ext_csd.generic_cmd6_time); +if (!err) + card->ext_csd.cmdq_en = enable; + +return err; +} + +int mmc_cmdq_enable (struct mmc_card *card) +{ +return mmc_cmdq_switch (card, true); +} +EXPORT_SYMBOL_GPL (mmc_cmdq_enable); + +int mmc_cmdq_disable (struct mmc_card *card) +{ +return mmc_cmdq_switch (card, false); +} +EXPORT_SYMBOL_GPL (mmc_cmdq_disable);
drivers/mmc/core/mmc_ops.h +2 -0
@@ -46,6 +46,8 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,void mmc_start_bkops (struct mmc_card *card,bool from_exception);int mmc_can_reset (struct mmc_card *card);int mmc_flush_cache (struct mmc_card *card); +int mmc_cmdq_enable (struct mmc_card *card); +int mmc_cmdq_disable (struct mmc_card *card);#endif
include/linux/mmc/card.h +1 -0
@@ -89,6 +89,7 @@ struct mmc_ext_csd {unsigned int boot_ro_lock;/* ro lock support */ bool boot_ro_lockable;bool ffu_capable;/* Firmware upgrade support */ +bool cmdq_en;/* Command Queue enabled */ bool cmdq_support;/* Command Queue supported */ unsigned int cmdq_depth;/* Command Queue depth */ #define MMC_FIRMWARE_LEN 8
Signature · 1 line
1.9.1
Re: [PATCH RFC 05/39] mmc: mmc: Add functions to enable / disable the Command Queue
Quoted 3 lines · Adrian Hunter
Add helper functions to enable or disable the Command Queue.
Signed-off-by Adrian Hunter <[email protected]>
I think I asked this before but why?
If the card has this feature, certainly we should just exploit it?
If some card has a problem with it, I guess it is broken and should simply have this operation blacklisted.
Yours,
Linus Walleij
Re: [PATCH RFC 05/39] mmc: mmc: Add functions to enable / disable the Command Queue
Quoted 7 lines · Linus Walleij
Quoted 3 lines · Adrian Hunter
Add helper functions to enable or disable the Command Queue.
Signed-off-by Adrian Hunter <[email protected]>I think I asked this before but why?
There are certain other requests, like for RPMB, which requires CMDQ to be "temporary" disabled.
Seems like a little more information the change log would be appreciated to understand why we need to add these functions.
Quoted 8 lines
If the card has this feature, certainly we should just exploit it?
If some card has a problem with it, I guess it is broken and should simply have this operation blacklisted.
Yours,
Linus Walleij
Kind regards
Uffe
Re: [PATCH RFC 05/39] mmc: mmc: Add functions to enable / disable the Command Queue
Quoted 11 lines · Ulf Hansson
Quoted 7 lines · Linus Walleij
Quoted 3 lines · Adrian Hunter
Add helper functions to enable or disable the Command Queue.
Signed-off-by Adrian Hunter <[email protected]>I think I asked this before but why?
There are certain other requests, like for RPMB, which requires CMDQ to be "temporary" disabled.
Ah my comment is stupid.
I specifically want to know why we should be able to disable it from sysfs.
I don't see the point in that, just giving userspace another gun to shoot itself in the foot.
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 6/39 mmc: mmc_test: Disable Command Queue while mmc_test is used
In reply to Adrian HunterNormal read and write commands may not be used while the command queue is enabled. Disable the Command Queue when mmc_test is probed and re-enable it when it is removed.
--- drivers/mmc/core/mmc.c | 7 +++++++ drivers/mmc/core/mmc_test.c | 14 ++++++++++++++ include/linux/mmc/card.h | 2 ++ 3 files changed, 23 insertions(+)
drivers/mmc/core/mmc.c +7 -0
@@ -1800,6 +1800,13 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, }/* +* In some cases (e.g. RPMB or mmc_test), the Command Queue must be +* disabled for a time, so a flag is needed to indicate to re-enable the +* Command Queue. +*/ + card->reenable_cmdq = card->ext_csd.cmdq_en; + +/* * The mandatory minimum values are defined for packed command. * read: 5, write: 3 */
drivers/mmc/core/mmc_test.c +14 -0
@@ -26,6 +26,7 @@#include "card.h" #include "host.h" #include "bus.h" +#include "mmc_ops.h" #define RESULT_OK 0#define RESULT_FAIL 1
@@ -3264,6 +3265,14 @@ static int mmc_test_probe(struct mmc_card *card)if (ret)return ret; +if (card->ext_csd.cmdq_en) { +mmc_claim_host (card->host); + ret =mmc_cmdq_disable (card); +mmc_release_host (card->host); +if (ret) +return ret; + } +dev_info (&card->dev,"Card claimed for testing.\n" );return 0 ;
@@ -3271,6 +3280,11 @@ static int mmc_test_probe(struct mmc_card *card)static void mmc_test_remove (struct mmc_card *card) { +if (card->reenable_cmdq) { +mmc_claim_host (card->host); +mmc_cmdq_enable (card); +mmc_release_host (card->host); + }mmc_test_free_result (card);mmc_test_free_dbgfs_file (card); }
include/linux/mmc/card.h +2 -0
@@ -269,6 +269,8 @@ struct mmc_card {#define MMC_QUIRK_TRIM_BROKEN (1<<12)/* Skip trim */ #define MMC_QUIRK_BROKEN_HPI (1<<13)/* Disable broken HPI support */ +bool reenable_cmdq;/* Re-enable Command Queue */ +unsigned int erase_size;/* erase size in sectors */ unsigned int erase_shift;/* if erase unit is power 2 */ unsigned int pref_erase;/* in sectors */
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 7/39 mmc: block: Disable Command Queue while RPMB is used
In reply to Adrian HunterRPMB does not allow Command Queue commands. Disable and re-enable the Command Queue when switching.
Note that the driver only switches partitions when the queue is empty.
--- drivers/mmc/core/block.c | 46 ++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 38 insertions(+), 8 deletions(-)
drivers/mmc/core/block.c +38 -8
@@ -733,10 +733,41 @@ static int mmc_blk_compat_ioctl(struct block_device *bdev, fmode_t mode,#endif }; +static int mmc_blk_part_switch_pre (struct mmc_card *card, +unsigned int part_type) +{ +int ret =0 ; + +if (part_type ==EXT_CSD_PART_CONFIG_ACC_RPMB ) { +if (card->ext_csd.cmdq_en) { + ret =mmc_cmdq_disable (card); +if (ret) +return ret; + } +mmc_retune_pause (card->host); + } + +return ret; +} + +static int mmc_blk_part_switch_post (struct mmc_card *card, +unsigned int part_type) +{ +int ret =0 ; + +if (part_type ==EXT_CSD_PART_CONFIG_ACC_RPMB ) { +mmc_retune_unpause (card->host); +if (card->reenable_cmdq && !card->ext_csd.cmdq_en) + ret =mmc_cmdq_enable (card); + } + +return ret; +} +static inline int mmc_blk_part_switch (struct mmc_card *card,struct mmc_blk_data *md) { -int ret; +int ret =0 ;struct mmc_blk_data *main_md =dev_get_drvdata (&card->dev);if (main_md->part_curr == md->part_type)
@@ -745,8 +776,9 @@ static inline int mmc_blk_part_switch(struct mmc_card *card,if (mmc_card_mmc (card)) {u8 part_config = card->ext_csd.part_config; -if (md->part_type ==EXT_CSD_PART_CONFIG_ACC_RPMB ) -mmc_retune_pause (card->host); + ret =mmc_blk_part_switch_pre (card, md->part_type); +if (ret) +return ret; part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK ; part_config |= md->part_type;
@@ -755,19 +787,17 @@ static inline int mmc_blk_part_switch(struct mmc_card *card,EXT_CSD_PART_CONFIG , part_config, card->ext_csd.part_time);if (ret) { -if (md->part_type ==EXT_CSD_PART_CONFIG_ACC_RPMB ) -mmc_retune_unpause (card->host); +mmc_blk_part_switch_post (card, md->part_type);return ret; } card->ext_csd.part_config = part_config; -if (main_md->part_curr ==EXT_CSD_PART_CONFIG_ACC_RPMB ) -mmc_retune_unpause (card->host); + ret =mmc_blk_part_switch_post (card, main_md->part_curr); } main_md->part_curr = md->part_type; -return 0 ; +return ret; }static int mmc_sd_num_wr_blocks (struct mmc_card *card,u32 *written_blocks)
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 8/39 mmc: core: Export mmc_retune_hold() and mmc_retune_release()
In reply to Adrian HunterRe-tuning can only be done when the Command Queue is empty, when means holding and releasing re-tuning from the block driver, so export those functions.
--- drivers/mmc/core/host.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/mmc/core/host.c +2 -0
@@ -109,6 +109,7 @@ void mmc_retune_hold(struct mmc_host *host) host->retune_now =1 ; host->hold_retune +=1 ; } +EXPORT_SYMBOL (mmc_retune_hold);void mmc_retune_release (struct mmc_host *host) {
@@ -117,6 +118,7 @@ void mmc_retune_release(struct mmc_host *host)else WARN_ON (1 ); } +EXPORT_SYMBOL (mmc_retune_release);int mmc_retune (struct mmc_host *host) {
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 9/39 mmc: queue: Add a function to control wake-up on new requests
In reply to Adrian HunterAdd a function to control wake-up on new requests. This will enable Software Command Queuing to choose whether or not to queue new requests immediately or wait for the current task to complete.
--- drivers/mmc/core/queue.c | 16 ++++++++++++++++ drivers/mmc/core/queue.h | 2 ++ 2 files changed, 18 insertions(+)
drivers/mmc/core/queue.c +16 -0
@@ -97,6 +97,7 @@ static int mmc_queue_thread(void *d) cntx->is_waiting_last_req = false; cntx->is_new_req = false;if (!req) { + mq->is_new_req = false;/* * Dispatch queue is empty so set flags for * mmc_request_fn() to wake us up.
@@ -147,6 +148,8 @@ static void mmc_request_fn(struct request_queue *q)return ; } + mq->is_new_req = true; + cntx = &mq->card->host->context_info;if (cntx->is_waiting_last_req) {
@@ -158,6 +161,19 @@ static void mmc_request_fn(struct request_queue *q)wake_up_process (mq->thread); } +void mmc_queue_set_wake (struct mmc_queue *mq,bool wake_me) +{ +struct mmc_context_info *cntx = &mq->card->host->context_info; +struct request_queue *q = mq->queue; + +if (cntx->is_waiting_last_req != wake_me) { +spin_lock_irq (q->queue_lock); + cntx->is_waiting_last_req = wake_me; + cntx->is_new_req = wake_me && mq->is_new_req; +spin_unlock_irq (q->queue_lock); + } +} +static struct scatterlist *mmc_alloc_sg (int sg_len) {struct scatterlist *sg;
drivers/mmc/core/queue.h +2 -0
@@ -43,6 +43,7 @@ struct mmc_queue {struct semaphore thread_sem;bool suspended;bool asleep; +bool is_new_req;struct mmc_blk_data *blkdata;struct request_queue *queue;struct mmc_queue_req *mqrq;
@@ -69,5 +70,6 @@ extern unsigned int mmc_queue_map_sg(struct mmc_queue *,extern struct mmc_queue_req *mmc_queue_req_find (struct mmc_queue *,struct request *);extern void mmc_queue_req_free (struct mmc_queue *,struct mmc_queue_req *); +extern void mmc_queue_set_wake (struct mmc_queue *,bool );#endif
Signature · 1 line
1.9.1
Re: [PATCH RFC 09/39] mmc: queue: Add a function to control wake-up on new requests
Quoted 5 lines · Adrian Hunter
Add a function to control wake-up on new requests. This will enable Software Command Queuing to choose whether or not to queue new requests immediately or wait for the current task to complete.
Signed-off-by Adrian Hunter <[email protected]>
I think my patch set killed off the context and this whole thing "just works" instead of needing more states and hacks like this.
The proliferation of states is reaching a all time high here:
+ if (cntx->is_waiting_last_req != wake_me) {
+ spin_lock_irq(q->queue_lock); + cntx->is_waiting_last_req = wake_me; + cntx->is_new_req = wake_me && mq->is_new_req;
(...)
@@ -43,6 +43,7 @@ struct mmc_queue {
(...)
+ bool is_new_req;
Now there is a is_new_req in the context AND an identically named state variable in struct mmc_queue, and when reading the code I suspect a reader would like to know the difference between the two .is_new_req variables, one in the state of the host and one in the state of the queue.
This is a cognitive nightmare, sorry. At least this would have to have more specific names.
I think all these states come from the polling loop construction and this constant spinning around and checking for errors, doing and undoing the pre/post/bounce stuff, and compulsively flushing the pipeline with NULL and so on. I was trying to
get rid of that stuff, but this is expanding it instead.
Hm, maybe I get a bit on the complainy side, sorry if so...
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 10/39 mmc: block: Change mmc_apply_rel_rw() to get block address from the request
In reply to Adrian Huntermmc_apply_rel_rw() will be used by Software Command Queuing also. In that case the command argument is not the block address so change mmc_apply_rel_rw() to get block address from the request.
--- drivers/mmc/core/block.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/mmc/core/block.c +1 -1
@@ -1314,7 +1314,7 @@ static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq, {if (!(card->ext_csd.rel_param &EXT_CSD_WR_REL_PARAM_EN )) {/* Legacy mode imposes restrictions on transfers. */ -if (!IS_ALIGNED (brq->cmd.arg, card->ext_csd.rel_sectors)) +if (!IS_ALIGNED (blk_rq_pos (req), card->ext_csd.rel_sectors)) brq->data.blocks =1 ;if (brq->data.blocks > card->ext_csd.rel_sectors)
Signature · 1 line
1.9.1
Re: [PATCH RFC 10/39] mmc: block: Change mmc_apply_rel_rw() to get block address from the request
Quoted 5 lines · Adrian Hunter
mmc_apply_rel_rw()will be used by Software Command Queuing also. In that case the command argument is not the block address so changemmc_apply_rel_rw()to get block address from the request.Signed-off-by Adrian Hunter <[email protected]>
This looks right. Isn't this something we can just apply right off?
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 11/39 mmc: block: Factor out data preparation
In reply to Adrian HunterFactor out data preparation into a separate function mmc_blk_data_prep() which can be re-used for command queuing.
--- drivers/mmc/core/block.c | 151 +++++++++++++++++++++++++---------------------- 1 file changed, 82 insertions(+), 69 deletions(-)
drivers/mmc/core/block.c +82 -69
@@ -1438,36 +1438,39 @@ static enum mmc_blk_status mmc_blk_err_check(struct mmc_card *card,return MMC_BLK_SUCCESS ; } -static void mmc_blk_rw_rq_prep (struct mmc_queue_req *mqrq, -struct mmc_card *card, -int disable_multi, -struct mmc_queue *mq) +static void mmc_blk_data_prep (struct mmc_queue *mq,struct mmc_queue_req *mqrq, +int disable_multi,bool *do_rel_wr, +bool *do_data_tag) { -u32 readcmd, writecmd; +struct mmc_blk_data *md = mq->blkdata; +struct mmc_card *card = md->queue.card;struct mmc_blk_request *brq = &mqrq->brq;struct request *req = mqrq->req; -struct mmc_blk_data *md = mq->blkdata; -bool do_data_tag;/* * Reliable writes are used to implement Forced Unit Access and * are supported only on MMCs. */ -bool do_rel_wr = (req->cmd_flags &REQ_FUA ) && - (rq_data_dir (req) ==WRITE ) && - (md->flags &MMC_BLK_REL_WR ); + *do_rel_wr = (req->cmd_flags &REQ_FUA ) && +rq_data_dir (req) ==WRITE && + (md->flags &MMC_BLK_REL_WR );memset (brq,0 ,sizeof (struct mmc_blk_request )); - brq->mrq.cmd = &brq->cmd; + brq->mrq.data = &brq->data; - brq->cmd.arg =blk_rq_pos (req); -if (!mmc_card_blockaddr (card)) - brq->cmd.arg <<=9 ; - brq->cmd.flags =MMC_RSP_SPI_R1 |MMC_RSP_R1 |MMC_CMD_ADTC ; - brq->data.blksz =512 ; brq->stop.opcode =MMC_STOP_TRANSMISSION ; brq->stop.arg =0 ; + +if (rq_data_dir (req) ==READ ) { + brq->data.flags =MMC_DATA_READ ; + brq->stop.flags =MMC_RSP_SPI_R1 |MMC_RSP_R1 |MMC_CMD_AC ; + }else { + brq->data.flags =MMC_DATA_WRITE ; + brq->stop.flags =MMC_RSP_SPI_R1B |MMC_RSP_R1B |MMC_CMD_AC ; + } + + brq->data.blksz =512 ; brq->data.blocks =blk_rq_sectors (req);/*
@@ -1498,6 +1501,68 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq, brq->data.blocks); } +if (*do_rel_wr) +mmc_apply_rel_rw (brq, card, req); + +/* +* Data tag is used only during writing meta data to speed +* up write and any subsequent read of this meta data +*/ + *do_data_tag = card->ext_csd.data_tag_unit_size && + (req->cmd_flags &REQ_META ) && + (rq_data_dir (req) ==WRITE ) && + ((brq->data.blocks * brq->data.blksz) >= + card->ext_csd.data_tag_unit_size); + +mmc_set_data_timeout (&brq->data, card); + + brq->data.sg = mqrq->sg; + brq->data.sg_len =mmc_queue_map_sg (mq, mqrq); + +/* +* Adjust the sg list so it is the same size as the +* request. +*/ +if (brq->data.blocks !=blk_rq_sectors (req)) { +int i, data_size = brq->data.blocks <<9 ; +struct scatterlist *sg; + +for_each_sg (brq->data.sg, sg, brq->data.sg_len, i) { + data_size -= sg->length; +if (data_size <=0 ) { + sg->length += data_size; + i++; +break ; + } + } + brq->data.sg_len = i; + } + + mqrq->areq.mrq = &brq->mrq; + +mmc_queue_bounce_pre (mqrq); +} + +static void mmc_blk_rw_rq_prep (struct mmc_queue_req *mqrq, +struct mmc_card *card, +int disable_multi, +struct mmc_queue *mq) +{ +u32 readcmd, writecmd; +struct mmc_blk_request *brq = &mqrq->brq; +struct request *req = mqrq->req; +struct mmc_blk_data *md = mq->blkdata; +bool do_rel_wr, do_data_tag; + +mmc_blk_data_prep (mq, mqrq, disable_multi, &do_rel_wr, &do_data_tag); + + brq->mrq.cmd = &brq->cmd; + + brq->cmd.arg =blk_rq_pos (req); +if (!mmc_card_blockaddr (card)) + brq->cmd.arg <<=9 ; + brq->cmd.flags =MMC_RSP_SPI_R1 |MMC_RSP_R1 |MMC_CMD_ADTC ; +if (brq->data.blocks >1 || do_rel_wr) {/* SPI multiblock writes terminate using a special * token, not a STOP_TRANSMISSION request.
@@ -1512,32 +1577,7 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq, readcmd =MMC_READ_SINGLE_BLOCK ; writecmd =MMC_WRITE_BLOCK ; } -if (rq_data_dir (req) ==READ ) { - brq->cmd.opcode = readcmd; - brq->data.flags =MMC_DATA_READ ; -if (brq->mrq.stop) - brq->stop.flags =MMC_RSP_SPI_R1 |MMC_RSP_R1 | -MMC_CMD_AC ; - }else { - brq->cmd.opcode = writecmd; - brq->data.flags =MMC_DATA_WRITE ; -if (brq->mrq.stop) - brq->stop.flags =MMC_RSP_SPI_R1B |MMC_RSP_R1B | -MMC_CMD_AC ; - } - -if (do_rel_wr) -mmc_apply_rel_rw (brq, card, req); - -/* -* Data tag is used only during writing meta data to speed -* up write and any subsequent read of this meta data -*/ - do_data_tag = (card->ext_csd.data_tag_unit_size) && - (req->cmd_flags &REQ_META ) && - (rq_data_dir (req) ==WRITE ) && - ((brq->data.blocks * brq->data.blksz) >= - card->ext_csd.data_tag_unit_size); + brq->cmd.opcode =rq_data_dir (req) ==READ ? readcmd : writecmd;/* * Pre-defined multi-block transfers are preferable to
@@ -1568,34 +1608,7 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq, brq->mrq.sbc = &brq->sbc; } -mmc_set_data_timeout (&brq->data, card); - - brq->data.sg = mqrq->sg; - brq->data.sg_len =mmc_queue_map_sg (mq, mqrq); - -/* -* Adjust the sg list so it is the same size as the -* request. -*/ -if (brq->data.blocks !=blk_rq_sectors (req)) { -int i, data_size = brq->data.blocks <<9 ; -struct scatterlist *sg; - -for_each_sg (brq->data.sg, sg, brq->data.sg_len, i) { - data_size -= sg->length; -if (data_size <=0 ) { - sg->length += data_size; - i++; -break ; - } - } - brq->data.sg_len = i; - } - - mqrq->areq.mrq = &brq->mrq; mqrq->areq.err_check = mmc_blk_err_check; - -mmc_queue_bounce_pre (mqrq); } static bool mmc_blk_rw_cmd_err(struct mmc_blk_data *md, struct mmc_card *card,
Signature · 1 line
1.9.1
Re: [PATCH RFC 11/39] mmc: block: Factor out data preparation
Quoted 4 lines · Adrian Hunter
Factor out data preparation into a separate function
mmc_blk_data_prep()which can be re-used for command queuing.Signed-off-by Adrian Hunter <[email protected]>
This patch is a good and valid refactoring as it stands, alone.
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 12/39 mmc: block: Add Software Command Queuing
In reply to Adrian HuntereMMC Command Queuing is a feature added in version 5.1. The card maintains a queue of up to 32 data transfers. Commands CMD44/CMD45 are sent to queue up transfers in advance, and then one of the transfers is selected to "execute" by CMD46/CMD47 at which point data transfer actually begins.
The advantage of command queuing is that the card can prepare for transfers in advance. That makes a big difference in the case of random reads because the card can start reading into its cache in advance.
A v5.1 host controller can manage the command queue itself, but it is also possible for software to manage the queue using an non-v5.1 host controller
- that is what Software Command Queuing is.
Refer to the JEDEC (http://www.jedec.org/) eMMC v5.1 Specification for more information about Command Queuing.
Two important aspects of Command Queuing that affect the implementation are:
- only read/write requests are queued
- the queue must be empty to send other commands, including re-tuning
To support Software Command Queuing a separate function is provided to issue read/write requests (i.e. mmc_swcmdq_issue_rw_rq()) and the mmc_blk_request structure amended to cater for additional commands CMD44 and CMD45. There is a separate function (mmc_swcmdq_prep()) to prepare the needed commands, but transfers are started by mmc_start_req() like normal.
mmc_swcmdq_issue_rw_rq() enqueues the new request and then executes tasks until the queue is empty or mmc_swcmdq_execute() asks for a new request. This puts mmc_swcmdq_execute() in control of the decision whether to queue more requests or wait for the active one.
Recovery is invoked if anything goes wrong. Recovery has 2 options:
1. Discard the queue and re-queue all requests. If that fails, fall back to option 2.
2. Reset and re-queue all requests. If that fails, error out all the requests.
In either case, re-tuning will be done if needed after the queue becomes empty because re-tuning is released at that point.
--- drivers/mmc/core/block.c | 525 ++++++++++++++++++++++++++++++++++++++++++++++- drivers/mmc/core/queue.c | 10 +- drivers/mmc/core/queue.h | 11 +- include/linux/mmc/core.h | 1 + 4 files changed, 544 insertions(+), 3 deletions(-)
drivers/mmc/core/block.c +524 -1
@@ -113,6 +113,7 @@ struct mmc_blk_data {#define MMC_BLK_WRITE BIT(1)#define MMC_BLK_DISCARD BIT(2)#define MMC_BLK_SECDISCARD BIT(3) +#define MMC_BLK_SWCMDQ BIT(4)/* * Only set in main mmc_blk_data associated
@@ -1674,7 +1675,518 @@ static void mmc_blk_rw_try_restart(struct mmc_queue *mq, struct request *req,mmc_start_areq (mq->card->host, &mqrq->areq,NULL ); } -static void mmc_blk_issue_rw_rq (struct mmc_queue *mq,struct request *new_req) +static enum mmc_blk_status mmc_swcmdq_err_check (struct mmc_card *card, +struct mmc_async_req *areq) +{ + struct mmc_queue_req *mqrq = container_of(areq, struct mmc_queue_req, + areq); +struct mmc_blk_request *brq = &mqrq->brq; +struct request *req = mqrq->req; +int err; + + err = brq->data.error; +/* In the case of data errors, send stop */ +if (err) +mmc_wait_for_cmd (card->host, &brq->stop,0 ); +else + err = brq->cmd.error; + +/* In the case of CRC errors when re-tuning is needed, retry */ +if (err == -EILSEQ && card->host->need_retune) +return MMC_BLK_RETRY ; + +/* For other errors abort */ +if (err) +return MMC_BLK_ABORT ; + +if (blk_rq_bytes (req) != brq->data.bytes_xfered) +return MMC_BLK_PARTIAL ; + +return MMC_BLK_SUCCESS ; +} + +static void mmc_swcmdq_prep (struct mmc_queue *mq,struct mmc_queue_req *mqrq) +{ +struct mmc_blk_request *brq = &mqrq->brq; +struct request *req = mqrq->req; +bool do_rel_wr, do_data_tag; + +mmc_blk_data_prep (mq, mqrq,0 , &do_rel_wr, &do_data_tag); + + brq->mrq.cmd = &brq->cmd; + brq->mrq.cap_cmd_during_tfr = true; + + brq->cmd.opcode =rq_data_dir (req) ==READ ?MMC_EXECUTE_READ_TASK : +MMC_EXECUTE_WRITE_TASK ; + brq->cmd.arg = mqrq->task_id <<16 ; + brq->cmd.flags =MMC_RSP_R1 |MMC_CMD_ADTC ; + + brq->cmd44.opcode =MMC_QUE_TASK_PARAMS ; + brq->cmd44.arg = brq->data.blocks | + (do_rel_wr ? (1 <<31 ) :0 ) | + ((rq_data_dir (req) ==READ ) ? (1 <<30 ) :0 ) | + (do_data_tag ? (1 <<29 ) :0 ) | + mqrq->task_id <<16 ; + brq->cmd44.flags =MMC_RSP_R1 |MMC_CMD_AC ; + + brq->cmd45.opcode =MMC_QUE_TASK_ADDR ; + brq->cmd45.arg =blk_rq_pos (req); + + mqrq->areq.err_check = mmc_swcmdq_err_check; +} + +static int mmc_swcmdq_blk_err (struct mmc_card *card,int err) +{ +/* Re-try after CRC errors when re-tuning is needed */ +if (err == -EILSEQ && card->host->need_retune) +return MMC_BLK_RETRY ; + +if (err) +return MMC_BLK_ABORT ; + +return 0 ; +} + +#define SWCMDQ_ENQUEUE_ERR ( \ + R1_OUT_OF_RANGE | \ + R1_ADDRESS_ERROR | \ + R1_BLOCK_LEN_ERROR | \ + R1_WP_VIOLATION | \ + R1_CC_ERROR | \ + R1_ERROR | \ + R1_COM_CRC_ERROR | \ + R1_ILLEGAL_COMMAND) + +static int __mmc_swcmdq_enqueue (struct mmc_queue *mq, +struct mmc_queue_req *mqrq) +{ +struct mmc_card *card = mq->card; +int err; + +mmc_swcmdq_prep (mq, mqrq); + + err =mmc_wait_for_cmd (card->host, &mqrq->brq.cmd44,0 ); +if (err) + goto out; + + err =mmc_wait_for_cmd (card->host, &mqrq->brq.cmd45,0 ); +if (err) + goto out; + +/* +* Don't assume the task is queued if there are any error bits set in +* the response. +*/ +if (mqrq->brq.cmd45.resp[0 ] &SWCMDQ_ENQUEUE_ERR ) +return MMC_BLK_ABORT ; +out: +return mmc_swcmdq_blk_err (card, err); +} + +static int mmc_swcmdq_enqueue (struct mmc_queue *mq,struct request *req) +{ +struct mmc_queue_req *mqrq; + + mqrq =mmc_queue_req_find (mq, req); +if (!mqrq) { +WARN_ON (1 ); +mmc_blk_requeue (mq->queue, req); +return 0 ; + } + +/* Need to hold re-tuning so long as the queue is not empty */ +if (mq->qcnt ==1 ) +mmc_retune_hold (mq->card->host); + +return __mmc_swcmdq_enqueue (mq, mqrq); +} + +static struct mmc_async_req *mmc_swcmdq_next (struct mmc_queue *mq) +{ +int i =__ffs (mq->qsr); + +__clear_bit (i, &mq->qsr); + +if (i >= mq->qdepth) +return NULL ; + +return &mq->mqrq[i].areq; +} + +static int mmc_get_qsr (struct mmc_card *card,u32 *qsr) +{ +struct mmc_command cmd = {0 }; +int err, retries =3 ; + + cmd.opcode =MMC_SEND_STATUS ; + cmd.arg = card->rca <<16 |1 <<15 ; + cmd.flags =MMC_RSP_R1 |MMC_CMD_AC ; + err =mmc_wait_for_cmd (card->host, &cmd, retries); +if (err) +return err; + + *qsr = cmd.resp[0 ]; + +return 0 ; +} + +static int mmc_await_qsr (struct mmc_card *card,u32 *qsr) +{ +unsigned long timeout; +u32 status =0 ; +int err; + + timeout = jiffies +msecs_to_jiffies (10 *1000 ); +while (!status) { + err =mmc_get_qsr (card, &status); +if (err) +return err; +if (time_after (jiffies, timeout)) { +pr_err ("%s: Card stuck with queued tasks\n" , +mmc_hostname (card->host)); +return -ETIMEDOUT ; + } + } + + *qsr = status; + +return 0 ; +} + +static int mmc_swcmdq_await_qsr (struct mmc_queue *mq,struct mmc_card *card, +bool wait) +{ +struct mmc_queue_req *mqrq; +u32 qsr; +int err; + +if (wait) + err =mmc_await_qsr (card, &qsr); +else + err =mmc_get_qsr (card, &qsr); +if (err) + goto out_err; + + mq->qsr = qsr; + +if (card->host->areq) { +/* +* The active request remains in the QSR until completed. Remove +* it so that mq->qsr only contains ones that are ready but not +* executed. +*/ + mqrq = container_of(card->host->areq, struct mmc_queue_req, + areq); +__clear_bit (mqrq->task_id, &mq->qsr); + } + +if (mq->qsr) + mq->qsr_err = false; +out_err: +if (err) { +/* Don't repeatedly retry if no progress is made */ +if (mq->qsr_err) +return MMC_BLK_ABORT ; + mq->qsr_err = true; + } + +return mmc_swcmdq_blk_err (card, err); +} + +static int mmc_swcmdq_execute (struct mmc_queue *mq,bool flush,bool requeuing, +bool new_req) +{ +struct mmc_card *card = mq->card; +struct mmc_async_req *next =NULL , *prev; +struct mmc_blk_request *brq; +struct mmc_queue_req *mqrq; +enum mmc_blk_status status; +struct request *req; +int active = card->host->areq ?1 :0 ; +int ret; + +if (mq->prepared_areq) { +/* +* A request that has been prepared before (i.e. passed to +* mmc_start_areq()) but not started because another new request +* turned up. +*/ + next = mq->prepared_areq; + }else if (requeuing) { +/* Just finish the active request */ + next =NULL ; + }else if (mq->qsr) { +/* Get the next task from the Queue Status Register */ + next =mmc_swcmdq_next (mq); + }else if (mq->qcnt > active) { +/* +* There are queued tasks so read the Queue Status Register to +* see if any are ready. Wait for a ready task only if there is +* no active request and no new request. +*/ + ret =mmc_swcmdq_await_qsr (mq, card, !active && !new_req); +if (ret) +return ret; +if (mq->qsr) + next =mmc_swcmdq_next (mq); + } + +if (next) { +/* +* Don't wake for a new request when waiting for the active +* request if there is another request ready to start. +*/ +if (active) +mmc_queue_set_wake (mq, false); + }else { +if (!active) +return 0 ; +/* +* Don't wake for a new request when flushing or the queue is +* full. +*/ +if (flush || mq->qcnt == mq->qdepth) +mmc_queue_set_wake (mq, false); +else +mmc_queue_set_wake (mq, true); + } + + prev =mmc_start_areq (card->host, next, &status); + +if (status ==MMC_BLK_NEW_REQUEST ) { + mq->prepared_areq = next; +return status; + } + + mq->prepared_areq =NULL ; + +if (!prev) +return 0 ; + + mqrq = container_of(prev, struct mmc_queue_req, areq); + brq = &mqrq->brq; + req = mqrq->req; + +mmc_queue_bounce_post (mqrq); + +switch (status) { +case MMC_BLK_SUCCESS : +case MMC_BLK_PARTIAL : +case MMC_BLK_SUCCESS_ERR : +mmc_blk_reset_success (mq->blkdata,MMC_BLK_SWCMDQ ); + ret =blk_end_request (req,0 , brq->data.bytes_xfered); +if (ret) { +if (!requeuing) +return __mmc_swcmdq_enqueue (mq, mqrq); +return 0 ; + } +break ; +case MMC_BLK_NEW_REQUEST : +return status; +default : +if (mqrq->retry_cnt++) { +blk_end_request_all (req, -EIO ); +break ; + } +return status; + } + +mmc_queue_req_free (mq, mqrq); + +/* Release re-tuning when queue is empty */ +if (!mq->qcnt) +mmc_retune_release (card->host); + +return 0 ; +} + +static enum mmc_blk_status mmc_swcmdq_requeue_check (struct mmc_card *card, +struct mmc_async_req *areq) +{ +enum mmc_blk_status ret =mmc_swcmdq_err_check (card, areq); + +/* +* In the case of success, prevent mmc_start_areq() from starting +* another request by returning MMC_BLK_SUCCESS_ERR. +*/ +return ret ==MMC_BLK_SUCCESS ?MMC_BLK_SUCCESS_ERR : ret; +} + +static int mmc_swcmdq_await_active (struct mmc_queue *mq) +{ +struct mmc_async_req *areq = mq->card->host->areq; +int err; + +if (!areq) +return 0 ; + + areq->err_check = mmc_swcmdq_requeue_check; + + err =mmc_swcmdq_execute (mq, true, true, false); + +/* The request will be requeued anyway, so ignore 'retry' */ +if (err ==MMC_BLK_RETRY ) + err =0 ; + +return err; +} + +static int mmc_swcmdq_discard_queue (struct mmc_queue *mq) +{ +struct mmc_command cmd = {0 }; + +if (!mq->qcnt) +return 0 ; + + mq->qsr =0 ; + + cmd.opcode =MMC_CMDQ_TASK_MGMT ; + cmd.arg =1 ;/* Discard entire queue */ + cmd.flags =MMC_RSP_R1B |MMC_CMD_AC ; +/* This is for recovery and the response is not needed, so ignore CRC */ + cmd.flags &= ~MMC_RSP_CRC ; + +return mmc_wait_for_cmd (mq->card->host, &cmd,0 ); +} + +static int __mmc_swcmdq_requeue (struct mmc_queue *mq) +{ +unsigned long i, qslots = mq->qslots; +int err; + +if (qslots) { +/* Cause re-tuning before next command, if needed */ +mmc_retune_release (mq->card->host); +mmc_retune_hold (mq->card->host); + } + +while (qslots) { + i =__ffs (qslots); + err =__mmc_swcmdq_enqueue (mq, &mq->mqrq[i]); +if (err) +return err; +__clear_bit (i, &qslots); + } + +return 0 ; +} + +static void __mmc_swcmdq_error_out (struct mmc_queue *mq) +{ +unsigned long i, qslots = mq->qslots; +struct request *req; + +if (qslots) +mmc_retune_release (mq->card->host); + +while (qslots) { + i =__ffs (qslots); + req = mq->mqrq[i].req; +blk_end_request_all (req, -EIO ); + mq->mqrq[i].req =NULL ; +__clear_bit (i, &qslots); + } + + mq->qslots =0 ; + mq->qcnt =0 ; +} + +static int mmc_swcmdq_requeue (struct mmc_queue *mq) +{ +int err; + +/* Wait for active request */ + err =mmc_swcmdq_await_active (mq); +if (err) +return err; + + err =mmc_swcmdq_discard_queue (mq); +if (err) +return err; + +return __mmc_swcmdq_requeue (mq); +} + +static void mmc_swcmdq_reset (struct mmc_queue *mq) +{ +/* Wait for active request ignoring errors */ +mmc_swcmdq_await_active (mq); + +/* Ensure the queue is discarded */ +mmc_swcmdq_discard_queue (mq); + +/* Reset and requeue else error out all requests */ +if (mmc_blk_reset (mq->blkdata, mq->card->host,MMC_BLK_SWCMDQ ) || +__mmc_swcmdq_requeue (mq)) +__mmc_swcmdq_error_out (mq); +} + +/* +* Recovery has 2 options: +* 1. Discard the queue and re-queue all requests. If that fails, fall back to +* option 2. +* 2. Reset and re-queue all requests. If that fails, error out all the +* requests. +* In either case, re-tuning will be done if needed after the queue becomes +* empty because re-tuning is released at that point. +*/ +static void mmc_swcmdq_recovery (struct mmc_queue *mq,int err) +{ +/* +* Recovery is expected seldom, if at all, but it reduces performance, +* so make sure it is not completely silent. +*/ +pr_warn ("%s: running software command queue recovery\n" , +mmc_hostname (mq->card->host)); + +switch (err) { +case MMC_BLK_RETRY : + err =mmc_swcmdq_requeue (mq); +if (!err) +break ; +/* Fall through */ +default : +mmc_swcmdq_reset (mq); + } +} + +static void mmc_swcmdq_issue_rw_rq (struct mmc_queue *mq,struct request *req) +{ +struct mmc_context_info *cntx = &mq->card->host->context_info; +bool flush = !req && !cntx->is_waiting_last_req; +int err; + +/* Enqueue new requests */ +if (req) { + err =mmc_swcmdq_enqueue (mq, req); +if (err) +mmc_swcmdq_recovery (mq, err); + } + +/* +* Keep executing queued requests until the queue is empty or +* mmc_swcmdq_execute() asks for new requests by returning +* MMC_BLK_NEW_REQUEST. +*/ +while (mq->qcnt) { +/* +* Re-tuning can only be done when the queue is empty. Recovery +* for MMC_BLK_RETRY will discard the queue and re-queue all +* requests. At the point the queue is empty, re-tuning is +* released and will be done automatically before the next +* mmc_request. +*/ +if (mq->card->host->need_retune) +mmc_swcmdq_recovery (mq,MMC_BLK_RETRY ); + err =mmc_swcmdq_execute (mq, flush, false, !!req); +if (err ==MMC_BLK_NEW_REQUEST ) +return ; +if (err) +mmc_swcmdq_recovery (mq, err); + } +} + +static void __mmc_blk_issue_rw_rq (struct mmc_queue *mq,struct request *new_req) {struct mmc_blk_data *md = mq->blkdata;struct mmc_card *card = md->queue.card;
@@ -1846,6 +2358,17 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)mmc_queue_req_free (mq, mq_rq); } +static void mmc_blk_issue_rw_rq (struct mmc_queue *mq,struct request *req) +{ +struct mmc_blk_data *md = mq->blkdata; +struct mmc_card *card = md->queue.card; + +if (card->ext_csd.cmdq_en) +mmc_swcmdq_issue_rw_rq (mq, req); +else +__mmc_blk_issue_rw_rq (mq, req); +} +void mmc_blk_issue_rq (struct mmc_queue *mq,struct request *req) {int ret;
drivers/mmc/core/queue.c +9 -1
@@ -64,6 +64,7 @@ struct mmc_queue_req *mmc_queue_req_find(struct mmc_queue *mq, mqrq->req = req; mq->qcnt +=1 ;__set_bit (mqrq->task_id, &mq->qslots); + mqrq->retry_cnt =0 ;return mqrq; }
@@ -377,7 +378,14 @@ static int __mmc_queue_alloc_shared_queue(struct mmc_card *card, int qdepth)int mmc_queue_alloc_shared_queue (struct mmc_card *card) { -return __mmc_queue_alloc_shared_queue (card,2 ); +int qdepth; + +if (card->ext_csd.cmdq_en) + qdepth = card->ext_csd.cmdq_depth; +else + qdepth =2 ; + +return __mmc_queue_alloc_shared_queue (card, qdepth); }/**
drivers/mmc/core/queue.h +10 -1
@@ -19,9 +19,13 @@ static inline bool mmc_req_is_special(struct request *req)struct mmc_blk_request {struct mmc_request mrq; -struct mmc_command sbc; +union { +struct mmc_command sbc; +struct mmc_command cmd44; + };struct mmc_command cmd;struct mmc_command stop; +struct mmc_command cmd45;struct mmc_data data;int retune_retry_done; };
@@ -35,6 +39,7 @@ struct mmc_queue_req {unsigned int bounce_sg_len;struct mmc_async_req areq;int task_id; +unsigned int retry_cnt; };struct mmc_queue {
@@ -50,6 +55,10 @@ struct mmc_queue {int qdepth;int qcnt;unsigned long qslots; +/* Following are defined for Software Command Queuing */ +unsigned long qsr; +struct mmc_async_req *prepared_areq; +bool qsr_err; };extern int mmc_queue_alloc_shared_queue (struct mmc_card *card);
include/linux/mmc/core.h +1 -0
@@ -24,6 +24,7 @@ enum mmc_blk_status {MMC_BLK_ECC_ERR ,MMC_BLK_NOMEDIUM ,MMC_BLK_NEW_REQUEST , + MMC_BLK_SUCCESS_ERR, /* Success but prevent starting another request */ }; struct mmc_command {
Signature · 1 line
1.9.1
Re: [PATCH RFC 12/39] mmc: block: Add Software Command Queuing
Quoted 4 lines · Adrian Hunter
eMMC Command Queuing is a feature added in version 5.1. The card maintains a queue of up to 32 data transfers. Commands CMD44/CMD45 are sent to queue up transfers in advance, and then one of the transfers is selected to "execute" by CMD46/CMD47 at which point data transfer actually begins.
(...)
Quoted 1 line
Signed-off-by Adrian Hunter <[email protected]>
Overall this looks nice.
I have of course objections about the things where I just patched around.
Quoted 2 lines
drivers/mmc/core/block.c +2
-0+static int mmc_swcmdq_await_qsr (struct mmc_queue *mq,struct mmc_card *card, +bool wait)
(...)
drivers/mmc/core/block.c static void mmc_blk_rw_try_restart(struct mmc_queue *mq, struct request *req, · line 1881
Quoted 10 lines
drivers/mmc/core/block.c +10
-0+if (card->host->areq) { +/* +* The active request remains in the QSR until completed. Remove +* it so that mq->qsr only contains ones that are ready but not +* executed. +*/ + mqrq = container_of(card->host->areq, struct mmc_queue_req, + areq); +__clear_bit (mqrq->task_id, &mq->qsr); + }
Clever. I see that you might need that task_id field in mqrq for this. Which is fine: this is the per-request state container and should be used for all states pertaining to a certain request.
Quoted 7 lines
drivers/mmc/core/block.c +7
-0+ prev =mmc_start_areq (card->host, next, &status); + +if (status ==MMC_BLK_NEW_REQUEST ) { + mq->prepared_areq = next; +return status; + } +
drivers/mmc/core/block.c static void mmc_blk_rw_try_restart(struct mmc_queue *mq, struct request *req, · line 1970
Quoted 10 lines
drivers/mmc/core/block.c +10
-0+ mq->prepared_areq =NULL ; + +if (!prev) +return 0 ; + + mqrq = container_of(prev, struct mmc_queue_req, areq); + brq = &mqrq->brq; + req = mqrq->req; + +mmc_queue_bounce_post (mqrq);
So this is duplicating hairy submission semantics that I've tried to get rid of.
Quoted 11 lines
drivers/mmc/core/block.c +11
-0+switch (status) { +case MMC_BLK_SUCCESS : +case MMC_BLK_PARTIAL : +case MMC_BLK_SUCCESS_ERR : +mmc_blk_reset_success (mq->blkdata,MMC_BLK_SWCMDQ ); + ret =blk_end_request (req,0 , brq->data.bytes_xfered); +if (ret) { +if (!requeuing) +return __mmc_swcmdq_enqueue (mq, mqrq); +return 0 ; + }
drivers/mmc/core/block.c static void mmc_blk_rw_try_restart(struct mmc_queue *mq, struct request *req, · line 1992
Quoted 10 lines
drivers/mmc/core/block.c +10
-0+break ; +case MMC_BLK_NEW_REQUEST : +return status; +default : +if (mqrq->retry_cnt++) { +blk_end_request_all (req, -EIO ); +break ; + } +return status; + }
And this is the successful path where I nowadays try to split the return path in two in the last non-RFC patch:
"mmc: queue: issue requests in massive parallel"
It is not good that the command queue code is making a local copy of the error handling code, but I guess it actually needs to handle errors in a totally different way?
Quoted 1 line
+static void
__mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
For this ans all other functions that got a __prefix all of a sudden: please try to avoid that and instead come up with a proper new name.
The code is confusing enough as it is and in "my" subsystems I have tried to cut down on all __prefixed functions in favor of more exact naming. This is just very painful for the mind.
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 13/39 mmc: mmc: Enable Software Command Queuing
In reply to Adrian HunterEnable the Command Queue if the host controller supports Software Command Queuing. It is not compatible with Packed Commands, so do not enable that at the same time.
--- drivers/mmc/core/mmc.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)
drivers/mmc/core/mmc.c +16 -1
@@ -1799,6 +1799,20 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, } } +/* Enable Command Queue if supported */ + card->ext_csd.cmdq_en = false; +if (card->ext_csd.cmdq_support && host->caps &MMC_CAP_CMD_DURING_TFR ) { + err =mmc_cmdq_enable (card); +if (err && err != -EBADMSG ) + goto free_card; +if (err) { +pr_warn ("%s: Enabling CMDQ failed\n" , +mmc_hostname (card->host)); + card->ext_csd.cmdq_support = false; + card->ext_csd.cmdq_depth =0 ; + err =0 ; + } + }/* * In some cases (e.g. RPMB or mmc_test), the Command Queue must be * disabled for a time, so a flag is needed to indicate to re-enable the
@@ -1812,7 +1826,8 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,*/ if (card->ext_csd.max_packed_writes >=3 && card->ext_csd.max_packed_reads >=5 && - host->caps2 &MMC_CAP2_PACKED_CMD ) { + host->caps2 &MMC_CAP2_PACKED_CMD && + !card->ext_csd.cmdq_en) { err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_EXP_EVENTS_CTRL, EXT_CSD_PACKED_EVENT_EN,
Signature · 1 line
1.9.1
Re: [PATCH RFC 13/39] mmc: mmc: Enable Software Command Queuing
Quoted 5 lines · Adrian Hunter
Enable the Command Queue if the host controller supports Software Command Queuing. It is not compatible with Packed Commands, so do not enable that at the same time.
Signed-off-by Adrian Hunter <[email protected]>
This looks right
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 14/39 mmc: core: Factor out debug prints from mmc_start_request()
In reply to Adrian HunterIn preparation to reuse the code for CQE support.
--- drivers/mmc/core/core.c | 33 ++++++++++++++++++++------------- 1 file changed, 20 insertions(+), 13 deletions(-)
drivers/mmc/core/core.c +20 -13
@@ -262,26 +262,19 @@ static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) host->ops->request (host, mrq); } -static int mmc_start_request (struct mmc_host *host,struct mmc_request *mrq) +static void mmc_mrq_pr_debug (struct mmc_host *host,struct mmc_request *mrq) { -#ifdef CONFIG_MMC_DEBUG -unsigned int i, sz; -struct scatterlist *sg; -#endif -mmc_retune_hold (host); - -if (mmc_card_removed (host->card)) -return -ENOMEDIUM ; -if (mrq->sbc) {pr_debug ("<%s: starting CMD%u arg %08x flags %08x>\n" ,mmc_hostname (host), mrq->sbc->opcode, mrq->sbc->arg, mrq->sbc->flags); } -pr_debug ("%s: starting CMD%u arg %08x flags %08x\n" , -mmc_hostname (host), mrq->cmd->opcode, - mrq->cmd->arg, mrq->cmd->flags); +if (mrq->cmd) { +pr_debug ("%s: starting CMD%u arg %08x flags %08x\n" , +mmc_hostname (host), mrq->cmd->opcode, mrq->cmd->arg, + mrq->cmd->flags); + }if (mrq->data) { pr_debug("%s: blksz %d blocks %d flags %08x "
@@ -297,6 +290,20 @@ static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)mmc_hostname (host), mrq->stop->opcode, mrq->stop->arg, mrq->stop->flags); } +} + +static int mmc_start_request (struct mmc_host *host,struct mmc_request *mrq) +{ +#ifdef CONFIG_MMC_DEBUG +unsigned int i, sz; +struct scatterlist *sg; +#endif +mmc_retune_hold (host); + +if (mmc_card_removed (host->card)) +return -ENOMEDIUM ; + +mmc_mrq_pr_debug (host, mrq);WARN_ON (!host->claimed);
Signature · 1 line
1.9.1
Re: [PATCH RFC 14/39] mmc: core: Factor out debug prints from mmc_start_request()
Quoted 3 lines · Adrian Hunter
In preparation to reuse the code for CQE support.
Signed-off-by Adrian Hunter <[email protected]>
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 15/39 mmc: core: Factor out mrq preparation from mmc_start_request()
In reply to Adrian HunterIn preparation to reuse the code for CQE support.
--- drivers/mmc/core/core.c | 40 +++++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-)
drivers/mmc/core/core.c +27 -13
@@ -292,23 +292,18 @@ static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq) } } -static int mmc_start_request (struct mmc_host *host,struct mmc_request *mrq) +static int mmc_mrq_prep (struct mmc_host *host,struct mmc_request *mrq) {#ifdef CONFIG_MMC_DEBUG unsigned int i, sz;struct scatterlist *sg;#endif -mmc_retune_hold (host); - -if (mmc_card_removed (host->card)) -return -ENOMEDIUM ; - -mmc_mrq_pr_debug (host, mrq); - -WARN_ON (!host->claimed); - mrq->cmd->error =0 ; - mrq->cmd->mrq = mrq; +if (mrq->cmd) { + mrq->cmd->error =0 ; + mrq->cmd->mrq = mrq; + mrq->cmd->data = mrq->data; + }if (mrq->sbc) { mrq->sbc->error =0 ; mrq->sbc->mrq = mrq;
@@ -325,8 +320,6 @@ static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)if (sz != mrq->data->blocks * mrq->data->blksz)return -EINVAL ;#endif - - mrq->cmd->data = mrq->data; mrq->data->error =0 ; mrq->data->mrq = mrq;if (mrq->stop) {
@@ -335,6 +328,27 @@ static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) mrq->stop->mrq = mrq; } } + +return 0 ; +} + +static int mmc_start_request (struct mmc_host *host,struct mmc_request *mrq) +{ +int err; + +mmc_retune_hold (host); + +if (mmc_card_removed (host->card)) +return -ENOMEDIUM ; + +mmc_mrq_pr_debug (host, mrq); + +WARN_ON (!host->claimed); + + err =mmc_mrq_prep (host, mrq); +if (err) +return err; +led_trigger_event (host->led,LED_FULL );__mmc_start_request (host, mrq);
Signature · 1 line
1.9.1
Re: [PATCH RFC 15/39] mmc: core: Factor out mrq preparation from mmc_start_request()
Quoted 3 lines · Adrian Hunter
In preparation to reuse the code for CQE support.
Signed-off-by Adrian Hunter <[email protected]>
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 16/39 mmc: core: Add mmc_retune_hold_now()
In reply to Adrian HunterIn preparation for CQE support.
--- drivers/mmc/core/host.c | 6 ++++++ drivers/mmc/core/host.h | 1 + 2 files changed, 7 insertions(+)
drivers/mmc/core/host.c +6 -0
@@ -111,6 +111,12 @@ void mmc_retune_hold(struct mmc_host *host) }EXPORT_SYMBOL (mmc_retune_hold); +void mmc_retune_hold_now (struct mmc_host *host) +{ + host->retune_now =0 ; + host->hold_retune +=1 ; +} +void mmc_retune_release (struct mmc_host *host) {if (host->hold_retune)
drivers/mmc/core/host.h +1 -0
@@ -19,6 +19,7 @@void mmc_retune_enable (struct mmc_host *host);void mmc_retune_disable (struct mmc_host *host);void mmc_retune_hold (struct mmc_host *host); +void mmc_retune_hold_now (struct mmc_host *host);void mmc_retune_release (struct mmc_host *host);int mmc_retune (struct mmc_host *host);void mmc_retune_pause (struct mmc_host *host);
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 17/39 mmc: core: Add members to mmc_request and mmc_data for CQE's
In reply to Adrian HunterMost of the information needed to issue requests to a CQE is already in struct mmc_request and struct mmc_data. Add data block address, some flags, and the task id (tag).
--- include/linux/mmc/core.h | 13 +++++++++++-- include/trace/events/mmc.h | 17 ++++++++++++----- 2 files changed, 23 insertions(+), 7 deletions(-)
include/linux/mmc/core.h +11 -2
@@ -123,11 +123,18 @@ struct mmc_data {unsigned int timeout_clks;/* data timeout (in clocks) */ unsigned int blksz;/* data block size */ unsigned int blocks;/* number of blocks */ +unsigned int blk_addr;/* block address */ int error;/* data error */ unsigned int flags; -#define MMC_DATA_WRITE (1 << 8) -#define MMC_DATA_READ (1 << 9) +#define MMC_DATA_WRITE BIT(8) +#define MMC_DATA_READ BIT(9) +/* Extra flags used by CQE */ +#define MMC_DATA_QBR BIT(10)/* CQE queue barrier*/ +#define MMC_DATA_PRIO BIT(11)/* CQE high priority */ +#define MMC_DATA_REL_WR BIT(12)/* Reliable write */ +#define MMC_DATA_DAT_TAG BIT(13)/* Tag request */ +#define MMC_DATA_FORCED_PRG BIT(14)/* Forced programming */ unsigned int bytes_xfered;
@@ -154,6 +161,8 @@ struct mmc_request {/* Allow other commands during this ongoing data transfer or busy wait */ bool cap_cmd_during_tfr; + +int tag; };struct mmc_card ;
include/trace/events/mmc.h +12 -5
@@ -29,8 +29,10 @@ __field(unsigned int, sbc_flags) __field(unsigned int, sbc_retries) __field(unsigned int, blocks) + __field(unsigned int, blk_addr) __field(unsigned int, blksz) __field(unsigned int, data_flags) + __field(int, tag) __field(unsigned int, can_retune) __field(unsigned int, doing_retune) __field(unsigned int, retune_now)
@@ -56,7 +58,9 @@ __entry->sbc_retries = mrq->sbc ? mrq->sbc->retries :0 ; __entry->blksz = mrq->data ? mrq->data->blksz :0 ; __entry->blocks = mrq->data ? mrq->data->blocks :0 ; + __entry->blk_addr = mrq->data ? mrq->data->blk_addr :0 ; __entry->data_flags = mrq->data ? mrq->data->flags :0 ; + __entry->tag = mrq->tag; __entry->can_retune = host->can_retune; __entry->doing_retune = host->doing_retune; __entry->retune_now = host->retune_now;
@@ -71,8 +75,8 @@"cmd_opcode=%u cmd_arg=0x%x cmd_flags=0x%x cmd_retries=%u " "stop_opcode=%u stop_arg=0x%x stop_flags=0x%x stop_retries=%u " "sbc_opcode=%u sbc_arg=0x%x sbc_flags=0x%x sbc_retires=%u " -"blocks=%u block_size=%u data_flags=0x%x " -"can_retune=%u doing_retune=%u retune_now=%u " +"blocks=%u block_size=%u blk_addr=%u data_flags=0x%x " +"tag=%d can_retune=%u doing_retune=%u retune_now=%u " "need_retune=%d hold_retune=%d retune_period=%u" ,__get_str (name), __entry->mrq, __entry->cmd_opcode, __entry->cmd_arg,
@@ -81,7 +85,8 @@ __entry->stop_flags, __entry->stop_retries, __entry->sbc_opcode, __entry->sbc_arg, __entry->sbc_flags, __entry->sbc_retries, - __entry->blocks, __entry->blksz, __entry->data_flags, + __entry->blocks, __entry->blk_addr, + __entry->blksz, __entry->data_flags, __entry->tag, __entry->can_retune, __entry->doing_retune, __entry->retune_now, __entry->need_retune, __entry->hold_retune, __entry->retune_period)
@@ -108,6 +113,7 @@ __field(unsigned int, sbc_retries) __field(unsigned int, bytes_xfered) __field(int, data_err) + __field(int, tag) __field(unsigned int, can_retune) __field(unsigned int, doing_retune) __field(unsigned int, retune_now)
@@ -139,6 +145,7 @@ __entry->sbc_retries = mrq->sbc ? mrq->sbc->retries :0 ; __entry->bytes_xfered = mrq->data ? mrq->data->bytes_xfered :0 ; __entry->data_err = mrq->data ? mrq->data->error :0 ; + __entry->tag = mrq->tag; __entry->can_retune = host->can_retune; __entry->doing_retune = host->doing_retune; __entry->retune_now = host->retune_now;
@@ -154,7 +161,7 @@"cmd_retries=%u stop_opcode=%u stop_err=%d " "stop_resp=0x%x 0x%x 0x%x 0x%x stop_retries=%u " "sbc_opcode=%u sbc_err=%d sbc_resp=0x%x 0x%x 0x%x 0x%x " -"sbc_retries=%u bytes_xfered=%u data_err=%d " +"sbc_retries=%u bytes_xfered=%u data_err=%d tag=%d " "can_retune=%u doing_retune=%u retune_now=%u need_retune=%d " "hold_retune=%d retune_period=%u" , __get_str(name), __entry->mrq,
@@ -170,7 +177,7 @@ __entry->sbc_resp[0 ], __entry->sbc_resp[1 ], __entry->sbc_resp[2 ], __entry->sbc_resp[3 ], __entry->sbc_retries, - __entry->bytes_xfered, __entry->data_err, + __entry->bytes_xfered, __entry->data_err, __entry->tag, __entry->can_retune, __entry->doing_retune, __entry->retune_now, __entry->need_retune, __entry->hold_retune, __entry->retune_period)
Signature · 1 line
1.9.1
Re: [PATCH RFC 17/39] mmc: core: Add members to mmc_request and mmc_data for CQE's
Quoted 5 lines · Adrian Hunter
Most of the information needed to issue requests to a CQE is already in struct
mmc_requestand structmmc_data. Add data block address, some flags, and the task id (tag).Signed-off-by Adrian Hunter <[email protected]>
I can't claim to know exactly why tag has to be here as opposed to being only internal to out mmc_blk_req, but I assume there is a good reason for that.
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 18/39 mmc: host: Add CQE interface
In reply to Adrian HunterAdd CQE host operations, capabilities, and host members.
--- include/linux/mmc/host.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
include/linux/mmc/host.h +24 -0
@@ -160,6 +160,19 @@ struct mmc_host_ops { unsigned int direction, int blk_size); }; +struct mmc_cqe_ops { +int (*cqe_enable)(struct mmc_host *host,struct mmc_card *card); +void (*cqe_disable)(struct mmc_host *host); +int (*cqe_request)(struct mmc_host *host,struct mmc_request *mrq); +void (*cqe_post_req)(struct mmc_host *host,struct mmc_request *mrq); +void (*cqe_off)(struct mmc_host *host); +int (*cqe_wait_for_idle)(struct mmc_host *host); +bool (*cqe_timeout)(struct mmc_host *host,struct mmc_request *mrq, +bool *recovery_needed); +void (*cqe_recovery_start)(struct mmc_host *host); +void (*cqe_recovery_finish)(struct mmc_host *host,bool forget_reqs); +}; +struct mmc_async_req {/* active mmc request */ struct mmc_request *mrq;
@@ -304,6 +317,8 @@ struct mmc_host {#define MMC_CAP2_HS400_ES (1 << 20)/* Host supports enhanced strobe */ #define MMC_CAP2_NO_SD (1 << 21)/* Do not send SD commands during initialization */ #define MMC_CAP2_NO_MMC (1 << 22)/* Do not send (e)MMC commands during initialization */ +#define MMC_CAP2_CQE (1 << 23)/* Has eMMC command queue engine */ +#define MMC_CAP2_CQE_DCMD (1 << 24)/* CQE can issue a direct command */ mmc_pm_flag_t pm_caps;/* supported pm features */
@@ -389,6 +404,15 @@ struct mmc_host {int dsr_req;/* DSR value is valid */ u32 dsr;/* optional driver stage (DSR) value */ +/* Command Queue Engine (CQE) support */ +const struct mmc_cqe_ops *cqe_ops; +void *cqe_private; +void (*cqe_recovery_notifier)(struct mmc_host *, +struct mmc_request *); +int cqe_qdepth; +bool cqe_enabled; +bool cqe_on; +unsigned long private[0 ]____cacheline_aligned ; };
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 19/39 mmc: core: Turn off CQE before sending commands
In reply to Adrian HunterTurn off the CQE before sending commands, and ensure it is off in any reset or power management paths.
--- drivers/mmc/core/core.c | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/mmc/core/core.c +6 -0
@@ -259,6 +259,9 @@ static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)trace_mmc_request_start (host, mrq); +if (host->cqe_on) + host->cqe_ops->cqe_off (host); + host->ops->request (host, mrq); }
@@ -1229,6 +1232,9 @@ void mmc_set_bus_width(struct mmc_host *host, unsigned int width)*/ void mmc_set_initial_state (struct mmc_host *host) { +if (host->cqe_on) + host->cqe_ops->cqe_off (host); +mmc_retune_disable (host);if (mmc_host_is_spi (host))
Signature · 1 line
1.9.1
Re: [PATCH RFC 19/39] mmc: core: Turn off CQE before sending commands
Quoted 4 lines · Adrian Hunter
Turn off the CQE before sending commands, and ensure it is off in any reset or power management paths.
Signed-off-by Adrian Hunter <[email protected]>
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 20/39 mmc: core: Add support for handling CQE requests
In reply to Adrian HunterAdd core support for handling CQE requests, including starting, completing and recovering.
--- drivers/mmc/core/core.c | 147 +++++++++++++++++++++++++++++++++++++++++++++-- include/linux/mmc/core.h | 6 ++ 2 files changed, 148 insertions(+), 5 deletions(-)
drivers/mmc/core/core.c +142 -5
@@ -265,7 +265,8 @@ static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) host->ops->request (host, mrq); } -static void mmc_mrq_pr_debug (struct mmc_host *host,struct mmc_request *mrq) +static void mmc_mrq_pr_debug (struct mmc_host *host,struct mmc_request *mrq, +bool cqe) {if (mrq->sbc) { pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n",
@@ -274,9 +275,12 @@ static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq) }if (mrq->cmd) { -pr_debug ("%s: starting CMD%u arg %08x flags %08x\n" , -mmc_hostname (host), mrq->cmd->opcode, mrq->cmd->arg, - mrq->cmd->flags); +pr_debug ("%s: starting %sCMD%u arg %08x flags %08x\n" , +mmc_hostname (host), cqe ?"CQE direct " :"" , + mrq->cmd->opcode, mrq->cmd->arg, mrq->cmd->flags); + }else if (cqe) { +pr_debug ("%s: starting CQE transfer for tag %d blkaddr %u\n" , +mmc_hostname (host), mrq->tag, mrq->data->blk_addr); }if (mrq->data) {
@@ -344,7 +348,7 @@ static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)if (mmc_card_removed (host->card))return -ENOMEDIUM ; -mmc_mrq_pr_debug (host, mrq); +mmc_mrq_pr_debug (host, mrq, false);WARN_ON (!host->claimed);
@@ -358,6 +362,139 @@ static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)return 0 ; } +int mmc_cqe_start_req (struct mmc_host *host,struct mmc_request *mrq) +{ +int err; + +/* Caller must hold retuning while CQE is in use */ + err =mmc_retune (host); +if (err) + goto out_err; + + mrq->host = host; + +mmc_mrq_pr_debug (host, mrq, true); + + err =mmc_mrq_prep (host, mrq); +if (err) + goto out_err; + + err = host->cqe_ops->cqe_request (host, mrq); +if (err) + goto out_err; + +trace_mmc_request_start (host, mrq); + +return 0 ; + +out_err: +if (mrq->cmd) { +pr_debug ("%s: failed to start CQE direct CMD%u, error %d\n" , +mmc_hostname (host), mrq->cmd->opcode, err); + }else { +pr_debug ("%s: failed to start CQE transfer for tag %d, error %d\n" , +mmc_hostname (host), mrq->tag, err); + } +return err; +} +EXPORT_SYMBOL (mmc_cqe_start_req); + +void __mmc_cqe_request_done (struct mmc_host *host,struct mmc_request *mrq) +{ +mmc_should_fail_request (host, mrq); + +/* Flag re-tuning needed on CRC errors */ +if ((mrq->cmd && mrq->cmd->error == -EILSEQ ) || + (mrq->data && mrq->data->error == -EILSEQ )) +mmc_retune_needed (host); + +trace_mmc_request_done (host, mrq); + +if (mrq->cmd) { +pr_debug ("%s: CQE req done (direct CMD%u): %d\n" , +mmc_hostname (host), mrq->cmd->opcode, mrq->cmd->error); + }else { +pr_debug ("%s: CQE transfer done tag %d\n" , +mmc_hostname (host), mrq->tag); + } + +if (mrq->data) { +pr_debug ("%s: %d bytes transferred: %d\n" , +mmc_hostname (host), + mrq->data->bytes_xfered, mrq->data->error); + } +} +EXPORT_SYMBOL (__mmc_cqe_request_done); + +/** +* mmc_cqe_request_done - CQE has finished processing an MMC request +* @host: MMC host which completed request +* @mrq: MMC request which completed +* +* CQE drivers should call this function when they have completed +* their processing of a request. +*/ +void mmc_cqe_request_done (struct mmc_host *host,struct mmc_request *mrq) +{ +__mmc_cqe_request_done (host, mrq); + + mrq->done (mrq); +} +EXPORT_SYMBOL (mmc_cqe_request_done); + +/** +* mmc_cqe_post_req - CQE post process of a completed MMC request +* @host: MMC host +* @mrq: MMC request to be processed +*/ +void mmc_cqe_post_req (struct mmc_host *host,struct mmc_request *mrq) +{ +if (host->cqe_ops->cqe_post_req) + host->cqe_ops->cqe_post_req (host, mrq); +} +EXPORT_SYMBOL (mmc_cqe_post_req); + +/* Arbitrary 1 second timeout */ +#define MMC_CQE_RECOVERY_TIMEOUT 1000 + +int mmc_cqe_recovery (struct mmc_host *host,bool forget_reqs) +{ +struct mmc_command cmd; +int err; + +mmc_retune_hold_now (host); + +/* +* Recovery is expected seldom, if at all, but it reduces performance, +* so make sure it is not completely silent. +*/ +pr_warn ("%s: running CQE recovery\n" ,mmc_hostname (host)); + + host->cqe_ops->cqe_recovery_start (host); + +memset (&cmd,0 ,sizeof (cmd)); + cmd.opcode =MMC_STOP_TRANSMISSION , + cmd.flags =MMC_RSP_R1B |MMC_CMD_AC , + cmd.flags &= ~MMC_RSP_CRC ;/* Ignore CRC */ + cmd.busy_timeout =MMC_CQE_RECOVERY_TIMEOUT , +mmc_wait_for_cmd (host, &cmd,0 ); + +memset (&cmd,0 ,sizeof (cmd)); + cmd.opcode =MMC_CMDQ_TASK_MGMT ; + cmd.arg =1 ;/* Discard entire queue */ + cmd.flags =MMC_RSP_R1B |MMC_CMD_AC ; + cmd.flags &= ~MMC_RSP_CRC ;/* Ignore CRC */ + cmd.busy_timeout =MMC_CQE_RECOVERY_TIMEOUT , + err =mmc_wait_for_cmd (host, &cmd,0 ); + + host->cqe_ops->cqe_recovery_finish (host, forget_reqs); + +mmc_retune_release (host); + +return err; +} +EXPORT_SYMBOL (mmc_cqe_recovery); +/** * mmc_start_bkops - start BKOPS for supported cards * @card: MMC card to start BKOPS
include/linux/mmc/core.h +6 -0
@@ -175,6 +175,12 @@ struct mmc_async_req *mmc_start_areq(struct mmc_host *host,int mmc_wait_for_cmd (struct mmc_host *host,struct mmc_command *cmd,int retries); +int mmc_cqe_start_req (struct mmc_host *host,struct mmc_request *mrq); +void __mmc_cqe_request_done (struct mmc_host *host,struct mmc_request *mrq); +void mmc_cqe_request_done (struct mmc_host *host,struct mmc_request *mrq); +void mmc_cqe_post_req (struct mmc_host *host,struct mmc_request *mrq); +int mmc_cqe_recovery (struct mmc_host *host,bool forget_reqs); +int mmc_hw_reset (struct mmc_host *host);void mmc_set_data_timeout (struct mmc_data *data,const struct mmc_card *card);
Signature · 1 line
1.9.1
Re: [PATCH RFC 20/39] mmc: core: Add support for handling CQE requests
Quoted 4 lines · Adrian Hunter
Add core support for handling CQE requests, including starting, completing and recovering.
Signed-off-by Adrian Hunter <[email protected]>
So this adds a new command path for the cqe. I guess it's unavoidable, and looks good to me.
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 21/39 mmc: mmc: Enable CQE's
In reply to Adrian HunterEnable or disable CQE when a card is added or removed respectively.
--- drivers/mmc/core/bus.c | 7 +++++++ drivers/mmc/core/mmc.c | 17 ++++++++++++++++- 2 files changed, 23 insertions(+), 1 deletion(-)
drivers/mmc/core/bus.c +7 -0
@@ -369,10 +369,17 @@ int mmc_add_card(struct mmc_card *card)*/ void mmc_remove_card (struct mmc_card *card) { +struct mmc_host *host = card->host; +#ifdef CONFIG_DEBUG_FS mmc_remove_card_debugfs (card);#endif +if (host->cqe_enabled) { + host->cqe_ops->cqe_disable (host); + host->cqe_enabled = false; + } +if (mmc_card_present (card)) {if (mmc_host_is_spi (card->host)) { pr_info("%s: SPI card removed\n",
drivers/mmc/core/mmc.c +16 -1
@@ -1801,7 +1801,9 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,/* Enable Command Queue if supported */ card->ext_csd.cmdq_en = false; -if (card->ext_csd.cmdq_support && host->caps &MMC_CAP_CMD_DURING_TFR ) { +if (card->ext_csd.cmdq_support && + (host->caps &MMC_CAP_CMD_DURING_TFR || + host->caps2 &MMC_CAP2_CQE )) { err =mmc_cmdq_enable (card);if (err && err != -EBADMSG ) goto free_card;
@@ -1820,6 +1822,19 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,*/ card->reenable_cmdq = card->ext_csd.cmdq_en; +if (card->ext_csd.cmdq_en && (host->caps2 &MMC_CAP2_CQE ) && + !host->cqe_enabled) { + err = host->cqe_ops->cqe_enable (host, card); +if (err) { +pr_err ("%s: Failed to enable CQE, error %d\n" , +mmc_hostname (host), err); + }else { + host->cqe_enabled = true; +pr_info ("%s: Command Queue Engine enabled\n" , +mmc_hostname (host)); + } + } +/* * The mandatory minimum values are defined for packed command. * read: 5, write: 3
Signature · 1 line
1.9.1
Re: [PATCH RFC 21/39] mmc: mmc: Enable CQE's
Quoted 3 lines · Adrian Hunter
Enable or disable CQE when a card is added or removed respectively.
Signed-off-by Adrian Hunter <[email protected]>
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 22/39 mmc: block: Prepare CQE data
In reply to Adrian HunterEnhance mmc_blk_data_prep() to support CQE requests.
--- drivers/mmc/core/block.c | 40 +++++++++++++++++++++++++++++----------- 1 file changed, 29 insertions(+), 11 deletions(-)
drivers/mmc/core/block.c +29 -11
@@ -36,6 +36,7 @@#include <linux/compat.h> #include <linux/pm_runtime.h> #include <linux/idr.h> +#include <linux/ioprio.h> #include <linux/mmc/ioctl.h> #include <linux/mmc/card.h>
@@ -1440,25 +1441,27 @@ static enum mmc_blk_status mmc_blk_err_check(struct mmc_card *card, }static void mmc_blk_data_prep (struct mmc_queue *mq,struct mmc_queue_req *mqrq, -int disable_multi,bool *do_rel_wr, -bool *do_data_tag) +int disable_multi,bool *do_rel_wr_p, +bool *do_data_tag_p) {struct mmc_blk_data *md = mq->blkdata;struct mmc_card *card = md->queue.card;struct mmc_blk_request *brq = &mqrq->brq;struct request *req = mqrq->req; +bool do_rel_wr, do_data_tag;/* * Reliable writes are used to implement Forced Unit Access and * are supported only on MMCs. */ - *do_rel_wr = (req->cmd_flags &REQ_FUA ) && -rq_data_dir (req) ==WRITE && - (md->flags &MMC_BLK_REL_WR ); + do_rel_wr = (req->cmd_flags &REQ_FUA ) && +rq_data_dir (req) ==WRITE && + (md->flags &MMC_BLK_REL_WR );memset (brq,0 ,sizeof (struct mmc_blk_request )); brq->mrq.data = &brq->data; + brq->mrq.tag = req->tag; brq->stop.opcode =MMC_STOP_TRANSMISSION ; brq->stop.arg =0 ;
@@ -1473,6 +1476,10 @@ static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, brq->data.blksz =512 ; brq->data.blocks =blk_rq_sectors (req); + brq->data.blk_addr =blk_rq_pos (req); + +if (IOPRIO_PRIO_CLASS (req_get_ioprio (req)) ==IOPRIO_CLASS_RT ) + brq->data.flags |=MMC_DATA_PRIO ;/* * The block layer doesn't support all sector count
@@ -1502,18 +1509,23 @@ static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, brq->data.blocks); } -if (*do_rel_wr) +if (do_rel_wr) {mmc_apply_rel_rw (brq, card, req); + brq->data.flags |=MMC_DATA_REL_WR ; + }/* * Data tag is used only during writing meta data to speed * up write and any subsequent read of this meta data */ - *do_data_tag = card->ext_csd.data_tag_unit_size && - (req->cmd_flags &REQ_META ) && - (rq_data_dir (req) ==WRITE ) && - ((brq->data.blocks * brq->data.blksz) >= - card->ext_csd.data_tag_unit_size); + do_data_tag = card->ext_csd.data_tag_unit_size && + (req->cmd_flags &REQ_META ) && + (rq_data_dir (req) ==WRITE ) && + ((brq->data.blocks * brq->data.blksz) >= + card->ext_csd.data_tag_unit_size); + +if (do_data_tag) + brq->data.flags |=MMC_DATA_DAT_TAG ;mmc_set_data_timeout (&brq->data, card);
@@ -1542,6 +1554,12 @@ static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, mqrq->areq.mrq = &brq->mrq;mmc_queue_bounce_pre (mqrq); + +if (do_rel_wr_p) + *do_rel_wr_p = do_rel_wr; + +if (do_data_tag_p) + *do_data_tag_p = do_data_tag; } static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
Signature · 1 line
1.9.1
Re: [PATCH RFC 22/39] mmc: block: Prepare CQE data
Quoted 3 lines · Adrian Hunter
Enhance
mmc_blk_data_prep()to support CQE requests.Signed-off-by Adrian Hunter <[email protected]>
Hey:
Quoted 1 line
+#include <
linux/ioprio.h>
(...)
drivers/mmc/core/block.c static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, · line 1482
Quoted 2 lines
drivers/mmc/core/block.c +2
-0+if (IOPRIO_PRIO_CLASS (req_get_ioprio (req)) ==IOPRIO_CLASS_RT ) + brq->data.flags |=MMC_DATA_PRIO ;
What is this?
Why are we not already doing this and why is it not a separate patch?
Quoted 4 lines
/*
* Data tag is used only during writing meta data to speed
* up write and any subsequent read of this meta data */
Is this comment still true?
drivers/mmc/core/block.c static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, · line 1528
Quoted 13 lines
drivers/mmc/core/block.c +8
-5- *do_data_tag = card->ext_csd.data_tag_unit_size && - (req->cmd_flags &REQ_META ) && - (rq_data_dir (req) ==WRITE ) && - ((brq->data.blocks * brq->data.blksz) >= - card->ext_csd.data_tag_unit_size); + do_data_tag = card->ext_csd.data_tag_unit_size && + (req->cmd_flags &REQ_META ) && + (rq_data_dir (req) ==WRITE ) && + ((brq->data.blocks * brq->data.blksz) >= + card->ext_csd.data_tag_unit_size); + +if (do_data_tag) + brq->data.flags |=MMC_DATA_DAT_TAG ;
Because it seems to be more unconditionally used now.
Yours,
Linus Walleij
Adrian Hunter
maintainerRe: [PATCH RFC 22/39] mmc: block: Prepare CQE data
Quoted 6 lines · Linus Walleij
Quoted 3 lines · Adrian Hunter
Enhance
mmc_blk_data_prep()to support CQE requests.Signed-off-by Adrian Hunter <[email protected]>
Quoted 8 lines
Hey:
Quoted 1 line
+#include <
linux/ioprio.h>(...)
drivers/mmc/core/block.c static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, · line 1482
Quoted 2 lines
drivers/mmc/core/block.c +2
-0+if (IOPRIO_PRIO_CLASS (req_get_ioprio (req)) ==IOPRIO_CLASS_RT ) + brq->data.flags |=MMC_DATA_PRIO ;What is this?
It is the command queue priority.
The command queue supports 2 priorities: "high" (1) and "simple" (0). The eMMC will give "high" priority tasks priority over "simple" priority tasks.
So here we give priority to IOPRIO_CLASS_RT which seems appropriate.
Quoted 2 lines
Why are we not already doing this and why is it not a separate patch?
I think adding a comment is better since it is a command queue feature.
Quoted 7 lines
Quoted 5 lines
/*
* Data tag is used only during writing meta data to speed
* up write and any subsequent read of this meta data */Is this comment still true?
AFAIK
Quoted 15 lines
Quoted 4 lines
drivers/mmc/core/block.c +0
-3- *do_data_tag = card->ext_csd.data_tag_unit_size && - (req->cmd_flags &REQ_META ) && - (rq_data_dir(req) == WRITE) &&drivers/mmc/core/block.c static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, · line 1528
Quoted 10 lines
drivers/mmc/core/block.c +8
-2- ((brq->data.blocks * brq->data.blksz) >= - card->ext_csd.data_tag_unit_size); + do_data_tag = card->ext_csd.data_tag_unit_size && + (req->cmd_flags &REQ_META ) && + (rq_data_dir (req) ==WRITE ) && + ((brq->data.blocks * brq->data.blksz) >= + card->ext_csd.data_tag_unit_size); + +if (do_data_tag) + brq->data.flags |=MMC_DATA_DAT_TAG ;
Quoted 1 line
Because it seems to be more unconditionally used now.
The key ingredient is (req->cmd_flags & REQ_META) i.e. meta-data gets tagged.
Re: [PATCH RFC 22/39] mmc: block: Prepare CQE data
Quoted 14 lines · Adrian Hunter
Quoted 13 lines · Linus Walleij
Quoted 3 lines · Adrian Hunter
Enhance
mmc_blk_data_prep()to support CQE requests.Signed-off-by Adrian Hunter <[email protected]>Hey:
Quoted 1 line
+#include <
linux/ioprio.h>(...)
Quoted 2 lines
drivers/mmc/core/block.c +2
-0+if (IOPRIO_PRIO_CLASS (req_get_ioprio (req)) ==IOPRIO_CLASS_RT ) + brq->data.flags |=MMC_DATA_PRIO ;
Quoted 8 lines
Quoted 1 line
What is this?
It is the command queue priority.
The command queue supports 2 priorities: "high" (1) and "simple" (0). The eMMC will give "high" priority tasks priority over "simple" priority tasks.
So here we give priority to
IOPRIO_CLASS_RTwhich seems appropriate.
So if I understand correctly, you are obtaining the block layer scheduling priorities, that can (only?) be set by ionice has from the command line?
We need to discuss this with the block maintainers.
I'm not so sure about the future of this. The IOPRIO is only used with the CFQ scheduler, only two other sites in the kernel use this and MQ and its schedulers surely does not have ionice handling as far as I know.
The BFQ does not use it, AFAIK it is using different heuristics to prioritize block traffic, and that does not include using ionice hints.
Is ionice:ing something we're really going to do going forward? Should this be repurposed so that the block scheduler use this prio to communicate to the driver layer to prioritize certain traffic?
Yours,
Linus Walleij
Adrian Hunter
maintainerRe: [PATCH RFC 22/39] mmc: block: Prepare CQE data
Quoted 19 lines · Linus Walleij
Quoted 18 lines · Adrian Hunter
Quoted 6 lines · Linus Walleij
Quoted 3 lines · Adrian Hunter
Enhance
mmc_blk_data_prep()to support CQE requests.Signed-off-by Adrian Hunter <[email protected]>Quoted 8 lines
Hey:
Quoted 1 line
+#include <
linux/ioprio.h>(...)
drivers/mmc/core/block.c static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, · line 1482
Quoted 2 lines
drivers/mmc/core/block.c +2
-0+if (IOPRIO_PRIO_CLASS (req_get_ioprio (req)) ==IOPRIO_CLASS_RT ) + brq->data.flags |=MMC_DATA_PRIO ;What is this?
It is the command queue priority.
Quoted 7 lines
Quoted 4 lines
The command queue supports 2 priorities: "high" (1) and "simple" (0). The eMMC will give "high" priority tasks priority over "simple" priority tasks.
So here we give priority to
IOPRIO_CLASS_RTwhich seems appropriate.So if I understand correctly, you are obtaining the block layer scheduling priorities, that can (only?) be set by ionice has from the command line?
AFAICS it is the ioprio_set() system call .
Quoted 7 lines
We need to discuss this with the block maintainers.
I'm not so sure about the future of this. The IOPRIO is only used with the CFQ scheduler, only two other sites in the kernel use this and MQ and its schedulers surely does not have ionice handling as far as I know.
Quoted 6 lines
The BFQ does not use it, AFAIK it is using different heuristics to prioritize block traffic, and that does not include using ionice hints.
Is ionice:ing something we're really going to do going forward? Should this be repurposed so that the block scheduler use this prio to communicate to the driver layer to prioritize certain traffic?
That seems like a separate issue. At the moment, I/O priorities are what we have, and giving priority to RT seems appropriate.
Re: [PATCH RFC 22/39] mmc: block: Prepare CQE data
Quoted 23 lines · Adrian Hunter
Quoted 22 lines · Linus Walleij
Quoted 21 lines · Adrian Hunter
Quoted 6 lines · Linus Walleij
Quoted 3 lines · Adrian Hunter
Enhance
mmc_blk_data_prep()to support CQE requests.Signed-off-by Adrian Hunter <[email protected]>Quoted 8 lines
Hey:
Quoted 1 line
+#include <
linux/ioprio.h>(...)
drivers/mmc/core/block.c static void mmc_blk_data_prep(struct mmc_queue *mq, struct mmc_queue_req *mqrq, · line 1482
Quoted 2 lines
drivers/mmc/core/block.c +2
-0+if (IOPRIO_PRIO_CLASS (req_get_ioprio (req)) ==IOPRIO_CLASS_RT ) + brq->data.flags |=MMC_DATA_PRIO ;What is this?
It is the command queue priority.
The command queue supports 2 priorities: "high" (1) and "simple" (0). The eMMC will give "high" priority tasks priority over "simple" priority tasks.
Quoted 6 lines
Quoted 4 lines
Quoted 1 line
So here we give priority to
IOPRIO_CLASS_RTwhich seems appropriate.So if I understand correctly, you are obtaining the block layer scheduling priorities, that can (only?) be set by ionice has from the command line?
AFAICS it is the
ioprio_set()system call .
OK to be clear, correct, it is set by that system call.
And as far as I can tell there is exactly one program in the world that issues that syscall, and that is ionice(1).
It is described to the world as a way for users to give hints to the I/O scheduler
about how to manage requests. For example a user can hint that some IO is a backup job and not important and some IO is a media player and really important.
And since the block layer only handles this hint in the legacy blk CFQ scheduler I want to know from the block layer developers if this priority has any future. BFQ does not use this hint at all, I think Paolo described the ionice command as problematic, and we need to understand if user-provided IO scheduling hints is something that is going to be used in the future.
Yours,
Linus Walleij
Adrian Hunter
maintainerRFC PATCH 23/39 mmc: block: Add CQE support
In reply to Adrian HunterAdd CQE support to the block driver, including:
- optionally using DCMD for flush requests
- manually issuing discard requests
- issuing read / write requests to the CQE
- supporting block-layer timeouts
- handling recovery
- supporting re-tuning
--- drivers/mmc/core/block.c | 202 ++++++++++++++++++++++++++++++- drivers/mmc/core/block.h | 7 ++ drivers/mmc/core/queue.c | 301 ++++++++++++++++++++++++++++++++++++++++++++++- drivers/mmc/core/queue.h | 43 ++++++- 4 files changed, 546 insertions(+), 7 deletions(-)
drivers/mmc/core/block.c +201 -1
@@ -115,6 +115,7 @@ struct mmc_blk_data {#define MMC_BLK_DISCARD BIT(2)#define MMC_BLK_SECDISCARD BIT(3)#define MMC_BLK_SWCMDQ BIT(4) +#define MMC_BLK_CQE_RECOVERY BIT(5)/* * Only set in main mmc_blk_data associated
@@ -2376,6 +2377,205 @@ static void __mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)mmc_queue_req_free (mq, mq_rq); } +#define MMC_CQE_RETRIES 2 + +void mmc_blk_cqe_complete_rq (struct request *req) +{ +struct mmc_queue_req *mqrq = req->special; +struct mmc_request *mrq = &mqrq->brq.mrq; +struct request_queue *q = req->q; +struct mmc_queue *mq = q->queuedata; +struct mmc_host *host = mq->card->host; +unsigned long flags; +bool put_card; +int err; + +mmc_cqe_post_req (host, mrq); + +spin_lock_irqsave (q->queue_lock, flags); + + mq->cqe_in_flight[mmc_cqe_issue_type (host, req)] -=1 ; + + put_card =mmc_cqe_tot_in_flight (mq) ==0 ; + +mmc_queue_clr_special (req); + +if (mrq->cmd && mrq->cmd->error) + err = mrq->cmd->error; +else if (mrq->data && mrq->data->error) + err = mrq->data->error; +else + err =0 ; + +if (err) { +/* +* !req->retries means we have not seen this request before, so +* we add 1 to the number of retries and compare to 1 to decide +* whether or not to retry. +*/ +if (!req->retries) + req->retries =MMC_CQE_RETRIES +1 ; +if (--req->retries >=1 ) +blk_requeue_request (q, req); +else +__blk_end_request_all (req, -EIO ); + }else if (mrq->data) { +if (__blk_end_request (req,0 , mrq->data->bytes_xfered)) +blk_requeue_request (q, req); + }else { +__blk_end_request_all (req,0 ); + } + +mmc_cqe_kick_queue (mq); + +spin_unlock_irqrestore (q->queue_lock, flags); + +if (put_card) +mmc_put_card (mq->card); +} + +void mmc_blk_cqe_recovery (struct mmc_queue *mq) +{ +struct mmc_card *card = mq->card; +struct mmc_host *host = card->host; +int err, i; + +mmc_get_card (card); + +pr_debug ("%s: CQE recovery start\n" ,mmc_hostname (host)); + +/* +* Block layer timeouts race with completions which means the normal +* completion path cannot be used so tell CQE to forget the requests. +*/ + err =mmc_cqe_recovery (host, true); + +/* Then complete all requests directly */ +for (i =0 ; i < mq->qdepth; i++) { +struct mmc_queue_req *mqrq = &mq->mqrq[i]; + +if (mqrq->req) { +__mmc_cqe_request_done (host, &mqrq->brq.mrq); +mmc_blk_cqe_complete_rq (mqrq->req); + } + } + +if (err) +mmc_blk_reset (mq->blkdata, host,MMC_BLK_CQE_RECOVERY ); +else +mmc_blk_reset_success (mq->blkdata,MMC_BLK_CQE_RECOVERY ); + +pr_debug ("%s: CQE recovery done\n" ,mmc_hostname (host)); + +mmc_put_card (card); +} + +static void mmc_blk_cqe_req_done (struct mmc_request *mrq) +{ + struct mmc_queue_req *mqrq = container_of(mrq, struct mmc_queue_req, + brq.mrq); + +blk_complete_request (mqrq->req); +} + +static int mmc_blk_cqe_start_req (struct mmc_host *host,struct mmc_request *mrq) +{ + mrq->done = mmc_blk_cqe_req_done; +return mmc_cqe_start_req (host, mrq); +} + +static struct mmc_request *mmc_blk_cqe_prep_dcmd (struct mmc_queue_req *mqrq) +{ +struct mmc_blk_request *brq = &mqrq->brq; + +memset (brq,0 ,sizeof (*brq)); + + brq->mrq.cmd = &brq->cmd; + brq->mrq.tag = mqrq->req->tag; + +return &brq->mrq; +} + +int mmc_blk_cqe_issue_flush (struct mmc_queue *mq,struct request *req) +{ +struct mmc_queue_req *mqrq = req->special; +struct mmc_request *mrq =mmc_blk_cqe_prep_dcmd (mqrq); + + mrq->cmd->opcode =MMC_SWITCH ; + mrq->cmd->arg = (MMC_SWITCH_MODE_WRITE_BYTE <<24 ) | + (EXT_CSD_FLUSH_CACHE <<16 ) | + (1 <<8 ) | +EXT_CSD_CMD_SET_NORMAL ; + mrq->cmd->flags =MMC_CMD_AC |MMC_RSP_R1B ; + +return mmc_blk_cqe_start_req (mq->card->host, mrq); +} + +static int mmc_blk_cqe_issue_rw_rq (struct mmc_queue *mq,struct request *req) +{ +struct mmc_queue_req *mqrq = req->special; + +mmc_blk_data_prep (mq, mqrq,0 ,NULL ,NULL ); + +return mmc_blk_cqe_start_req (mq->card->host, &mqrq->brq.mrq); +} + +enum mmc_issued mmc_blk_cqe_issue_rq (struct mmc_queue *mq,struct request *req) +{ +struct mmc_blk_data *md = mq->blkdata; +struct mmc_card *card = md->queue.card; +struct mmc_host *host = card->host; +int ret; + + ret =mmc_blk_part_switch (card, md); +if (ret) +return MMC_REQ_FAILED_TO_START ; + +switch (mmc_cqe_issue_type (host, req)) { +case MMC_ISSUE_SYNC : + ret = host->cqe_ops->cqe_wait_for_idle (host); +if (ret) +return MMC_REQ_BUSY ; +switch (req_op (req)) { +case REQ_OP_DISCARD : +mmc_blk_issue_discard_rq (mq, req); +break ; +case REQ_OP_SECURE_ERASE : +mmc_blk_issue_secdiscard_rq (mq, req); +break ; +case REQ_OP_FLUSH : +mmc_blk_issue_flush (mq, req); +break ; +default : +WARN_ON_ONCE (1 ); +return MMC_REQ_FAILED_TO_START ; + } +return MMC_REQ_FINISHED ; +case MMC_ISSUE_DCMD : +case MMC_ISSUE_ASYNC : +mmc_queue_set_special (mq, req); +switch (req_op (req)) { +case REQ_OP_FLUSH : + ret =mmc_blk_cqe_issue_flush (mq, req); +break ; +case REQ_OP_READ : +case REQ_OP_WRITE : + ret =mmc_blk_cqe_issue_rw_rq (mq, req); +break ; +default : +WARN_ON_ONCE (1 ); + ret = -EINVAL ; + } +if (!ret) +return MMC_REQ_STARTED ; +mmc_queue_clr_special (req); +return ret == -EBUSY ?MMC_REQ_BUSY :MMC_REQ_FAILED_TO_START ; +default : +WARN_ON_ONCE (1 ); +return MMC_REQ_FAILED_TO_START ; + } +} +static void mmc_blk_issue_rw_rq (struct mmc_queue *mq,struct request *req) {struct mmc_blk_data *md = mq->blkdata;
@@ -2473,7 +2673,7 @@ static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,INIT_LIST_HEAD (&md->part); md->usage =1 ; - ret =mmc_init_queue (&md->queue, card, &md->lock, subname); + ret =mmc_init_queue (&md->queue, card, &md->lock, subname, area_type);if (ret) goto err_putdisk;
drivers/mmc/core/block.h +7 -0
@@ -6,4 +6,11 @@void mmc_blk_issue_rq (struct mmc_queue *mq,struct request *req); +enum mmc_issued ; + +enum mmc_issued mmc_blk_cqe_issue_rq (struct mmc_queue *mq, +struct request *req); +void mmc_blk_cqe_complete_rq (struct request *rq); +void mmc_blk_cqe_recovery (struct mmc_queue *mq); +#endif
drivers/mmc/core/queue.c +296 -5
331 lines not on this page · raw message
drivers/mmc/core/queue.h +42 -1
70 lines not on this page · raw message
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 24/39 mmc: cqhci: support for command queue enabled host
In reply to Adrian HunterFrom: Venkat Gopalakrishnan <[email protected]>
This patch adds CMDQ support for command-queue compatible hosts.
Command queue is added in eMMC-5.1 specification. This enables the controller to process upto 32 requests at a time.
Adrian Hunter contributed renaming to cqhci, recovery, suspend and resume, cqhci_off, cqhci_wait_for_idle, and external timeout handling.
--- drivers/mmc/host/Kconfig | 13 + drivers/mmc/host/Makefile | 1 + drivers/mmc/host/cqhci.c | 1148 +++++++++++++++++++++++++++++++++++++++++++++ drivers/mmc/host/cqhci.h | 228 +++++++++ 4 files changed, 1390 insertions(+) create mode 100644 drivers/mmc/host/cqhci.c create mode 100644 drivers/mmc/host/cqhci.h
drivers/mmc/host/Kconfig +13 -0
@@ -794,6 +794,19 @@ config MMC_SUNXI This selects support for the SD/MMC Host Controller on Allwinner sunxi SoCs. +config MMC_CQHCI + tristate "Command Queue Host Controller Interface support" + depends on HAS_DMA + help + This selects the Command Queue Host Controller Interface (CQHCI) + support present in host controllers of Qualcomm Technologies, Inc + amongst others. + This controller supports eMMC devices with command queue support. + + If you have a controller with this interface, say Y or M here. + + If unsure, say N. + config MMC_TOSHIBA_PCI tristate "Toshiba Type A SD/MMC Card Interface Driver" depends on PCI
drivers/mmc/host/Makefile +1 -0
@@ -79,6 +79,7 @@ obj-$(CONFIG_MMC_SDHCI_MSM) += sdhci-msm.o obj-$(CONFIG_MMC_SDHCI_ST) += sdhci-st.o obj-$(CONFIG_MMC_SDHCI_MICROCHIP_PIC32) += sdhci-pic32.o obj-$(CONFIG_MMC_SDHCI_BRCMSTB) += sdhci-brcmstb.o +obj-$(CONFIG_MMC_CQHCI) += cqhci.o ifeq ($(CONFIG_CB710_DEBUG),y) CFLAGS-cb710-mmc += -DDEBUG
drivers/mmc/host/cqhci.c new file +1148 -0
1,148 lines not on this page · raw message
drivers/mmc/host/cqhci.h new file +228 -0
228 lines not on this page · raw message
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 25/39 mmc: sdhci: Improve debug print format
In reply to Adrian HunterEnsure all debug prints start with the mmc host name.
--- drivers/mmc/host/sdhci.c | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-)
drivers/mmc/host/sdhci.c +12 -16
@@ -37,7 +37,7 @@#define DRIVER_NAME "sdhci" #define DBG(f, x...) \ - pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x) + pr_debug("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)#define MAX_TUNING_LOOP 40
@@ -715,8 +715,8 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd) }if (count >=0xF ) { -DBG ("%s: Too large timeout 0x%x requested for CMD%d!\n" , -mmc_hostname (host->mmc), count, cmd->opcode); +DBG ("Too large timeout 0x%x requested for CMD%d!\n" , + count, cmd->opcode); count =0xE ; }
@@ -2509,7 +2509,6 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)#ifdef CONFIG_MMC_DEBUG static void sdhci_adma_show_error (struct sdhci_host *host) { -const char *name =mmc_hostname (host->mmc);void *desc = host->adma_table;sdhci_dumpregs (host);
@@ -2518,14 +2517,14 @@ static void sdhci_adma_show_error(struct sdhci_host *host)struct sdhci_adma2_64_desc *dma_desc = desc;if (host->flags &SDHCI_USE_64_BIT_DMA ) -DBG ("%s: %p: DMA 0x%08x%08x, LEN 0x%04x, Attr=0x%02x\n" , - name, desc,le32_to_cpu (dma_desc->addr_hi), +DBG ("%p: DMA 0x%08x%08x, LEN 0x%04x, Attr=0x%02x\n" , + desc,le32_to_cpu (dma_desc->addr_hi),le32_to_cpu (dma_desc->addr_lo),le16_to_cpu (dma_desc->len),le16_to_cpu (dma_desc->cmd));else -DBG ("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n" , - name, desc,le32_to_cpu (dma_desc->addr_lo), +DBG ("%p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n" , + desc,le32_to_cpu (dma_desc->addr_lo),le16_to_cpu (dma_desc->len),le16_to_cpu (dma_desc->cmd));
@@ -2641,10 +2640,8 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask) ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1)) +SDHCI_DEFAULT_BOUNDARY_SIZE ; host->data->bytes_xfered = dmanow - dmastart; -DBG ("%s: DMA base 0x%08x, transferred 0x%06x bytes," -" next 0x%08x\n" , -mmc_hostname (host->mmc), dmastart, - host->data->bytes_xfered, dmanow); +DBG ("DMA base 0x%08x, transferred 0x%06x bytes, next 0x%08x\n" , + dmastart, host->data->bytes_xfered, dmanow);sdhci_writel (host, dmanow,SDHCI_DMA_ADDRESS ); }
@@ -2689,8 +2686,7 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id) SDHCI_INT_BUS_POWER);sdhci_writel (host, mask,SDHCI_INT_STATUS ); -DBG ("*** %s got interrupt: 0x%08x\n" , -mmc_hostname (host->mmc), intmask); +DBG ("IRQ status 0x%08x\n" , intmask);if (intmask & (SDHCI_INT_CARD_INSERT |SDHCI_INT_CARD_REMOVE )) { u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
@@ -3324,9 +3320,9 @@ int sdhci_setup_host(struct sdhci_host *host) !(host->flags & SDHCI_USE_SDMA)) && !(host->quirks2 & SDHCI_QUIRK2_ACMD23_BROKEN)) { host->flags |= SDHCI_AUTO_CMD23; - DBG("%s: Auto-CMD23 available\n", mmc_hostname(mmc)); + DBG("Auto-CMD23 available\n"); } else { -DBG ("%s: Auto-CMD23 unavailable\n" ,mmc_hostname (mmc)); +DBG ("Auto-CMD23 unavailable\n" ); }/*
Signature · 1 line
1.9.1
Re: [PATCH RFC 25/39] mmc: sdhci: Improve debug print format
Quoted 3 lines · Adrian Hunter
Ensure all debug prints start with the mmc host name.
Signed-off-by Adrian Hunter <[email protected]>
There seems to be a bunch of sdhci improvements/cleanups, not closely relate to the CMDQ support. May suggest you send these in a separate series, so we can apply them first.
Like this one.
Kind regards
Uffe
Quoted 93 lines
--- drivers/mmc/host/sdhci.c | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-)drivers/mmc/host/sdhci.c +12
-17@@ -37,7 +37,7 @@#define DRIVER_NAME "sdhci" #define DBG(f, x...) \ - pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x) + pr_debug("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)#define MAX_TUNING_LOOP 40@@ -715,8 +715,8 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd) }if (count >=0xF ) { -DBG ("%s: Too large timeout 0x%x requested for CMD%d!\n" , -mmc_hostname (host->mmc), count, cmd->opcode); +DBG ("Too large timeout 0x%x requested for CMD%d!\n" , + count, cmd->opcode); count =0xE ; }@@ -2509,7 +2509,6 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)#ifdef CONFIG_MMC_DEBUG static void sdhci_adma_show_error (struct sdhci_host *host) { -const char *name =mmc_hostname (host->mmc);void *desc = host->adma_table;sdhci_dumpregs (host);@@ -2518,14 +2517,14 @@ static void sdhci_adma_show_error(struct sdhci_host *host)struct sdhci_adma2_64_desc *dma_desc = desc;if (host->flags &SDHCI_USE_64_BIT_DMA ) -DBG ("%s: %p: DMA 0x%08x%08x, LEN 0x%04x, Attr=0x%02x\n" , - name, desc,le32_to_cpu (dma_desc->addr_hi), +DBG ("%p: DMA 0x%08x%08x, LEN 0x%04x, Attr=0x%02x\n" , + desc,le32_to_cpu (dma_desc->addr_hi),le32_to_cpu (dma_desc->addr_lo),le16_to_cpu (dma_desc->len),le16_to_cpu (dma_desc->cmd));else -DBG ("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n" , - name, desc,le32_to_cpu (dma_desc->addr_lo), +DBG ("%p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n" , + desc,le32_to_cpu (dma_desc->addr_lo),le16_to_cpu (dma_desc->len),le16_to_cpu (dma_desc->cmd));@@ -2641,10 +2640,8 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask) ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1)) +SDHCI_DEFAULT_BOUNDARY_SIZE ; host->data->bytes_xfered = dmanow - dmastart; -DBG ("%s: DMA base 0x%08x, transferred 0x%06x bytes," -" next 0x%08x\n" , -mmc_hostname (host->mmc), dmastart, - host->data->bytes_xfered, dmanow); +DBG ("DMA base 0x%08x, transferred 0x%06x bytes, next 0x%08x\n" , + dmastart, host->data->bytes_xfered, dmanow);sdhci_writel (host, dmanow,SDHCI_DMA_ADDRESS ); }@@ -2689,8 +2686,7 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id) SDHCI_INT_BUS_POWER);sdhci_writel (host, mask,SDHCI_INT_STATUS ); -DBG ("*** %s got interrupt: 0x%08x\n" , -mmc_hostname (host->mmc), intmask); +DBG ("IRQ status 0x%08x\n" , intmask);if (intmask & (SDHCI_INT_CARD_INSERT |SDHCI_INT_CARD_REMOVE )) { u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &@@ -3324,9 +3320,9 @@ int sdhci_setup_host(struct sdhci_host *host) !(host->flags & SDHCI_USE_SDMA)) && !(host->quirks2 & SDHCI_QUIRK2_ACMD23_BROKEN)) { host->flags |= SDHCI_AUTO_CMD23; - DBG("%s: Auto-CMD23 available\n", mmc_hostname(mmc)); + DBG("Auto-CMD23 available\n"); } else { -DBG ("%s: Auto-CMD23 unavailable\n" ,mmc_hostname (mmc)); +DBG ("Auto-CMD23 unavailable\n" ); }/* -- 1.9.1
Adrian Hunter
maintainerRFC PATCH 26/39 mmc: sdhci: Add response register to register dump
In reply to Adrian HunterAdd response register to register dump.
--- drivers/mmc/host/sdhci.c | 7 +++++++ 1 file changed, 7 insertions(+)
drivers/mmc/host/sdhci.c +7 -0
@@ -86,6 +86,13 @@ static void sdhci_dumpregs(struct sdhci_host *host)pr_err (DRIVER_NAME ": Cmd: 0x%08x | Max curr: 0x%08x\n" ,sdhci_readw (host,SDHCI_COMMAND ),sdhci_readl (host,SDHCI_MAX_CURRENT )); +pr_err (DRIVER_NAME ": Resp[0]: 0x%08x | Resp[1]: 0x%08x\n" , +sdhci_readl (host,SDHCI_RESPONSE ), +sdhci_readl (host,SDHCI_RESPONSE +4 )); +pr_err (DRIVER_NAME ": Resp[2]: 0x%08x | Resp[3]: 0x%08x\n" , +sdhci_readl (host,SDHCI_RESPONSE +8 ), +sdhci_readl (host,SDHCI_RESPONSE +12 )); +pr_err (DRIVER_NAME ": Host ctl2: 0x%08x\n" ,sdhci_readw (host,SDHCI_HOST_CONTROL2 ));
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 27/39 mmc: sdhci: Improve register dump print format
In reply to Adrian HunterEnsure all prints start with the mmc host name, and the text all lines up.
--- drivers/mmc/host/sdhci.c | 104 ++++++++++++++++++++++++----------------------- 1 file changed, 53 insertions(+), 51 deletions(-)
drivers/mmc/host/sdhci.c +53 -51
@@ -39,6 +39,9 @@ #define DBG(f, x...) \ pr_debug("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x) +#define SDHCI_DUMP(f, x...) \ + pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x) +#define MAX_TUNING_LOOP 40static unsigned int debug_quirks =0 ;
@@ -50,65 +53,64 @@static void sdhci_dumpregs (struct sdhci_host *host) { -pr_err (DRIVER_NAME ": =========== REGISTER DUMP (%s)===========\n" , -mmc_hostname (host->mmc)); - -pr_err (DRIVER_NAME ": Sys addr: 0x%08x | Version: 0x%08x\n" , -sdhci_readl (host,SDHCI_DMA_ADDRESS ), -sdhci_readw (host,SDHCI_HOST_VERSION )); -pr_err (DRIVER_NAME ": Blk size: 0x%08x | Blk cnt: 0x%08x\n" , -sdhci_readw (host,SDHCI_BLOCK_SIZE ), -sdhci_readw (host,SDHCI_BLOCK_COUNT )); -pr_err (DRIVER_NAME ": Argument: 0x%08x | Trn mode: 0x%08x\n" , -sdhci_readl (host,SDHCI_ARGUMENT ), -sdhci_readw (host,SDHCI_TRANSFER_MODE )); -pr_err (DRIVER_NAME ": Present: 0x%08x | Host ctl: 0x%08x\n" , -sdhci_readl (host,SDHCI_PRESENT_STATE ), -sdhci_readb (host,SDHCI_HOST_CONTROL )); -pr_err (DRIVER_NAME ": Power: 0x%08x | Blk gap: 0x%08x\n" , -sdhci_readb (host,SDHCI_POWER_CONTROL ), -sdhci_readb (host,SDHCI_BLOCK_GAP_CONTROL )); -pr_err (DRIVER_NAME ": Wake-up: 0x%08x | Clock: 0x%08x\n" , -sdhci_readb (host,SDHCI_WAKE_UP_CONTROL ), -sdhci_readw (host,SDHCI_CLOCK_CONTROL )); -pr_err (DRIVER_NAME ": Timeout: 0x%08x | Int stat: 0x%08x\n" , -sdhci_readb (host,SDHCI_TIMEOUT_CONTROL ), -sdhci_readl (host,SDHCI_INT_STATUS )); -pr_err (DRIVER_NAME ": Int enab: 0x%08x | Sig enab: 0x%08x\n" , -sdhci_readl (host,SDHCI_INT_ENABLE ), -sdhci_readl (host,SDHCI_SIGNAL_ENABLE )); -pr_err (DRIVER_NAME ": AC12 err: 0x%08x | Slot int: 0x%08x\n" , -sdhci_readw (host,SDHCI_ACMD12_ERR ), -sdhci_readw (host,SDHCI_SLOT_INT_STATUS )); -pr_err (DRIVER_NAME ": Caps: 0x%08x | Caps_1: 0x%08x\n" , -sdhci_readl (host,SDHCI_CAPABILITIES ), -sdhci_readl (host,SDHCI_CAPABILITIES_1 )); -pr_err (DRIVER_NAME ": Cmd: 0x%08x | Max curr: 0x%08x\n" , -sdhci_readw (host,SDHCI_COMMAND ), -sdhci_readl (host,SDHCI_MAX_CURRENT )); -pr_err (DRIVER_NAME ": Resp[0]: 0x%08x | Resp[1]: 0x%08x\n" , +SDHCI_DUMP ("============ SDHCI REGISTER DUMP ===========\n" ); + +SDHCI_DUMP ("Sys addr: 0x%08x | Version: 0x%08x\n" , +sdhci_readl (host,SDHCI_DMA_ADDRESS ), +sdhci_readw (host,SDHCI_HOST_VERSION )); +SDHCI_DUMP ("Blk size: 0x%08x | Blk cnt: 0x%08x\n" , +sdhci_readw (host,SDHCI_BLOCK_SIZE ), +sdhci_readw (host,SDHCI_BLOCK_COUNT )); +SDHCI_DUMP ("Argument: 0x%08x | Trn mode: 0x%08x\n" , +sdhci_readl (host,SDHCI_ARGUMENT ), +sdhci_readw (host,SDHCI_TRANSFER_MODE )); +SDHCI_DUMP ("Present: 0x%08x | Host ctl: 0x%08x\n" , +sdhci_readl (host,SDHCI_PRESENT_STATE ), +sdhci_readb (host,SDHCI_HOST_CONTROL )); +SDHCI_DUMP ("Power: 0x%08x | Blk gap: 0x%08x\n" , +sdhci_readb (host,SDHCI_POWER_CONTROL ), +sdhci_readb (host,SDHCI_BLOCK_GAP_CONTROL )); +SDHCI_DUMP ("Wake-up: 0x%08x | Clock: 0x%08x\n" , +sdhci_readb (host,SDHCI_WAKE_UP_CONTROL ), +sdhci_readw (host,SDHCI_CLOCK_CONTROL )); +SDHCI_DUMP ("Timeout: 0x%08x | Int stat: 0x%08x\n" , +sdhci_readb (host,SDHCI_TIMEOUT_CONTROL ), +sdhci_readl (host,SDHCI_INT_STATUS )); +SDHCI_DUMP ("Int enab: 0x%08x | Sig enab: 0x%08x\n" , +sdhci_readl (host,SDHCI_INT_ENABLE ), +sdhci_readl (host,SDHCI_SIGNAL_ENABLE )); +SDHCI_DUMP ("AC12 err: 0x%08x | Slot int: 0x%08x\n" , +sdhci_readw (host,SDHCI_ACMD12_ERR ), +sdhci_readw (host,SDHCI_SLOT_INT_STATUS )); +SDHCI_DUMP ("Caps: 0x%08x | Caps_1: 0x%08x\n" , +sdhci_readl (host,SDHCI_CAPABILITIES ), +sdhci_readl (host,SDHCI_CAPABILITIES_1 )); +SDHCI_DUMP ("Cmd: 0x%08x | Max curr: 0x%08x\n" , +sdhci_readw (host,SDHCI_COMMAND ), +sdhci_readl (host,SDHCI_MAX_CURRENT )); +SDHCI_DUMP ("Resp[0]: 0x%08x | Resp[1]: 0x%08x\n" ,sdhci_readl (host,SDHCI_RESPONSE ),sdhci_readl (host,SDHCI_RESPONSE +4 )); -pr_err (DRIVER_NAME ": Resp[2]: 0x%08x | Resp[3]: 0x%08x\n" , +SDHCI_DUMP ("Resp[2]: 0x%08x | Resp[3]: 0x%08x\n" ,sdhci_readl (host,SDHCI_RESPONSE +8 ),sdhci_readl (host,SDHCI_RESPONSE +12 )); - -pr_err (DRIVER_NAME ": Host ctl2: 0x%08x\n" , -sdhci_readw (host,SDHCI_HOST_CONTROL2 )); +SDHCI_DUMP ("Host ctl2: 0x%08x\n" , +sdhci_readw (host,SDHCI_HOST_CONTROL2 ));if (host->flags &SDHCI_USE_ADMA ) { -if (host->flags &SDHCI_USE_64_BIT_DMA ) -pr_err (DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x%08x\n" , -readl (host->ioaddr +SDHCI_ADMA_ERROR ), -readl (host->ioaddr +SDHCI_ADMA_ADDRESS_HI ), -readl (host->ioaddr +SDHCI_ADMA_ADDRESS )); -else -pr_err (DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n" , -readl (host->ioaddr +SDHCI_ADMA_ERROR ), -readl (host->ioaddr +SDHCI_ADMA_ADDRESS )); +if (host->flags &SDHCI_USE_64_BIT_DMA ) { +SDHCI_DUMP ("ADMA Err: 0x%08x | ADMA Ptr: 0x%08x%08x\n" , +readl (host->ioaddr +SDHCI_ADMA_ERROR ), +readl (host->ioaddr +SDHCI_ADMA_ADDRESS_HI ), +readl (host->ioaddr +SDHCI_ADMA_ADDRESS )); + }else { +SDHCI_DUMP ("ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n" , +readl (host->ioaddr +SDHCI_ADMA_ERROR ), +readl (host->ioaddr +SDHCI_ADMA_ADDRESS )); + } } -pr_err (DRIVER_NAME ": ===========================================\n" ); +SDHCI_DUMP ("============================================\n" ); }/*****************************************************************************\
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 28/39 mmc: sdhci: Export sdhci_dumpregs
In reply to Adrian HunterExport sdhci_dumpregs so that it can be called by drivers.
--- drivers/mmc/host/sdhci.c | 3 ++- drivers/mmc/host/sdhci.h | 2 ++ 2 files changed, 4 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci.c +2 -1
@@ -51,7 +51,7 @@static void sdhci_enable_preset_value (struct sdhci_host *host,bool enable); -static void sdhci_dumpregs (struct sdhci_host *host) +void sdhci_dumpregs (struct sdhci_host *host) {SDHCI_DUMP ("============ SDHCI REGISTER DUMP ===========\n" );
@@ -112,6 +112,7 @@ static void sdhci_dumpregs(struct sdhci_host *host)SDHCI_DUMP ("============================================\n" ); } +EXPORT_SYMBOL_GPL (sdhci_dumpregs);/*****************************************************************************\ * *
drivers/mmc/host/sdhci.h +2 -0
@@ -702,4 +702,6 @@ void sdhci_set_power_noreg(struct sdhci_host *host, unsigned char mode,extern int sdhci_runtime_resume_host (struct sdhci_host *host);#endif +void sdhci_dumpregs (struct sdhci_host *host); +#endif /* __SDHCI_HW_H */
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 29/39 mmc: sdhci: Get rid of 'extern' in header file
In reply to Adrian HunterGet rid of unnecessary 'extern' in header file.
--- drivers/mmc/host/sdhci.h | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-)
drivers/mmc/host/sdhci.h +15 -17
@@ -652,24 +652,22 @@ static inline u8 sdhci_readb(struct sdhci_host *host, int reg)#endif /* CONFIG_MMC_SDHCI_IO_ACCESSORS */ -extern struct sdhci_host *sdhci_alloc_host (struct device *dev, -size_t priv_size); -extern void sdhci_free_host (struct sdhci_host *host); +struct sdhci_host *sdhci_alloc_host (struct device *dev,size_t priv_size); +void sdhci_free_host (struct sdhci_host *host);static inline void *sdhci_priv (struct sdhci_host *host) {return host->private; } -extern void sdhci_card_detect (struct sdhci_host *host); -extern void __sdhci_read_caps (struct sdhci_host *host,u16 *ver,u32 *caps, -u32 *caps1); -extern int sdhci_setup_host (struct sdhci_host *host); -extern int __sdhci_add_host (struct sdhci_host *host); -extern int sdhci_add_host (struct sdhci_host *host); -extern void sdhci_remove_host (struct sdhci_host *host,int dead); -extern void sdhci_send_command (struct sdhci_host *host, -struct mmc_command *cmd); +void sdhci_card_detect (struct sdhci_host *host); +void __sdhci_read_caps (struct sdhci_host *host,u16 *ver,u32 *caps, +u32 *caps1); +int sdhci_setup_host (struct sdhci_host *host); +int __sdhci_add_host (struct sdhci_host *host); +int sdhci_add_host (struct sdhci_host *host); +void sdhci_remove_host (struct sdhci_host *host,int dead); +void sdhci_send_command (struct sdhci_host *host,struct mmc_command *cmd);static inline void sdhci_read_caps (struct sdhci_host *host) {
@@ -695,11 +693,11 @@ void sdhci_set_power_noreg(struct sdhci_host *host, unsigned char mode,int sdhci_execute_tuning (struct mmc_host *mmc,u32 opcode);#ifdef CONFIG_PM -extern int sdhci_suspend_host (struct sdhci_host *host); -extern int sdhci_resume_host (struct sdhci_host *host); -extern void sdhci_enable_irq_wakeups (struct sdhci_host *host); -extern int sdhci_runtime_suspend_host (struct sdhci_host *host); -extern int sdhci_runtime_resume_host (struct sdhci_host *host); +int sdhci_suspend_host (struct sdhci_host *host); +int sdhci_resume_host (struct sdhci_host *host); +void sdhci_enable_irq_wakeups (struct sdhci_host *host); +int sdhci_runtime_suspend_host (struct sdhci_host *host); +int sdhci_runtime_resume_host (struct sdhci_host *host);#endif void sdhci_dumpregs (struct sdhci_host *host);
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 30/39 mmc: sdhci: Add sdhci_cleanup_host
In reply to Adrian HunterAdd sdhci_cleanup_host() to cleanup __sdhci_add_host().
--- drivers/mmc/host/sdhci.c | 37 ++++++++++++++++++++++++++----------- drivers/mmc/host/sdhci.h | 1 + 2 files changed, 27 insertions(+), 11 deletions(-)
drivers/mmc/host/sdhci.c +26 -11
@@ -3596,6 +3596,22 @@ int sdhci_setup_host(struct sdhci_host *host) }EXPORT_SYMBOL_GPL (sdhci_setup_host); +void sdhci_cleanup_host (struct sdhci_host *host) +{ +struct mmc_host *mmc = host->mmc; + +if (!IS_ERR (mmc->supply.vqmmc)) +regulator_disable (mmc->supply.vqmmc); + +if (host->align_buffer) +dma_free_coherent (mmc_dev (mmc), host->align_buffer_sz + + host->adma_table_sz, host->align_buffer, + host->align_addr); + host->adma_table =NULL ; + host->align_buffer =NULL ; +} +EXPORT_SYMBOL_GPL (sdhci_cleanup_host); +int __sdhci_add_host (struct sdhci_host *host) {struct mmc_host *mmc = host->mmc;
@@ -3660,16 +3676,6 @@ int __sdhci_add_host(struct sdhci_host *host) untasklet:tasklet_kill (&host->finish_tasklet); -if (!IS_ERR (mmc->supply.vqmmc)) -regulator_disable (mmc->supply.vqmmc); - -if (host->align_buffer) -dma_free_coherent (mmc_dev (mmc), host->align_buffer_sz + - host->adma_table_sz, host->align_buffer, - host->align_addr); - host->adma_table =NULL ; - host->align_buffer =NULL ; -return ret; }EXPORT_SYMBOL_GPL (__sdhci_add_host);
@@ -3682,7 +3688,16 @@ int sdhci_add_host(struct sdhci_host *host)if (ret)return ret; -return __sdhci_add_host (host); + ret =__sdhci_add_host (host); +if (ret) + goto cleanup; + +return 0 ; + +cleanup: +sdhci_cleanup_host (host); + +return ret; }EXPORT_SYMBOL_GPL (sdhci_add_host);
drivers/mmc/host/sdhci.h +1 -0
@@ -664,6 +664,7 @@ static inline void *sdhci_priv(struct sdhci_host *host)void __sdhci_read_caps (struct sdhci_host *host,u16 *ver,u32 *caps,u32 *caps1);int sdhci_setup_host (struct sdhci_host *host); +void sdhci_cleanup_host (struct sdhci_host *host);int __sdhci_add_host (struct sdhci_host *host);int sdhci_add_host (struct sdhci_host *host);void sdhci_remove_host (struct sdhci_host *host,int dead);
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 31/39 mmc: sdhci: Factor out sdhci_set_default_irqs
In reply to Adrian HunterFactor out sdhci_set_default_irqs().
--- drivers/mmc/host/sdhci.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/mmc/host/sdhci.c +13 -8
@@ -225,15 +225,8 @@ static void sdhci_do_reset(struct sdhci_host *host, u8 mask) } } -static void sdhci_init (struct sdhci_host *host,int soft) +static void sdhci_set_default_irqs (struct sdhci_host *host) { -struct mmc_host *mmc = host->mmc; - -if (soft) -sdhci_do_reset (host,SDHCI_RESET_CMD |SDHCI_RESET_DATA ); -else -sdhci_do_reset (host,SDHCI_RESET_ALL ); - host->ier =SDHCI_INT_BUS_POWER |SDHCI_INT_DATA_END_BIT |SDHCI_INT_DATA_CRC |SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_INDEX | SDHCI_INT_END_BIT | SDHCI_INT_CRC |
@@ -246,6 +239,18 @@ static void sdhci_init(struct sdhci_host *host, int soft)sdhci_writel (host, host->ier,SDHCI_INT_ENABLE );sdhci_writel (host, host->ier,SDHCI_SIGNAL_ENABLE ); +} + +static void sdhci_init (struct sdhci_host *host,int soft) +{ +struct mmc_host *mmc = host->mmc; + +if (soft) +sdhci_do_reset (host,SDHCI_RESET_CMD |SDHCI_RESET_DATA ); +else +sdhci_do_reset (host,SDHCI_RESET_ALL ); + +sdhci_set_default_irqs (host);if (soft) {/* force clock reconfiguration */
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 32/39 mmc: sdhci: Add CQE support
In reply to Adrian HunterAdd an interrupt hook and helper functions for enabling, disabling and delivering interrupts to a CQE.
--- drivers/mmc/host/sdhci.c | 130 +++++++++++++++++++++++++++++++++++++++++++++-- drivers/mmc/host/sdhci.h | 19 +++++++ 2 files changed, 146 insertions(+), 3 deletions(-)
drivers/mmc/host/sdhci.c +127 -3
@@ -252,6 +252,8 @@ static void sdhci_init(struct sdhci_host *host, int soft)sdhci_set_default_irqs (host); + host->cqe_on = false; +if (soft) {/* force clock reconfiguration */ host->clock =0 ;
@@ -2696,13 +2698,19 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id) } do { + DBG("IRQ status 0x%08x\n", intmask); + + if (host->ops->irq) { + intmask = host->ops->irq(host, intmask); + if (!intmask) + goto cont; + } + /* Clear selected interrupts. */ mask = intmask & (SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK | SDHCI_INT_BUS_POWER); sdhci_writel(host, mask, SDHCI_INT_STATUS); - DBG("IRQ status 0x%08x\n", intmask); - if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) { u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT;
@@ -2762,7 +2770,7 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id) unexpected |= intmask;sdhci_writel (host, intmask,SDHCI_INT_STATUS ); } - +cont:if (result ==IRQ_NONE ) result =IRQ_HANDLED ;
@@ -2995,6 +3003,119 @@ int sdhci_runtime_resume_host(struct sdhci_host *host)/*****************************************************************************\ * * +* Command Queue Engine (CQE) helpers * +* * +\*****************************************************************************/ + +void sdhci_cqe_enable (struct mmc_host *mmc) +{ +struct sdhci_host *host =mmc_priv (mmc); +unsigned long flags; +u8 ctrl; + +spin_lock_irqsave (&host->lock, flags); + + ctrl =sdhci_readb (host,SDHCI_HOST_CONTROL ); + ctrl &= ~SDHCI_CTRL_DMA_MASK ; +if (host->flags &SDHCI_USE_64_BIT_DMA ) + ctrl |=SDHCI_CTRL_ADMA64 ; +else + ctrl |=SDHCI_CTRL_ADMA32 ; +sdhci_writeb (host, ctrl,SDHCI_HOST_CONTROL ); + +sdhci_writew (host,SDHCI_MAKE_BLKSZ (SDHCI_DEFAULT_BOUNDARY_ARG ,512 ), +SDHCI_BLOCK_SIZE ); + +/* Set maximum timeout */ +sdhci_writeb (host,0xE ,SDHCI_TIMEOUT_CONTROL ); + + host->ier = host->cqe_ier; + +sdhci_writel (host, host->ier,SDHCI_INT_ENABLE ); +sdhci_writel (host, host->ier,SDHCI_SIGNAL_ENABLE ); + + host->cqe_on = true; + +pr_debug ("%s: sdhci: CQE on, IRQ mask %#x, IRQ status %#x\n" , +mmc_hostname (mmc), host->ier, +sdhci_readl (host,SDHCI_INT_STATUS )); + +mmiowb (); +spin_unlock_irqrestore (&host->lock, flags); +} +EXPORT_SYMBOL_GPL (sdhci_cqe_enable); + +void sdhci_cqe_disable (struct mmc_host *mmc,bool recovery) +{ +struct sdhci_host *host =mmc_priv (mmc); +unsigned long flags; + +spin_lock_irqsave (&host->lock, flags); + +sdhci_set_default_irqs (host); + + host->cqe_on = false; + +if (recovery) { +sdhci_do_reset (host,SDHCI_RESET_CMD ); +sdhci_do_reset (host,SDHCI_RESET_DATA ); + } + +pr_debug ("%s: sdhci: CQE off, IRQ mask %#x, IRQ status %#x\n" , +mmc_hostname (mmc), host->ier, +sdhci_readl (host,SDHCI_INT_STATUS )); + +mmiowb (); +spin_unlock_irqrestore (&host->lock, flags); +} +EXPORT_SYMBOL_GPL (sdhci_cqe_disable); + +bool sdhci_cqe_irq (struct sdhci_host *host,u32 intmask,int *cmd_error, +int *data_error) +{ +u32 mask; + +if (!host->cqe_on) +return false; + +if (intmask & (SDHCI_INT_INDEX |SDHCI_INT_END_BIT |SDHCI_INT_CRC )) + *cmd_error = -EILSEQ ; +else if (intmask &SDHCI_INT_TIMEOUT ) + *cmd_error = -ETIMEDOUT ; +else + *cmd_error =0 ; + +if (intmask & (SDHCI_INT_DATA_END_BIT |SDHCI_INT_DATA_CRC )) + *data_error = -EILSEQ ; +else if (intmask &SDHCI_INT_DATA_TIMEOUT ) + *data_error = -ETIMEDOUT ; +else if (intmask &SDHCI_INT_ADMA_ERROR ) + *data_error = -EIO ; +else + *data_error =0 ; + +/* Clear selected interrupts. */ + mask = intmask & host->cqe_ier; +sdhci_writel (host, mask,SDHCI_INT_STATUS ); + +if (intmask &SDHCI_INT_BUS_POWER ) +pr_err ("%s: Card is consuming too much power!\n" , +mmc_hostname (host->mmc)); + + intmask &= ~(host->cqe_ier |SDHCI_INT_ERROR ); +if (intmask) { +sdhci_writel (host, intmask,SDHCI_INT_STATUS ); +pr_err ("%s: CQE: Unexpected interrupt 0x%08x.\n" , +mmc_hostname (host->mmc), intmask); +sdhci_dumpregs (host); + } + +return true; +} +EXPORT_SYMBOL_GPL (sdhci_cqe_irq); + +/*****************************************************************************\ +* * * Device allocation/registration * * * \*****************************************************************************/
@@ -3018,6 +3139,9 @@ struct sdhci_host *sdhci_alloc_host(struct device *dev, host->flags =SDHCI_SIGNALING_330 ; + host->cqe_ier =SDHCI_CQE_INT_MASK ; + host->cqe_err_ier =SDHCI_CQE_INT_ERR_MASK ; +return host; }
drivers/mmc/host/sdhci.h +19 -0
@@ -134,6 +134,7 @@#define SDHCI_INT_CARD_REMOVE 0x00000080#define SDHCI_INT_CARD_INT 0x00000100#define SDHCI_INT_RETUNE 0x00001000 +#define SDHCI_INT_CQE 0x00004000#define SDHCI_INT_ERROR 0x00008000#define SDHCI_INT_TIMEOUT 0x00010000#define SDHCI_INT_CRC 0x00020000
@@ -158,6 +159,13 @@ SDHCI_INT_BLK_GAP)#define SDHCI_INT_ALL_MASK ((unsigned int)-1) +#define SDHCI_CQE_INT_ERR_MASK ( \ + SDHCI_INT_ADMA_ERROR | SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT | \ + SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_INDEX | \ + SDHCI_INT_END_BIT | SDHCI_INT_CRC | SDHCI_INT_TIMEOUT) + +#define SDHCI_CQE_INT_MASK (SDHCI_CQE_INT_ERR_MASK | SDHCI_INT_CQE) +#define SDHCI_ACMD12_ERR 0x3C#define SDHCI_HOST_CONTROL2 0x3E
@@ -518,6 +526,10 @@ struct sdhci_host {/* cached registers */ u32 ier; +bool cqe_on;/* CQE is operating */ +u32 cqe_ier;/* CQE interrupt mask */ +u32 cqe_err_ier;/* CQE error interrupt mask */ +wait_queue_head_t buf_ready_int;/* Waitqueue for Buffer Read Ready interrupt */ unsigned int tuning_done;/* Condition flag set when CMD19 succeeds */
@@ -544,6 +556,8 @@ struct sdhci_ops {void (*set_power)(struct sdhci_host *host,unsigned char mode,unsigned short vdd); +u32 (*irq)(struct sdhci_host *host,u32 intmask); +int (*enable_dma)(struct sdhci_host *host);unsigned int (*get_max_clock)(struct sdhci_host *host);unsigned int (*get_min_clock)(struct sdhci_host *host);
@@ -701,6 +715,11 @@ void sdhci_set_power_noreg(struct sdhci_host *host, unsigned char mode,int sdhci_runtime_resume_host (struct sdhci_host *host);#endif +void sdhci_cqe_enable (struct mmc_host *mmc); +void sdhci_cqe_disable (struct mmc_host *mmc,bool recovery); +bool sdhci_cqe_irq (struct sdhci_host *host,u32 intmask,int *cmd_error, +int *data_error); +void sdhci_dumpregs (struct sdhci_host *host);#endif /* __SDHCI_HW_H */
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 33/39 mmc: sdhci-pci: Let devices define how to add the host
In reply to Adrian HunterSDHCI provides more flexibility than simply calling sdhci_add_host(). Make that available by allowing devices to specify their own ->add_host() function.
--- drivers/mmc/host/sdhci-pci-core.c | 5 ++++- drivers/mmc/host/sdhci-pci.h | 1 + 2 files changed, 5 insertions(+), 1 deletion(-)
drivers/mmc/host/sdhci-pci-core.c +4 -1
@@ -1915,7 +1915,10 @@ static struct sdhci_pci_slot *sdhci_pci_probe_slot( } } - ret =sdhci_add_host (host); +if (chip->fixes && chip->fixes->add_host) + ret = chip->fixes->add_host (slot); +else + ret =sdhci_add_host (host);if (ret) goto remove;
drivers/mmc/host/sdhci-pci.h +1 -0
@@ -64,6 +64,7 @@ struct sdhci_pci_fixes {int (*probe) (struct sdhci_pci_chip *);int (*probe_slot) (struct sdhci_pci_slot *); +int (*add_host) (struct sdhci_pci_slot *);void (*remove_slot) (struct sdhci_pci_slot *,int );int (*suspend) (struct sdhci_pci_chip *);
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 34/39 mmc: sdhci-pci: Do not use suspend/resume callbacks with runtime pm
In reply to Adrian HunterDo not use suspend/resume callbacks with runtime pm. It doesn't make sense and isn't being used, so remove.
--- drivers/mmc/host/sdhci-pci-core.c | 12 ------------ 1 file changed, 12 deletions(-)
drivers/mmc/host/sdhci-pci-core.c +0 -12
@@ -1750,12 +1750,6 @@ static int sdhci_pci_runtime_suspend(struct device *dev) goto err_pci_runtime_suspend; } -if (chip->fixes && chip->fixes->suspend) { - ret = chip->fixes->suspend (chip); -if (ret) - goto err_pci_runtime_suspend; - } -return 0 ; err_pci_runtime_suspend:
@@ -1775,12 +1769,6 @@ static int sdhci_pci_runtime_resume(struct device *dev)if (!chip)return 0 ; -if (chip->fixes && chip->fixes->resume) { - ret = chip->fixes->resume (chip); -if (ret) -return ret; - } -for (i =0 ; i < chip->num_slots; i++) { slot = chip->slots[i];if (!slot)
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 35/39 mmc: sdhci-pci: Conditionally compile pm sleep functions
In reply to Adrian HunterIt is confusing to have some parts of suspend / resume under conditional compilation and some parts not. Use conditional compilation everywhere.
--- drivers/mmc/host/sdhci-pci-core.c | 10 ++++++++++ drivers/mmc/host/sdhci-pci-o2micro.c | 2 ++ drivers/mmc/host/sdhci-pci.h | 2 ++ 3 files changed, 14 insertions(+)
drivers/mmc/host/sdhci-pci-core.c +10 -0
@@ -71,6 +71,7 @@ static int ricoh_mmc_probe_slot(struct sdhci_pci_slot *slot)return 0 ; } +#ifdef CONFIG_PM_SLEEP static int ricoh_mmc_resume (struct sdhci_pci_chip *chip) {/* Apply a delay to allow controller to settle */
@@ -79,6 +80,7 @@ static int ricoh_mmc_resume(struct sdhci_pci_chip *chip)msleep (500 );return 0 ; } +#endif static const struct sdhci_pci_fixes sdhci_ricoh = { .probe = ricoh_probe,
@@ -89,7 +91,9 @@ static int ricoh_mmc_resume(struct sdhci_pci_chip *chip)static const struct sdhci_pci_fixes sdhci_ricoh_mmc = { .probe_slot = ricoh_mmc_probe_slot, +#ifdef CONFIG_PM_SLEEP .resume = ricoh_mmc_resume, +#endif .quirks =SDHCI_QUIRK_32BIT_DMA_ADDR |SDHCI_QUIRK_CLOCK_BEFORE_RESET | SDHCI_QUIRK_NO_CARD_NO_RESET |
@@ -715,6 +719,7 @@ static void jmicron_remove_slot(struct sdhci_pci_slot *slot, int dead)jmicron_enable_mmc (slot->host,0 ); } +#ifdef CONFIG_PM_SLEEP static int jmicron_suspend (struct sdhci_pci_chip *chip) {int i;
@@ -746,13 +751,16 @@ static int jmicron_resume(struct sdhci_pci_chip *chip)return 0 ; } +#endif static const struct sdhci_pci_fixes sdhci_o2 = { .probe = sdhci_pci_o2_probe, .quirks =SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC , .quirks2 =SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD , .probe_slot = sdhci_pci_o2_probe_slot, +#ifdef CONFIG_PM_SLEEP .resume = sdhci_pci_o2_resume, +#endif };static const struct sdhci_pci_fixes sdhci_jmicron = {
@@ -761,8 +769,10 @@ static int jmicron_resume(struct sdhci_pci_chip *chip) .probe_slot = jmicron_probe_slot, .remove_slot = jmicron_remove_slot, +#ifdef CONFIG_PM_SLEEP .suspend = jmicron_suspend, .resume = jmicron_resume, +#endif };/* SysKonnect CardBus2SDIO extra registers */
drivers/mmc/host/sdhci-pci-o2micro.c +2 -0
@@ -384,8 +384,10 @@ int sdhci_pci_o2_probe(struct sdhci_pci_chip *chip)return 0 ; } +#ifdef CONFIG_PM_SLEEP int sdhci_pci_o2_resume (struct sdhci_pci_chip *chip) {sdhci_pci_o2_probe (chip);return 0 ; } +#endif
drivers/mmc/host/sdhci-pci.h +2 -0
@@ -67,8 +67,10 @@ struct sdhci_pci_fixes {int (*add_host) (struct sdhci_pci_slot *);void (*remove_slot) (struct sdhci_pci_slot *,int ); +#ifdef CONFIG_PM_SLEEP int (*suspend) (struct sdhci_pci_chip *);int (*resume) (struct sdhci_pci_chip *); +#endif const struct sdhci_ops *ops; };
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 36/39 mmc: sdhci-pci: Let suspend/resume callbacks replace default callbacks
In reply to Adrian HunterThe suspend / resume callbacks lack the flexibility to allow a device to specify a different function entirely. Change them around so that device functions are called directly and they in turn can call the default implementations if needed.
--- drivers/mmc/host/sdhci-pci-core.c | 158 +++++++++++++++++++++-------------- drivers/mmc/host/sdhci-pci-o2micro.c | 2 +- drivers/mmc/host/sdhci-pci.h | 4 + 3 files changed, 98 insertions(+), 66 deletions(-)
drivers/mmc/host/sdhci-pci-core.c +93 -65
@@ -41,6 +41,82 @@ static int sdhci_pci_select_drive_strength(struct sdhci_host *host, unsigned int max_dtr, int host_drv, int card_drv, int *drv_type); +#ifdef CONFIG_PM_SLEEP +static int __sdhci_pci_suspend_host (struct sdhci_pci_chip *chip) +{ +int i, ret; + +for (i =0 ; i < chip->num_slots; i++) { +struct sdhci_pci_slot *slot = chip->slots[i]; + +if (!slot) +continue ; + + ret =sdhci_suspend_host (slot->host); +if (ret) + goto err_pci_suspend; + +if (slot->host->mmc->pm_flags &MMC_PM_WAKE_SDIO_IRQ ) +sdhci_enable_irq_wakeups (slot->host); + } + +return 0 ; + +err_pci_suspend: +while (--i >=0 ) +sdhci_resume_host (chip->slots[i]->host); +return ret; +} + +static int sdhci_pci_init_wakeup (struct sdhci_pci_chip *chip) +{ +mmc_pm_flag_t pm_flags =0 ; +int i; + +for (i =0 ; i < chip->num_slots; i++) { +struct sdhci_pci_slot *slot = chip->slots[i]; + +if (slot) + pm_flags |= slot->host->mmc->pm_flags; + } + +return device_init_wakeup (&chip->pdev->dev, + (pm_flags &MMC_PM_KEEP_POWER ) && + (pm_flags &MMC_PM_WAKE_SDIO_IRQ )); +} + +static int sdhci_pci_suspend_host (struct sdhci_pci_chip *chip) +{ +int ret; + + ret =__sdhci_pci_suspend_host (chip); +if (ret) +return ret; + +sdhci_pci_init_wakeup (chip); + +return 0 ; +} + +int sdhci_pci_resume_host (struct sdhci_pci_chip *chip) +{ +struct sdhci_pci_slot *slot; +int i, ret; + +for (i =0 ; i < chip->num_slots; i++) { + slot = chip->slots[i]; +if (!slot) +continue ; + + ret =sdhci_resume_host (slot->host); +if (ret) +return ret; + } + +return 0 ; +} +#endif +/*****************************************************************************\ * * * Hardware specific quirk handling *
@@ -78,7 +154,7 @@ static int ricoh_mmc_resume(struct sdhci_pci_chip *chip)/* Otherwise it becomes confused if card state changed during suspend */ msleep (500 ); - return 0; + return sdhci_pci_resume_host(chip); }#endif
@@ -722,7 +798,11 @@ static void jmicron_remove_slot(struct sdhci_pci_slot *slot, int dead)#ifdef CONFIG_PM_SLEEP static int jmicron_suspend (struct sdhci_pci_chip *chip) { -int i; +int i, ret; + + ret =__sdhci_pci_suspend_host (chip); +if (ret) +return ret;if (chip->pdev->device ==PCI_DEVICE_ID_JMICRON_JMB38X_MMC || chip->pdev->device ==PCI_DEVICE_ID_JMICRON_JMB388_ESD ) {
@@ -730,6 +810,8 @@ static int jmicron_suspend(struct sdhci_pci_chip *chip)jmicron_enable_mmc (chip->slots[i]->host,0 ); } +sdhci_pci_init_wakeup (chip); +return 0 ; }
@@ -749,7 +831,7 @@ static int jmicron_resume(struct sdhci_pci_chip *chip) return ret; } -return 0 ; +return sdhci_pci_resume_host (chip); }#endif
@@ -1657,83 +1739,29 @@ static int sdhci_pci_select_drive_strength(struct sdhci_host *host,static int sdhci_pci_suspend (struct device *dev) {struct pci_dev *pdev =to_pci_dev (dev); -struct sdhci_pci_chip *chip; -struct sdhci_pci_slot *slot; -mmc_pm_flag_t slot_pm_flags; -mmc_pm_flag_t pm_flags =0 ; -int i, ret; +struct sdhci_pci_chip *chip =pci_get_drvdata (pdev); - chip =pci_get_drvdata (pdev);if (!chip)return 0 ; -for (i =0 ; i < chip->num_slots; i++) { - slot = chip->slots[i]; -if (!slot) -continue ; - - ret =sdhci_suspend_host (slot->host); +if (chip->fixes && chip->fixes->suspend) +return chip->fixes->suspend (chip); -if (ret) - goto err_pci_suspend; - - slot_pm_flags = slot->host->mmc->pm_flags; -if (slot_pm_flags &MMC_PM_WAKE_SDIO_IRQ ) -sdhci_enable_irq_wakeups (slot->host); - - pm_flags |= slot_pm_flags; - } - -if (chip->fixes && chip->fixes->suspend) { - ret = chip->fixes->suspend (chip); -if (ret) - goto err_pci_suspend; - } - -if (pm_flags &MMC_PM_KEEP_POWER ) { -if (pm_flags &MMC_PM_WAKE_SDIO_IRQ ) -device_init_wakeup (dev, true); -else -device_init_wakeup (dev, false); - }else -device_init_wakeup (dev, false); - -return 0 ; - -err_pci_suspend: -while (--i >=0 ) -sdhci_resume_host (chip->slots[i]->host); -return ret; +return sdhci_pci_suspend_host (chip); }static int sdhci_pci_resume (struct device *dev) {struct pci_dev *pdev =to_pci_dev (dev); -struct sdhci_pci_chip *chip; -struct sdhci_pci_slot *slot; -int i, ret; +struct sdhci_pci_chip *chip =pci_get_drvdata (pdev); - chip =pci_get_drvdata (pdev);if (!chip)return 0 ; -if (chip->fixes && chip->fixes->resume) { - ret = chip->fixes->resume (chip); -if (ret) -return ret; - } - -for (i =0 ; i < chip->num_slots; i++) { - slot = chip->slots[i]; -if (!slot) -continue ; +if (chip->fixes && chip->fixes->resume) +return chip->fixes->resume (chip); - ret =sdhci_resume_host (slot->host); -if (ret) -return ret; - } - -return 0 ; +return sdhci_pci_resume_host (chip); }#endif
drivers/mmc/host/sdhci-pci-o2micro.c +1 -1
@@ -388,6 +388,6 @@ int sdhci_pci_o2_probe(struct sdhci_pci_chip *chip)int sdhci_pci_o2_resume (struct sdhci_pci_chip *chip) {sdhci_pci_o2_probe (chip); -return 0 ; +return sdhci_pci_resume_host (chip); }#endif
drivers/mmc/host/sdhci-pci.h +4 -0
@@ -106,4 +106,8 @@ struct sdhci_pci_chip { struct sdhci_pci_slot *slots[MAX_SLOTS]; /* Pointers to host slots */ }; +#ifdef CONFIG_PM_SLEEP +int sdhci_pci_resume_host (struct sdhci_pci_chip *chip); +#endif +#endif /* __SDHCI_PCI_H */
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 37/39 mmc: sdhci-pci: Add runtime suspend/resume callbacks
In reply to Adrian HunterAdd runtime suspend/resume callbacks to match suspend/resume callbacks.
--- drivers/mmc/host/sdhci-pci-core.c | 85 +++++++++++++++++++++++---------------- drivers/mmc/host/sdhci-pci.h | 4 ++ 2 files changed, 55 insertions(+), 34 deletions(-)
drivers/mmc/host/sdhci-pci-core.c +51 -34
@@ -117,6 +117,49 @@ int sdhci_pci_resume_host(struct sdhci_pci_chip *chip) }#endif +#ifdef CONFIG_PM +static int sdhci_pci_runtime_suspend_host (struct sdhci_pci_chip *chip) +{ +struct sdhci_pci_slot *slot; +int i, ret; + +for (i =0 ; i < chip->num_slots; i++) { + slot = chip->slots[i]; +if (!slot) +continue ; + + ret =sdhci_runtime_suspend_host (slot->host); +if (ret) + goto err_pci_runtime_suspend; + } + +return 0 ; + +err_pci_runtime_suspend: +while (--i >=0 ) +sdhci_runtime_resume_host (chip->slots[i]->host); +return ret; +} + +static int sdhci_pci_runtime_resume_host (struct sdhci_pci_chip *chip) +{ +struct sdhci_pci_slot *slot; +int i, ret; + +for (i =0 ; i < chip->num_slots; i++) { + slot = chip->slots[i]; +if (!slot) +continue ; + + ret =sdhci_runtime_resume_host (slot->host); +if (ret) +return ret; + } + +return 0 ; +} +#endif +/*****************************************************************************\ * * * Hardware specific quirk handling *
@@ -1769,55 +1812,29 @@ static int sdhci_pci_resume(struct device *dev)static int sdhci_pci_runtime_suspend (struct device *dev) {struct pci_dev *pdev =to_pci_dev (dev); -struct sdhci_pci_chip *chip; -struct sdhci_pci_slot *slot; -int i, ret; +struct sdhci_pci_chip *chip =pci_get_drvdata (pdev); - chip =pci_get_drvdata (pdev);if (!chip)return 0 ; -for (i =0 ; i < chip->num_slots; i++) { - slot = chip->slots[i]; -if (!slot) -continue ; - - ret =sdhci_runtime_suspend_host (slot->host); - -if (ret) - goto err_pci_runtime_suspend; - } - -return 0 ; +if (chip->fixes && chip->fixes->runtime_suspend) +return chip->fixes->runtime_suspend (chip); -err_pci_runtime_suspend: -while (--i >=0 ) -sdhci_runtime_resume_host (chip->slots[i]->host); -return ret; +return sdhci_pci_runtime_suspend_host (chip); }static int sdhci_pci_runtime_resume (struct device *dev) {struct pci_dev *pdev =to_pci_dev (dev); -struct sdhci_pci_chip *chip; -struct sdhci_pci_slot *slot; -int i, ret; +struct sdhci_pci_chip *chip =pci_get_drvdata (pdev); - chip =pci_get_drvdata (pdev);if (!chip)return 0 ; -for (i =0 ; i < chip->num_slots; i++) { - slot = chip->slots[i]; -if (!slot) -continue ; - - ret =sdhci_runtime_resume_host (slot->host); -if (ret) -return ret; - } +if (chip->fixes && chip->fixes->runtime_resume) +return chip->fixes->runtime_resume (chip); -return 0 ; +return sdhci_pci_runtime_resume_host (chip); }#endif
drivers/mmc/host/sdhci-pci.h +4 -0
@@ -71,6 +71,10 @@ struct sdhci_pci_fixes {int (*suspend) (struct sdhci_pci_chip *);int (*resume) (struct sdhci_pci_chip *);#endif +#ifdef CONFIG_PM +int (*runtime_suspend) (struct sdhci_pci_chip *); +int (*runtime_resume) (struct sdhci_pci_chip *); +#endif const struct sdhci_ops *ops; };
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 38/39 mmc: sdhci-pci: Move a function to avoid later forward declaration
In reply to Adrian HunterMove a function to avoid having to forward declare it in a subsequent patch.
--- drivers/mmc/host/sdhci-pci-core.c | 78 +++++++++++++++++++-------------------- 1 file changed, 39 insertions(+), 39 deletions(-)
drivers/mmc/host/sdhci-pci-core.c +39 -39
@@ -482,6 +482,45 @@ static int bxt_get_cd(struct mmc_host *mmc)return ret; } +#define SDHCI_INTEL_PWR_TIMEOUT_CNT 20 +#define SDHCI_INTEL_PWR_TIMEOUT_UDELAY 100 + +static void sdhci_intel_set_power (struct sdhci_host *host,unsigned char mode, +unsigned short vdd) +{ +int cntr; +u8 reg; + +sdhci_set_power (host, mode, vdd); + +if (mode ==MMC_POWER_OFF ) +return ; + +/* +* Bus power might not enable after D3 -> D0 transition due to the +* present state not yet having propagated. Retry for up to 2ms. +*/ +for (cntr =0 ; cntr <SDHCI_INTEL_PWR_TIMEOUT_CNT ; cntr++) { + reg =sdhci_readb (host,SDHCI_POWER_CONTROL ); +if (reg &SDHCI_POWER_ON ) +break ; +udelay (SDHCI_INTEL_PWR_TIMEOUT_UDELAY ); + reg |=SDHCI_POWER_ON ; +sdhci_writeb (host, reg,SDHCI_POWER_CONTROL ); + } +} + +static const struct sdhci_ops sdhci_intel_byt_ops = { + .set_clock = sdhci_set_clock, + .set_power = sdhci_intel_set_power, + .enable_dma = sdhci_pci_enable_dma, + .set_bus_width = sdhci_pci_set_bus_width, + .reset = sdhci_reset, + .set_uhs_signaling = sdhci_set_uhs_signaling, + .hw_reset = sdhci_pci_hw_reset, + .select_drive_strength = sdhci_pci_select_drive_strength, +}; +static int byt_emmc_probe_slot (struct sdhci_pci_slot *slot) { slot->host->mmc->caps |= MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE |
@@ -560,45 +599,6 @@ static int byt_sd_probe_slot(struct sdhci_pci_slot *slot)return 0 ; } -#define SDHCI_INTEL_PWR_TIMEOUT_CNT 20 -#define SDHCI_INTEL_PWR_TIMEOUT_UDELAY 100 - -static void sdhci_intel_set_power (struct sdhci_host *host,unsigned char mode, -unsigned short vdd) -{ -int cntr; -u8 reg; - -sdhci_set_power (host, mode, vdd); - -if (mode ==MMC_POWER_OFF ) -return ; - -/* -* Bus power might not enable after D3 -> D0 transition due to the -* present state not yet having propagated. Retry for up to 2ms. -*/ -for (cntr =0 ; cntr <SDHCI_INTEL_PWR_TIMEOUT_CNT ; cntr++) { - reg =sdhci_readb (host,SDHCI_POWER_CONTROL ); -if (reg &SDHCI_POWER_ON ) -break ; -udelay (SDHCI_INTEL_PWR_TIMEOUT_UDELAY ); - reg |=SDHCI_POWER_ON ; -sdhci_writeb (host, reg,SDHCI_POWER_CONTROL ); - } -} - -static const struct sdhci_ops sdhci_intel_byt_ops = { - .set_clock = sdhci_set_clock, - .set_power = sdhci_intel_set_power, - .enable_dma = sdhci_pci_enable_dma, - .set_bus_width = sdhci_pci_set_bus_width, - .reset = sdhci_reset, - .set_uhs_signaling = sdhci_set_uhs_signaling, - .hw_reset = sdhci_pci_hw_reset, - .select_drive_strength = sdhci_pci_select_drive_strength, -}; -static const struct sdhci_pci_fixes sdhci_intel_byt_emmc = { .allow_runtime_pm = true, .probe_slot = byt_emmc_probe_slot,
Signature · 1 line
1.9.1
Adrian Hunter
maintainerRFC PATCH 39/39 mmc: sdhci-pci: Add CQHCI support for Intel GLK
In reply to Adrian HunterAdd CQHCI initialization and implement CQHCI operations for Intel GLK.
--- drivers/mmc/host/Kconfig | 1 + drivers/mmc/host/sdhci-pci-core.c | 151 +++++++++++++++++++++++++++++++++++++- 2 files changed, 151 insertions(+), 1 deletion(-)
drivers/mmc/host/Kconfig +1 -0
@@ -72,6 +72,7 @@ config MMC_SDHCI_BIG_ENDIAN_32BIT_BYTE_SWAPPER config MMC_SDHCI_PCI tristate "SDHCI support on PCI bus" depends on MMC_SDHCI && PCI + select MMC_CQHCI help This selects the PCI Secure Digital Host Controller Interface. Most controllers found today are PCI devices.
drivers/mmc/host/sdhci-pci-core.c +150 -1
195 lines not on this page · raw message
Signature · 1 line
1.9.1