linux.git/drivers/mmc/card/queue.c, branch master

mmc: block: Move files to core

2016-12-12T15:30:05+00:00

Once upon a time it made sense to keep the mmc block device driver and its
related code, in its own directory called card. Over time, more an more
functions/structures have become shared through generic mmc header files,
between the core and the card directory. In other words, the relationship
between them has become closer.

By sharing functions/structures via generic header files, it becomes easy
for outside users to abuse them. In a way to avoid that from happen, let's
move the files from card directory into the core directory, as it enables
us to move definitions of functions/structures into mmc core specific
header files.

Note, this is only the first step in providing a cleaner mmc interface for
outside users. Following changes will do the actual cleanup, as that is not
part of this change.

Signed-off-by: Ulf Hansson 
Reviewed-by: Linus Walleij

mmc: queue: remove BUG_ON for bounce_sg

2016-12-05T09:31:13+00:00

bounce_sg for mqrq_cur and mqrq_pre are proper
allocated when initializing the queue and will not
be freed before explicitly cleaning the queue. So from
the code itself it should be quite confident to remove
this check. If that BUG_ON take effects, it is mostly
likely the memory is randomly oopsing.

Signed-off-by: Shawn Lin 
Signed-off-by: Ulf Hansson

mmc: queue: Introduce queue depth and use it to allocate and free

2016-12-05T09:31:07+00:00

Add a mmc_queue member to record the size of the queue, which currently
supports 2 requests on-the-go at a time. Instead of allocating resources
for 2 slots in the queue, allow for an arbitrary number.

Signed-off-by: Adrian Hunter 
Signed-off-by: Ulf Hansson

mmc: queue: Factor out mmc_queue_reqs_free_bufs()

2016-12-05T09:31:06+00:00

In preparation for supporting a queue of requests, factor out
mmc_queue_reqs_free_bufs().

Signed-off-by: Adrian Hunter 
Reviewed-by: Linus Walleij 
Reviewed-by: Harjani Ritesh 
Signed-off-by: Ulf Hansson

mmc: queue: Factor out mmc_queue_alloc_sgs()

2016-12-05T09:31:05+00:00

In preparation for supporting a queue of requests, factor out
mmc_queue_alloc_sgs().

Signed-off-by: Adrian Hunter 
Reviewed-by: Linus Walleij 
Reviewed-by: Harjani Ritesh 
Signed-off-by: Ulf Hansson

mmc: queue: Factor out mmc_queue_alloc_bounce_sgs()

2016-12-05T09:31:05+00:00

In preparation for supporting a queue of requests, factor out
mmc_queue_alloc_bounce_sgs().

Signed-off-by: Adrian Hunter 
Reviewed-by: Linus Walleij 
Reviewed-by: Harjani Ritesh 
[Ulf: Fixed compiler warning]
Signed-off-by: Ulf Hansson

mmc: queue: Factor out mmc_queue_alloc_bounce_bufs()

2016-12-05T09:31:04+00:00

In preparation for supporting a queue of requests, factor out
mmc_queue_alloc_bounce_bufs().

Signed-off-by: Adrian Hunter 
Reviewed-by: Linus Walleij 
Reviewed-by: Harjani Ritesh 
[Ulf: Fixed compiler warning]
Signed-off-by: Ulf Hansson

mmc: queue: Fix queue thread wake-up

2016-12-05T09:31:03+00:00

The only time the driver sleeps expecting to be woken upon the arrival of
a new request, is when the dispatch queue is empty. The only time that it
is known whether the dispatch queue is empty is after NULL is returned
from blk_fetch_request() while under the queue lock.

Recognizing those facts, simplify the synchronization between the queue
thread and the request function. A couple of flags tell the request
function what to do, and the queue lock and barriers associated with
wake-ups ensure synchronization.

The result is simpler and allows the removal of the context_info lock.

Signed-off-by: Adrian Hunter 
Reviewed-by: Linus Walleij 
Reviewed-by: Harjani Ritesh 
Signed-off-by: Ulf Hansson

mmc: block: delete packed command support

2016-11-29T08:05:27+00:00

I've had it with this code now.

The packed command support is a complex hurdle in the MMC/SD block
layer, around 500+ lines of code which was introduced in 2013 in

commit ce39f9d17c14 ("mmc: support packed write command for eMMC4.5
devices")
commit abd9ac144947 ("mmc: add packed command feature of eMMC4.5")

...and since then it has been rotting. The original author of the
code has disappeared from the community and the mail address is
bouncing.

For the code to be exercised the host must flag that it supports
packed commands, so in mmc_blk_prep_packed_list() which is called for
every single request, the following construction appears:

u8 max_packed_rw = 0;

if ((rq_data_dir(cur) == WRITE) &&
    mmc_host_packed_wr(card->host))
        max_packed_rw = card->ext_csd.max_packed_writes;

if (max_packed_rw == 0)
    goto no_packed;

This has the following logical deductions:

- Only WRITE commands can really be packed, so the solution is
  only half-done: we support packed WRITE but not packed READ.
  The packed command support has not been finalized by supporting
  reads in three years!

- mmc_host_packed_wr() is just a static inline that checks
  host->caps2 & MMC_CAP2_PACKED_WR. The problem with this is
  that NO upstream host sets this capability flag! No driver
  in the kernel is using it, and we can't test it. Packed
  command may be supported in out-of-tree code, but I doubt
  it. I doubt that the code is even working anymore due to
  other refactorings in the MMC block layer, who would
  notice if patches affecting it broke packed commands?
  No one.

- There is no Device Tree binding or code to mark a host as
  supporting packed read or write commands, just this flag
  in caps2, so for sure there are not any DT systems using
  it either.

It has other problems as well: mmc_blk_prep_packed_list() is
speculatively picking requests out of the request queue with
blk_fetch_request() making the MMC/SD stack harder to convert
to the multiqueue block layer. By this we get rid of an
obstacle.

The way I see it this is just cruft littering the MMC/SD
stack.

Cc: Namjae Jeon 
Cc: Maya Erez 
Acked-by: Jaehoon Chung 
Signed-off-by: Linus Walleij 
Signed-off-by: Ulf Hansson

mmc: block: move packed command struct init

2016-11-29T08:05:04+00:00

By moving the mmc_packed_init() and mmc_packed_clean() into the
only file in the kernel where they are used, we save two exported
functions and can staticize those to the block.c file.

Signed-off-by: Linus Walleij 
Signed-off-by: Ulf Hansson