projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Linux 4.6-rc3
[linux-2.6-block.git] / drivers / mmc / card / block.c
CommitLineData
1da177e4
LT		 1/*
2 * Block driver for media (i.e., flash cards)
3 *
4 * Copyright 2002 Hewlett-Packard Company
979ce720 5 * Copyright 2005-2008 Pierre Ossman
1da177e4
LT		 6 *
7 * Use consistent with the GNU GPL is permitted,
8 * provided that this copyright notice is
9 * preserved in its entirety in all copies and derived works.
10 *
11 * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
12 * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
13 * FITNESS FOR ANY PARTICULAR PURPOSE.
14 *
15 * Many thanks to Alessandro Rubini and Jonathan Corbet!
16 *
17 * Author: Andrew Christian
18 * 28 May 2002
19 */
20#include <linux/moduleparam.h>
21#include <linux/module.h>
22#include <linux/init.h>
23
1da177e4
LT		 24#include <linux/kernel.h>
25#include <linux/fs.h>
5a0e3ad6 26#include <linux/slab.h>
1da177e4
LT		 27#include <linux/errno.h>
28#include <linux/hdreg.h>
29#include <linux/kdev_t.h>
30#include <linux/blkdev.h>
a621aaed 31#include <linux/mutex.h>
ec5a19dd 32#include <linux/scatterlist.h>
a7bbb573 33#include <linux/string_helpers.h>
cb87ea28
JC		 34#include <linux/delay.h>
35#include <linux/capability.h>
36#include <linux/compat.h>
e94cfef6 37#include <linux/pm_runtime.h>
1da177e4 38
cb87ea28 39#include <linux/mmc/ioctl.h>
1da177e4 40#include <linux/mmc/card.h>
385e3227 41#include <linux/mmc/host.h>
da7fbe58
PO		 42#include <linux/mmc/mmc.h>
43#include <linux/mmc/sd.h>
1da177e4 44
1da177e4
LT		 45#include <asm/uaccess.h>
46
98ac2162 47#include "queue.h"
1da177e4 48
6b0b6285 49MODULE_ALIAS("mmc:block");
5e71b7a6
OJ		 50#ifdef MODULE_PARAM_PREFIX
51#undef MODULE_PARAM_PREFIX
52#endif
53#define MODULE_PARAM_PREFIX "mmcblk."
54
6a7a6b45
AW		 55#define INAND_CMD38_ARG_EXT_CSD 113
56#define INAND_CMD38_ARG_ERASE 0x00
57#define INAND_CMD38_ARG_TRIM 0x01
58#define INAND_CMD38_ARG_SECERASE 0x80
59#define INAND_CMD38_ARG_SECTRIM1 0x81
60#define INAND_CMD38_ARG_SECTRIM2 0x88
8fee476b 61#define MMC_BLK_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */
775a9362
ME		 62#define MMC_SANITIZE_REQ_TIMEOUT 240000
63#define MMC_EXTRACT_INDEX_FROM_ARG(x) ((x & 0x00FF0000) >> 16)
6a7a6b45 64
d3df0465 65#define mmc_req_rel_wr(req) ((req->cmd_flags & REQ_FUA) && \
ce39f9d1
SJ		 66 (rq_data_dir(req) == WRITE))
67#define PACKED_CMD_VER 0x01
68#define PACKED_CMD_WR 0x02
69
5e71b7a6 70static DEFINE_MUTEX(block_mutex);
6b0b6285 71
1da177e4 72/*
5e71b7a6
OJ		 73 * The defaults come from config options but can be overriden by module
74 * or bootarg options.
1da177e4 75 */
5e71b7a6 76static int perdev_minors = CONFIG_MMC_BLOCK_MINORS;
1dff3144 77
5e71b7a6
OJ		 78/*
79 * We've only got one major, so number of mmcblk devices is
a26eba61
BH		 80 * limited to (1 << 20) / number of minors per device. It is also
81 * currently limited by the size of the static bitmaps below.
5e71b7a6
OJ		 82 */
83static int max_devices;
84
a26eba61
BH		 85#define MAX_DEVICES 256
86
87/* TODO: Replace these with struct ida */
88static DECLARE_BITMAP(dev_use, MAX_DEVICES);
89static DECLARE_BITMAP(name_use, MAX_DEVICES);
1da177e4 90
1da177e4
LT		 91/*
92 * There is one mmc_blk_data per slot.
93 */
94struct mmc_blk_data {
95 spinlock_t lock;
96 struct gendisk *disk;
97 struct mmc_queue queue;
371a689f 98 struct list_head part;
1da177e4 99
d0c97cfb
AW		 100 unsigned int flags;
101#define MMC_BLK_CMD23 (1 << 0) /* Can do SET_BLOCK_COUNT for multiblock */
102#define MMC_BLK_REL_WR (1 << 1) /* MMC Reliable write support */
ce39f9d1 103#define MMC_BLK_PACKED_CMD (1 << 2) /* MMC packed command support */
d0c97cfb 104
1da177e4 105 unsigned int usage;
a6f6c96b 106 unsigned int read_only;
371a689f 107 unsigned int part_type;
f06c9153 108 unsigned int name_idx;
67716327
AH		 109 unsigned int reset_done;
110#define MMC_BLK_READ BIT(0)
111#define MMC_BLK_WRITE BIT(1)
112#define MMC_BLK_DISCARD BIT(2)
113#define MMC_BLK_SECDISCARD BIT(3)
371a689f
AW		 114
115 /*
116 * Only set in main mmc_blk_data associated
fc95e30b 117 * with mmc_card with dev_set_drvdata, and keeps
371a689f
AW		 118 * track of the current selected device partition.
119 */
120 unsigned int part_curr;
121 struct device_attribute force_ro;
add710ea
JR		 122 struct device_attribute power_ro_lock;
123 int area_type;
1da177e4
LT		 124};
125
a621aaed 126static DEFINE_MUTEX(open_lock);
1da177e4 127
ce39f9d1
SJ		 128enum {
129 MMC_PACKED_NR_IDX = -1,
130 MMC_PACKED_NR_ZERO,
131 MMC_PACKED_NR_SINGLE,
132};
133
5e71b7a6
OJ		 134module_param(perdev_minors, int, 0444);
135MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device");
136
8d1e977d
LP		 137static inline int mmc_blk_part_switch(struct mmc_card *card,
138 struct mmc_blk_data *md);
139static int get_card_status(struct mmc_card *card, u32 *status, int retries);
140
ce39f9d1
SJ		 141static inline void mmc_blk_clear_packed(struct mmc_queue_req *mqrq)
142{
143 struct mmc_packed *packed = mqrq->packed;
144
145 BUG_ON(!packed);
146
147 mqrq->cmd_type = MMC_PACKED_NONE;
148 packed->nr_entries = MMC_PACKED_NR_ZERO;
149 packed->idx_failure = MMC_PACKED_NR_IDX;
150 packed->retries = 0;
151 packed->blocks = 0;
152}
153
1da177e4
LT		 154static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
155{
156 struct mmc_blk_data *md;
157
a621aaed 158 mutex_lock(&open_lock);
1da177e4
LT		 159 md = disk->private_data;
160 if (md && md->usage == 0)
161 md = NULL;
162 if (md)
163 md->usage++;
a621aaed 164 mutex_unlock(&open_lock);
1da177e4
LT		 165
166 return md;
167}
168
371a689f
AW		 169static inline int mmc_get_devidx(struct gendisk *disk)
170{
382c55f8 171 int devidx = disk->first_minor / perdev_minors;
371a689f
AW		 172 return devidx;
173}
174
1da177e4
LT		 175static void mmc_blk_put(struct mmc_blk_data *md)
176{
a621aaed 177 mutex_lock(&open_lock);
1da177e4
LT		 178 md->usage--;
179 if (md->usage == 0) {
371a689f 180 int devidx = mmc_get_devidx(md->disk);
5fa83ce2
AH		 181 blk_cleanup_queue(md->queue.queue);
182
1dff3144
DW		 183 __clear_bit(devidx, dev_use);
184
1da177e4 185 put_disk(md->disk);
1da177e4
LT		 186 kfree(md);
187 }
a621aaed 188 mutex_unlock(&open_lock);
1da177e4
LT		 189}
190
add710ea
JR		 191static ssize_t power_ro_lock_show(struct device *dev,
192 struct device_attribute *attr, char *buf)
193{
194 int ret;
195 struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
196 struct mmc_card *card = md->queue.card;
197 int locked = 0;
198
199 if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PERM_WP_EN)
200 locked = 2;
201 else if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_EN)
202 locked = 1;
203
204 ret = snprintf(buf, PAGE_SIZE, "%d\n", locked);
205
9098f84c
TW		 206 mmc_blk_put(md);
207
add710ea
JR		 208 return ret;
209}
210
211static ssize_t power_ro_lock_store(struct device *dev,
212 struct device_attribute *attr, const char *buf, size_t count)
213{
214 int ret;
215 struct mmc_blk_data *md, *part_md;
216 struct mmc_card *card;
217 unsigned long set;
218
219 if (kstrtoul(buf, 0, &set))
220 return -EINVAL;
221
222 if (set != 1)
223 return count;
224
225 md = mmc_blk_get(dev_to_disk(dev));
226 card = md->queue.card;
227
e94cfef6 228 mmc_get_card(card);
add710ea
JR		 229
230 ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_WP,
231 card->ext_csd.boot_ro_lock |
232 EXT_CSD_BOOT_WP_B_PWR_WP_EN,
233 card->ext_csd.part_time);
234 if (ret)
235 pr_err("%s: Locking boot partition ro until next power on failed: %d\n", md->disk->disk_name, ret);
236 else
237 card->ext_csd.boot_ro_lock |= EXT_CSD_BOOT_WP_B_PWR_WP_EN;
238
e94cfef6 239 mmc_put_card(card);
add710ea
JR		 240
241 if (!ret) {
242 pr_info("%s: Locking boot partition ro until next power on\n",
243 md->disk->disk_name);
244 set_disk_ro(md->disk, 1);
245
246 list_for_each_entry(part_md, &md->part, part)
247 if (part_md->area_type == MMC_BLK_DATA_AREA_BOOT) {
248 pr_info("%s: Locking boot partition ro until next power on\n", part_md->disk->disk_name);
249 set_disk_ro(part_md->disk, 1);
250 }
251 }
252
253 mmc_blk_put(md);
254 return count;
255}
256
371a689f
AW		 257static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr,
258 char *buf)
259{
260 int ret;
261 struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
262
0031a98a 263 ret = snprintf(buf, PAGE_SIZE, "%d\n",
371a689f
AW		 264 get_disk_ro(dev_to_disk(dev)) ^
265 md->read_only);
266 mmc_blk_put(md);
267 return ret;
268}
269
270static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
271 const char *buf, size_t count)
272{
273 int ret;
274 char *end;
275 struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
276 unsigned long set = simple_strtoul(buf, &end, 0);
277 if (end == buf) {
278 ret = -EINVAL;
279 goto out;
280 }
281
282 set_disk_ro(dev_to_disk(dev), set || md->read_only);
283 ret = count;
284out:
285 mmc_blk_put(md);
286 return ret;
287}
288
a5a1561f 289static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
1da177e4 290{
a5a1561f 291 struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
1da177e4
LT		 292 int ret = -ENXIO;
293
2a48fc0a 294 mutex_lock(&block_mutex);
1da177e4
LT		 295 if (md) {
296 if (md->usage == 2)
a5a1561f 297 check_disk_change(bdev);
1da177e4 298 ret = 0;
a00fc090 299
a5a1561f 300 if ((mode & FMODE_WRITE) && md->read_only) {
70bb0896 301 mmc_blk_put(md);
a00fc090 302 ret = -EROFS;
70bb0896 303 }
1da177e4 304 }
2a48fc0a 305 mutex_unlock(&block_mutex);
1da177e4
LT		 306
307 return ret;
308}
309
db2a144b 310static void mmc_blk_release(struct gendisk *disk, fmode_t mode)
1da177e4 311{
a5a1561f 312 struct mmc_blk_data *md = disk->private_data;
1da177e4 313
2a48fc0a 314 mutex_lock(&block_mutex);
1da177e4 315 mmc_blk_put(md);
2a48fc0a 316 mutex_unlock(&block_mutex);
1da177e4
LT		 317}
318
319static int
a885c8c4 320mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1da177e4 321{
a885c8c4
CH		 322 geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
323 geo->heads = 4;
324 geo->sectors = 16;
325 return 0;
1da177e4
LT		 326}
327
cb87ea28
JC		 328struct mmc_blk_ioc_data {
329 struct mmc_ioc_cmd ic;
330 unsigned char *buf;
331 u64 buf_bytes;
332};
333
334static struct mmc_blk_ioc_data *mmc_blk_ioctl_copy_from_user(
335 struct mmc_ioc_cmd __user *user)
336{
337 struct mmc_blk_ioc_data *idata;
338 int err;
339
1ff8950c 340 idata = kmalloc(sizeof(*idata), GFP_KERNEL);
cb87ea28
JC		 341 if (!idata) {
342 err = -ENOMEM;
aea253ec 343 goto out;
cb87ea28
JC		 344 }
345
346 if (copy_from_user(&idata->ic, user, sizeof(idata->ic))) {
347 err = -EFAULT;
aea253ec 348 goto idata_err;
cb87ea28
JC		 349 }
350
351 idata->buf_bytes = (u64) idata->ic.blksz * idata->ic.blocks;
352 if (idata->buf_bytes > MMC_IOC_MAX_BYTES) {
353 err = -EOVERFLOW;
aea253ec 354 goto idata_err;
cb87ea28
JC		 355 }
356
4d6144de
JR		 357 if (!idata->buf_bytes)
358 return idata;
359
1ff8950c 360 idata->buf = kmalloc(idata->buf_bytes, GFP_KERNEL);
cb87ea28
JC		 361 if (!idata->buf) {
362 err = -ENOMEM;
aea253ec 363 goto idata_err;
cb87ea28
JC		 364 }
365
366 if (copy_from_user(idata->buf, (void __user *)(unsigned long)
367 idata->ic.data_ptr, idata->buf_bytes)) {
368 err = -EFAULT;
369 goto copy_err;
370 }
371
372 return idata;
373
374copy_err:
375 kfree(idata->buf);
aea253ec 376idata_err:
cb87ea28 377 kfree(idata);
aea253ec 378out:
cb87ea28 379 return ERR_PTR(err);
cb87ea28
JC		 380}
381
a5f5774c
JH		 382static int mmc_blk_ioctl_copy_to_user(struct mmc_ioc_cmd __user *ic_ptr,
383 struct mmc_blk_ioc_data *idata)
384{
385 struct mmc_ioc_cmd *ic = &idata->ic;
386
387 if (copy_to_user(&(ic_ptr->response), ic->response,
388 sizeof(ic->response)))
389 return -EFAULT;
390
391 if (!idata->ic.write_flag) {
392 if (copy_to_user((void __user *)(unsigned long)ic->data_ptr,
393 idata->buf, idata->buf_bytes))
394 return -EFAULT;
395 }
396
397 return 0;
398}
399
8d1e977d
LP		 400static int ioctl_rpmb_card_status_poll(struct mmc_card *card, u32 *status,
401 u32 retries_max)
402{
403 int err;
404 u32 retry_count = 0;
405
406 if (!status || !retries_max)
407 return -EINVAL;
408
409 do {
410 err = get_card_status(card, status, 5);
411 if (err)
412 break;
413
414 if (!R1_STATUS(*status) &&
415 (R1_CURRENT_STATE(*status) != R1_STATE_PRG))
416 break; /* RPMB programming operation complete */
417
418 /*
419 * Rechedule to give the MMC device a chance to continue
420 * processing the previous command without being polled too
421 * frequently.
422 */
423 usleep_range(1000, 5000);
424 } while (++retry_count < retries_max);
425
426 if (retry_count == retries_max)
427 err = -EPERM;
428
429 return err;
430}
431
775a9362
ME		 432static int ioctl_do_sanitize(struct mmc_card *card)
433{
434 int err;
435
a2d1086d 436 if (!mmc_can_sanitize(card)) {
775a9362
ME		 437 pr_warn("%s: %s - SANITIZE is not supported\n",
438 mmc_hostname(card->host), __func__);
439 err = -EOPNOTSUPP;
440 goto out;
441 }
442
443 pr_debug("%s: %s - SANITIZE IN PROGRESS...\n",
444 mmc_hostname(card->host), __func__);
445
446 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
447 EXT_CSD_SANITIZE_START, 1,
448 MMC_SANITIZE_REQ_TIMEOUT);
449
450 if (err)
451 pr_err("%s: %s - EXT_CSD_SANITIZE_START failed. err=%d\n",
452 mmc_hostname(card->host), __func__, err);
453
454 pr_debug("%s: %s - SANITIZE COMPLETED\n", mmc_hostname(card->host),
455 __func__);
456out:
457 return err;
458}
459
a5f5774c
JH		 460static int __mmc_blk_ioctl_cmd(struct mmc_card *card, struct mmc_blk_data *md,
461 struct mmc_blk_ioc_data *idata)
cb87ea28 462{
cb87ea28
JC		 463 struct mmc_command cmd = {0};
464 struct mmc_data data = {0};
ad5fd972 465 struct mmc_request mrq = {NULL};
cb87ea28
JC		 466 struct scatterlist sg;
467 int err;
8d1e977d
LP		 468 int is_rpmb = false;
469 u32 status = 0;
cb87ea28 470
a5f5774c
JH		 471 if (!card || !md || !idata)
472 return -EINVAL;
cb87ea28 473
8d1e977d
LP		 474 if (md->area_type & MMC_BLK_DATA_AREA_RPMB)
475 is_rpmb = true;
476
4d6144de
JR		 477 cmd.opcode = idata->ic.opcode;
478 cmd.arg = idata->ic.arg;
479 cmd.flags = idata->ic.flags;
480
481 if (idata->buf_bytes) {
482 data.sg = &sg;
483 data.sg_len = 1;
484 data.blksz = idata->ic.blksz;
485 data.blocks = idata->ic.blocks;
486
487 sg_init_one(data.sg, idata->buf, idata->buf_bytes);
488
489 if (idata->ic.write_flag)
490 data.flags = MMC_DATA_WRITE;
491 else
492 data.flags = MMC_DATA_READ;
493
494 /* data.flags must already be set before doing this. */
495 mmc_set_data_timeout(&data, card);
496
497 /* Allow overriding the timeout_ns for empirical tuning. */
498 if (idata->ic.data_timeout_ns)
499 data.timeout_ns = idata->ic.data_timeout_ns;
500
501 if ((cmd.flags & MMC_RSP_R1B) == MMC_RSP_R1B) {
502 /*
503 * Pretend this is a data transfer and rely on the
504 * host driver to compute timeout. When all host
505 * drivers support cmd.cmd_timeout for R1B, this
506 * can be changed to:
507 *
508 * mrq.data = NULL;
509 * cmd.cmd_timeout = idata->ic.cmd_timeout_ms;
510 */
511 data.timeout_ns = idata->ic.cmd_timeout_ms * 1000000;
512 }
513
514 mrq.data = &data;
515 }
516
517 mrq.cmd = &cmd;
518
8d1e977d
LP		 519 err = mmc_blk_part_switch(card, md);
520 if (err)
a5f5774c 521 return err;
8d1e977d 522
cb87ea28
JC		 523 if (idata->ic.is_acmd) {
524 err = mmc_app_cmd(card->host, card);
525 if (err)
a5f5774c 526 return err;
cb87ea28
JC		 527 }
528
8d1e977d
LP		 529 if (is_rpmb) {
530 err = mmc_set_blockcount(card, data.blocks,
531 idata->ic.write_flag & (1 << 31));
532 if (err)
a5f5774c 533 return err;
8d1e977d
LP		 534 }
535
a82e484e
YG		 536 if ((MMC_EXTRACT_INDEX_FROM_ARG(cmd.arg) == EXT_CSD_SANITIZE_START) &&
537 (cmd.opcode == MMC_SWITCH)) {
775a9362
ME		 538 err = ioctl_do_sanitize(card);
539
540 if (err)
541 pr_err("%s: ioctl_do_sanitize() failed. err = %d",
542 __func__, err);
543
a5f5774c 544 return err;
775a9362
ME		 545 }
546
cb87ea28
JC		 547 mmc_wait_for_req(card->host, &mrq);
548
549 if (cmd.error) {
550 dev_err(mmc_dev(card->host), "%s: cmd error %d\n",
551 __func__, cmd.error);
a5f5774c 552 return cmd.error;
cb87ea28
JC		 553 }
554 if (data.error) {
555 dev_err(mmc_dev(card->host), "%s: data error %d\n",
556 __func__, data.error);
a5f5774c 557 return data.error;
cb87ea28
JC		 558 }
559
560 /*
561 * According to the SD specs, some commands require a delay after
562 * issuing the command.
563 */
564 if (idata->ic.postsleep_min_us)
565 usleep_range(idata->ic.postsleep_min_us, idata->ic.postsleep_max_us);
566
a5f5774c 567 memcpy(&(idata->ic.response), cmd.resp, sizeof(cmd.resp));
cb87ea28 568
8d1e977d
LP		 569 if (is_rpmb) {
570 /*
571 * Ensure RPMB command has completed by polling CMD13
572 * "Send Status".
573 */
574 err = ioctl_rpmb_card_status_poll(card, &status, 5);
575 if (err)
576 dev_err(mmc_dev(card->host),
577 "%s: Card Status=0x%08X, error %d\n",
578 __func__, status, err);
579 }
580
a5f5774c
JH		 581 return err;
582}
583
584static int mmc_blk_ioctl_cmd(struct block_device *bdev,
585 struct mmc_ioc_cmd __user *ic_ptr)
586{
587 struct mmc_blk_ioc_data *idata;
588 struct mmc_blk_data *md;
589 struct mmc_card *card;
b093410c 590 int err = 0, ioc_err = 0;
a5f5774c 591
83c742c3
SL		 592 /*
593 * The caller must have CAP_SYS_RAWIO, and must be calling this on the
594 * whole block device, not on a partition. This prevents overspray
595 * between sibling partitions.
596 */
597 if ((!capable(CAP_SYS_RAWIO)) || (bdev != bdev->bd_contains))
598 return -EPERM;
599
a5f5774c
JH		 600 idata = mmc_blk_ioctl_copy_from_user(ic_ptr);
601 if (IS_ERR(idata))
602 return PTR_ERR(idata);
603
604 md = mmc_blk_get(bdev->bd_disk);
605 if (!md) {
606 err = -EINVAL;
607 goto cmd_err;
608 }
609
610 card = md->queue.card;
611 if (IS_ERR(card)) {
612 err = PTR_ERR(card);
613 goto cmd_done;
614 }
615
616 mmc_get_card(card);
617
b093410c 618 ioc_err = __mmc_blk_ioctl_cmd(card, md, idata);
a5f5774c 619
e94cfef6 620 mmc_put_card(card);
cb87ea28 621
b093410c 622 err = mmc_blk_ioctl_copy_to_user(ic_ptr, idata);
a5f5774c 623
cb87ea28
JC		 624cmd_done:
625 mmc_blk_put(md);
1c02f000 626cmd_err:
cb87ea28
JC		 627 kfree(idata->buf);
628 kfree(idata);
b093410c 629 return ioc_err ? ioc_err : err;
cb87ea28
JC		 630}
631
a5f5774c
JH		 632static int mmc_blk_ioctl_multi_cmd(struct block_device *bdev,
633 struct mmc_ioc_multi_cmd __user *user)
634{
635 struct mmc_blk_ioc_data **idata = NULL;
636 struct mmc_ioc_cmd __user *cmds = user->cmds;
637 struct mmc_card *card;
638 struct mmc_blk_data *md;
b093410c 639 int i, err = 0, ioc_err = 0;
a5f5774c
JH		 640 __u64 num_of_cmds;
641
83c742c3
SL		 642 /*
643 * The caller must have CAP_SYS_RAWIO, and must be calling this on the
644 * whole block device, not on a partition. This prevents overspray
645 * between sibling partitions.
646 */
647 if ((!capable(CAP_SYS_RAWIO)) || (bdev != bdev->bd_contains))
648 return -EPERM;
649
a5f5774c
JH		 650 if (copy_from_user(&num_of_cmds, &user->num_of_cmds,
651 sizeof(num_of_cmds)))
652 return -EFAULT;
653
654 if (num_of_cmds > MMC_IOC_MAX_CMDS)
655 return -EINVAL;
656
657 idata = kcalloc(num_of_cmds, sizeof(*idata), GFP_KERNEL);
658 if (!idata)
659 return -ENOMEM;
660
661 for (i = 0; i < num_of_cmds; i++) {
662 idata[i] = mmc_blk_ioctl_copy_from_user(&cmds[i]);
663 if (IS_ERR(idata[i])) {
664 err = PTR_ERR(idata[i]);
665 num_of_cmds = i;
666 goto cmd_err;
667 }
668 }
669
670 md = mmc_blk_get(bdev->bd_disk);
f00ab14c
OJ		 671 if (!md) {
672 err = -EINVAL;
a5f5774c 673 goto cmd_err;
f00ab14c 674 }
a5f5774c
JH		 675
676 card = md->queue.card;
677 if (IS_ERR(card)) {
678 err = PTR_ERR(card);
679 goto cmd_done;
680 }
681
682 mmc_get_card(card);
683
b093410c
GG		 684 for (i = 0; i < num_of_cmds && !ioc_err; i++)
685 ioc_err = __mmc_blk_ioctl_cmd(card, md, idata[i]);
a5f5774c
JH		 686
687 mmc_put_card(card);
688
689 /* copy to user if data and response */
b093410c 690 for (i = 0; i < num_of_cmds && !err; i++)
a5f5774c 691 err = mmc_blk_ioctl_copy_to_user(&cmds[i], idata[i]);
a5f5774c
JH		 692
693cmd_done:
694 mmc_blk_put(md);
695cmd_err:
696 for (i = 0; i < num_of_cmds; i++) {
697 kfree(idata[i]->buf);
698 kfree(idata[i]);
699 }
700 kfree(idata);
b093410c 701 return ioc_err ? ioc_err : err;
a5f5774c
JH		 702}
703
cb87ea28
JC		 704static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode,
705 unsigned int cmd, unsigned long arg)
706{
a5f5774c
JH		 707 switch (cmd) {
708 case MMC_IOC_CMD:
709 return mmc_blk_ioctl_cmd(bdev,
710 (struct mmc_ioc_cmd __user *)arg);
711 case MMC_IOC_MULTI_CMD:
712 return mmc_blk_ioctl_multi_cmd(bdev,
713 (struct mmc_ioc_multi_cmd __user *)arg);
714 default:
715 return -EINVAL;
716 }
cb87ea28
JC		 717}
718
719#ifdef CONFIG_COMPAT
720static int mmc_blk_compat_ioctl(struct block_device *bdev, fmode_t mode,
721 unsigned int cmd, unsigned long arg)
722{
723 return mmc_blk_ioctl(bdev, mode, cmd, (unsigned long) compat_ptr(arg));
724}
725#endif
726
83d5cde4 727static const struct block_device_operations mmc_bdops = {
a5a1561f
AV		 728 .open = mmc_blk_open,
729 .release = mmc_blk_release,
a885c8c4 730 .getgeo = mmc_blk_getgeo,
1da177e4 731 .owner = THIS_MODULE,
cb87ea28
JC		 732 .ioctl = mmc_blk_ioctl,
733#ifdef CONFIG_COMPAT
734 .compat_ioctl = mmc_blk_compat_ioctl,
735#endif
1da177e4
LT		 736};
737
371a689f
AW		 738static inline int mmc_blk_part_switch(struct mmc_card *card,
739 struct mmc_blk_data *md)
740{
741 int ret;
fc95e30b 742 struct mmc_blk_data *main_md = dev_get_drvdata(&card->dev);
0d7d85ca 743
371a689f
AW		 744 if (main_md->part_curr == md->part_type)
745 return 0;
746
747 if (mmc_card_mmc(card)) {
0d7d85ca
AH		 748 u8 part_config = card->ext_csd.part_config;
749
750 part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
751 part_config |= md->part_type;
371a689f
AW		 752
753 ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
0d7d85ca 754 EXT_CSD_PART_CONFIG, part_config,
371a689f
AW		 755 card->ext_csd.part_time);
756 if (ret)
757 return ret;
0d7d85ca
AH		 758
759 card->ext_csd.part_config = part_config;
67716327 760 }
371a689f
AW		 761
762 main_md->part_curr = md->part_type;
763 return 0;
764}
765
ec5a19dd
PO		 766static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
767{
768 int err;
051913da
BD		 769 u32 result;
770 __be32 *blocks;
ec5a19dd 771
ad5fd972 772 struct mmc_request mrq = {NULL};
1278dba1 773 struct mmc_command cmd = {0};
a61ad2b4 774 struct mmc_data data = {0};
ec5a19dd
PO		 775
776 struct scatterlist sg;
777
ec5a19dd
PO		 778 cmd.opcode = MMC_APP_CMD;
779 cmd.arg = card->rca << 16;
7213d175 780 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
ec5a19dd
PO		 781
782 err = mmc_wait_for_cmd(card->host, &cmd, 0);
7213d175
DB		 783 if (err)
784 return (u32)-1;
785 if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD))
ec5a19dd
PO		 786 return (u32)-1;
787
788 memset(&cmd, 0, sizeof(struct mmc_command));
789
790 cmd.opcode = SD_APP_SEND_NUM_WR_BLKS;
791 cmd.arg = 0;
7213d175 792 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
ec5a19dd 793
ec5a19dd
PO		 794 data.blksz = 4;
795 data.blocks = 1;
796 data.flags = MMC_DATA_READ;
797 data.sg = &sg;
798 data.sg_len = 1;
d380443c 799 mmc_set_data_timeout(&data, card);
ec5a19dd 800
ec5a19dd
PO		 801 mrq.cmd = &cmd;
802 mrq.data = &data;
803
051913da
BD		 804 blocks = kmalloc(4, GFP_KERNEL);
805 if (!blocks)
806 return (u32)-1;
807
808 sg_init_one(&sg, blocks, 4);
ec5a19dd
PO		 809
810 mmc_wait_for_req(card->host, &mrq);
811
051913da
BD		 812 result = ntohl(*blocks);
813 kfree(blocks);
814
17b0429d 815 if (cmd.error || data.error)
051913da 816 result = (u32)-1;
ec5a19dd 817
051913da 818 return result;
ec5a19dd
PO		 819}
820
0a2d4048 821static int get_card_status(struct mmc_card *card, u32 *status, int retries)
504f191f 822{
1278dba1 823 struct mmc_command cmd = {0};
504f191f
AH		 824 int err;
825
504f191f
AH		 826 cmd.opcode = MMC_SEND_STATUS;
827 if (!mmc_host_is_spi(card->host))
828 cmd.arg = card->rca << 16;
829 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
0a2d4048
RKAL		 830 err = mmc_wait_for_cmd(card->host, &cmd, retries);
831 if (err == 0)
832 *status = cmd.resp[0];
833 return err;
504f191f
AH		 834}
835
c49433fb 836static int card_busy_detect(struct mmc_card *card, unsigned int timeout_ms,
95a91298 837 bool hw_busy_detect, struct request *req, int *gen_err)
c49433fb
UH		 838{
839 unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
840 int err = 0;
841 u32 status;
842
843 do {
844 err = get_card_status(card, &status, 5);
845 if (err) {
846 pr_err("%s: error %d requesting status\n",
847 req->rq_disk->disk_name, err);
848 return err;
849 }
850
851 if (status & R1_ERROR) {
852 pr_err("%s: %s: error sending status cmd, status %#x\n",
853 req->rq_disk->disk_name, __func__, status);
854 *gen_err = 1;
855 }
856
95a91298
UH		 857 /* We may rely on the host hw to handle busy detection.*/
858 if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) &&
859 hw_busy_detect)
860 break;
861
c49433fb
UH		 862 /*
863 * Timeout if the device never becomes ready for data and never
864 * leaves the program state.
865 */
866 if (time_after(jiffies, timeout)) {
867 pr_err("%s: Card stuck in programming state! %s %s\n",
868 mmc_hostname(card->host),
869 req->rq_disk->disk_name, __func__);
870 return -ETIMEDOUT;
871 }
872
873 /*
874 * Some cards mishandle the status bits,
875 * so make sure to check both the busy
876 * indication and the card state.
877 */
878 } while (!(status & R1_READY_FOR_DATA) ||
879 (R1_CURRENT_STATE(status) == R1_STATE_PRG));
880
881 return err;
882}
883
bb5cba40
UH		 884static int send_stop(struct mmc_card *card, unsigned int timeout_ms,
885 struct request *req, int *gen_err, u32 *stop_status)
886{
887 struct mmc_host *host = card->host;
888 struct mmc_command cmd = {0};
889 int err;
890 bool use_r1b_resp = rq_data_dir(req) == WRITE;
891
892 /*
893 * Normally we use R1B responses for WRITE, but in cases where the host
894 * has specified a max_busy_timeout we need to validate it. A failure
895 * means we need to prevent the host from doing hw busy detection, which
896 * is done by converting to a R1 response instead.
897 */
898 if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout))
899 use_r1b_resp = false;
900
901 cmd.opcode = MMC_STOP_TRANSMISSION;
902 if (use_r1b_resp) {
903 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
904 cmd.busy_timeout = timeout_ms;
905 } else {
906 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
907 }
908
909 err = mmc_wait_for_cmd(host, &cmd, 5);
910 if (err)
911 return err;
912
913 *stop_status = cmd.resp[0];
914
915 /* No need to check card status in case of READ. */
916 if (rq_data_dir(req) == READ)
917 return 0;
918
919 if (!mmc_host_is_spi(host) &&
920 (*stop_status & R1_ERROR)) {
921 pr_err("%s: %s: general error sending stop command, resp %#x\n",
922 req->rq_disk->disk_name, __func__, *stop_status);
923 *gen_err = 1;
924 }
925
926 return card_busy_detect(card, timeout_ms, use_r1b_resp, req, gen_err);
927}
928
a8ad82cc 929#define ERR_NOMEDIUM 3
a01f3ccf
RKAL		 930#define ERR_RETRY 2
931#define ERR_ABORT 1
932#define ERR_CONTINUE 0
933
934static int mmc_blk_cmd_error(struct request *req, const char *name, int error,
935 bool status_valid, u32 status)
936{
937 switch (error) {
938 case -EILSEQ:
939 /* response crc error, retry the r/w cmd */
940 pr_err("%s: %s sending %s command, card status %#x\n",
941 req->rq_disk->disk_name, "response CRC error",
942 name, status);
943 return ERR_RETRY;
944
945 case -ETIMEDOUT:
946 pr_err("%s: %s sending %s command, card status %#x\n",
947 req->rq_disk->disk_name, "timed out", name, status);
948
949 /* If the status cmd initially failed, retry the r/w cmd */
950 if (!status_valid)
951 return ERR_RETRY;
952
953 /*
954 * If it was a r/w cmd crc error, or illegal command
955 * (eg, issued in wrong state) then retry - we should
956 * have corrected the state problem above.
957 */
958 if (status & (R1_COM_CRC_ERROR | R1_ILLEGAL_COMMAND))
959 return ERR_RETRY;
960
961 /* Otherwise abort the command */
962 return ERR_ABORT;
963
964 default:
965 /* We don't understand the error code the driver gave us */
966 pr_err("%s: unknown error %d sending read/write command, card status %#x\n",
967 req->rq_disk->disk_name, error, status);
968 return ERR_ABORT;
969 }
970}
971
972/*
973 * Initial r/w and stop cmd error recovery.
974 * We don't know whether the card received the r/w cmd or not, so try to
975 * restore things back to a sane state. Essentially, we do this as follows:
976 * - Obtain card status. If the first attempt to obtain card status fails,
977 * the status word will reflect the failed status cmd, not the failed
978 * r/w cmd. If we fail to obtain card status, it suggests we can no
979 * longer communicate with the card.
980 * - Check the card state. If the card received the cmd but there was a
981 * transient problem with the response, it might still be in a data transfer
982 * mode. Try to send it a stop command. If this fails, we can't recover.
983 * - If the r/w cmd failed due to a response CRC error, it was probably
984 * transient, so retry the cmd.
985 * - If the r/w cmd timed out, but we didn't get the r/w cmd status, retry.
986 * - If the r/w cmd timed out, and the r/w cmd failed due to CRC error or
987 * illegal cmd, retry.
988 * Otherwise we don't understand what happened, so abort.
989 */
990static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
c8760069 991 struct mmc_blk_request *brq, int *ecc_err, int *gen_err)
a01f3ccf
RKAL		 992{
993 bool prev_cmd_status_valid = true;
994 u32 status, stop_status = 0;
995 int err, retry;
996
a8ad82cc
SRT		 997 if (mmc_card_removed(card))
998 return ERR_NOMEDIUM;
999
a01f3ccf
RKAL		 1000 /*
1001 * Try to get card status which indicates both the card state
1002 * and why there was no response. If the first attempt fails,
1003 * we can't be sure the returned status is for the r/w command.
1004 */
1005 for (retry = 2; retry >= 0; retry--) {
1006 err = get_card_status(card, &status, 0);
1007 if (!err)
1008 break;
1009
6f398ad2
AH		 1010 /* Re-tune if needed */
1011 mmc_retune_recheck(card->host);
1012
a01f3ccf
RKAL		 1013 prev_cmd_status_valid = false;
1014 pr_err("%s: error %d sending status command, %sing\n",
1015 req->rq_disk->disk_name, err, retry ? "retry" : "abort");
1016 }
1017
1018 /* We couldn't get a response from the card. Give up. */
a8ad82cc
SRT		 1019 if (err) {
1020 /* Check if the card is removed */
1021 if (mmc_detect_card_removed(card->host))
1022 return ERR_NOMEDIUM;
a01f3ccf 1023 return ERR_ABORT;
a8ad82cc 1024 }
a01f3ccf 1025
67716327
AH		 1026 /* Flag ECC errors */
1027 if ((status & R1_CARD_ECC_FAILED) ||
1028 (brq->stop.resp[0] & R1_CARD_ECC_FAILED) ||
1029 (brq->cmd.resp[0] & R1_CARD_ECC_FAILED))
1030 *ecc_err = 1;
1031
c8760069
KY		 1032 /* Flag General errors */
1033 if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ)
1034 if ((status & R1_ERROR) ||
1035 (brq->stop.resp[0] & R1_ERROR)) {
1036 pr_err("%s: %s: general error sending stop or status command, stop cmd response %#x, card status %#x\n",
1037 req->rq_disk->disk_name, __func__,
1038 brq->stop.resp[0], status);
1039 *gen_err = 1;
1040 }
1041
a01f3ccf
RKAL		 1042 /*
1043 * Check the current card state. If it is in some data transfer
1044 * mode, tell it to stop (and hopefully transition back to TRAN.)
1045 */
1046 if (R1_CURRENT_STATE(status) == R1_STATE_DATA ||
1047 R1_CURRENT_STATE(status) == R1_STATE_RCV) {
bb5cba40
UH		 1048 err = send_stop(card,
1049 DIV_ROUND_UP(brq->data.timeout_ns, 1000000),
1050 req, gen_err, &stop_status);
1051 if (err) {
a01f3ccf
RKAL		 1052 pr_err("%s: error %d sending stop command\n",
1053 req->rq_disk->disk_name, err);
bb5cba40
UH		 1054 /*
1055 * If the stop cmd also timed out, the card is probably
1056 * not present, so abort. Other errors are bad news too.
1057 */
a01f3ccf 1058 return ERR_ABORT;
bb5cba40
UH		 1059 }
1060
67716327
AH		 1061 if (stop_status & R1_CARD_ECC_FAILED)
1062 *ecc_err = 1;
a01f3ccf
RKAL		 1063 }
1064
1065 /* Check for set block count errors */
1066 if (brq->sbc.error)
1067 return mmc_blk_cmd_error(req, "SET_BLOCK_COUNT", brq->sbc.error,
1068 prev_cmd_status_valid, status);
1069
1070 /* Check for r/w command errors */
1071 if (brq->cmd.error)
1072 return mmc_blk_cmd_error(req, "r/w cmd", brq->cmd.error,
1073 prev_cmd_status_valid, status);
1074
67716327
AH		 1075 /* Data errors */
1076 if (!brq->stop.error)
1077 return ERR_CONTINUE;
1078
a01f3ccf 1079 /* Now for stop errors. These aren't fatal to the transfer. */
5e1344eb 1080 pr_info("%s: error %d sending stop command, original cmd response %#x, card status %#x\n",
a01f3ccf
RKAL		 1081 req->rq_disk->disk_name, brq->stop.error,
1082 brq->cmd.resp[0], status);
1083
1084 /*
1085 * Subsitute in our own stop status as this will give the error
1086 * state which happened during the execution of the r/w command.
1087 */
1088 if (stop_status) {
1089 brq->stop.resp[0] = stop_status;
1090 brq->stop.error = 0;
1091 }
1092 return ERR_CONTINUE;
1093}
1094
67716327
AH		 1095static int mmc_blk_reset(struct mmc_blk_data *md, struct mmc_host *host,
1096 int type)
1097{
1098 int err;
1099
1100 if (md->reset_done & type)
1101 return -EEXIST;
1102
1103 md->reset_done |= type;
1104 err = mmc_hw_reset(host);
1105 /* Ensure we switch back to the correct partition */
1106 if (err != -EOPNOTSUPP) {
fc95e30b
UH		 1107 struct mmc_blk_data *main_md =
1108 dev_get_drvdata(&host->card->dev);
67716327
AH		 1109 int part_err;
1110
1111 main_md->part_curr = main_md->part_type;
1112 part_err = mmc_blk_part_switch(host->card, md);
1113 if (part_err) {
1114 /*
1115 * We have failed to get back into the correct
1116 * partition, so we need to abort the whole request.
1117 */
1118 return -ENODEV;
1119 }
1120 }
1121 return err;
1122}
1123
1124static inline void mmc_blk_reset_success(struct mmc_blk_data *md, int type)
1125{
1126 md->reset_done &= ~type;
1127}
1128
4e93b9a6
CD		 1129int mmc_access_rpmb(struct mmc_queue *mq)
1130{
1131 struct mmc_blk_data *md = mq->data;
1132 /*
1133 * If this is a RPMB partition access, return ture
1134 */
1135 if (md && md->part_type == EXT_CSD_PART_CONFIG_ACC_RPMB)
1136 return true;
1137
1138 return false;
1139}
1140
bd788c96
AH		 1141static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
1142{
1143 struct mmc_blk_data *md = mq->data;
1144 struct mmc_card *card = md->queue.card;
1145 unsigned int from, nr, arg;
67716327 1146 int err = 0, type = MMC_BLK_DISCARD;
bd788c96 1147
bd788c96
AH		 1148 if (!mmc_can_erase(card)) {
1149 err = -EOPNOTSUPP;
1150 goto out;
1151 }
1152
1153 from = blk_rq_pos(req);
1154 nr = blk_rq_sectors(req);
1155
b3bf9153
KP		 1156 if (mmc_can_discard(card))
1157 arg = MMC_DISCARD_ARG;
1158 else if (mmc_can_trim(card))
bd788c96
AH		 1159 arg = MMC_TRIM_ARG;
1160 else
1161 arg = MMC_ERASE_ARG;
67716327 1162retry:
6a7a6b45
AW		 1163 if (card->quirks & MMC_QUIRK_INAND_CMD38) {
1164 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1165 INAND_CMD38_ARG_EXT_CSD,
1166 arg == MMC_TRIM_ARG ?
1167 INAND_CMD38_ARG_TRIM :
1168 INAND_CMD38_ARG_ERASE,
1169 0);
1170 if (err)
1171 goto out;
1172 }
bd788c96
AH		 1173 err = mmc_erase(card, from, nr, arg);
1174out:
67716327
AH		 1175 if (err == -EIO && !mmc_blk_reset(md, card->host, type))
1176 goto retry;
1177 if (!err)
1178 mmc_blk_reset_success(md, type);
ecf8b5d0 1179 blk_end_request(req, err, blk_rq_bytes(req));
bd788c96 1180
bd788c96
AH		 1181 return err ? 0 : 1;
1182}
1183
49804548
AH		 1184static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
1185 struct request *req)
1186{
1187 struct mmc_blk_data *md = mq->data;
1188 struct mmc_card *card = md->queue.card;
775a9362 1189 unsigned int from, nr, arg;
67716327 1190 int err = 0, type = MMC_BLK_SECDISCARD;
49804548 1191
775a9362 1192 if (!(mmc_can_secure_erase_trim(card))) {
49804548
AH		 1193 err = -EOPNOTSUPP;
1194 goto out;
1195 }
1196
28302812
AH		 1197 from = blk_rq_pos(req);
1198 nr = blk_rq_sectors(req);
1199
775a9362
ME		 1200 if (mmc_can_trim(card) && !mmc_erase_group_aligned(card, from, nr))
1201 arg = MMC_SECURE_TRIM1_ARG;
1202 else
1203 arg = MMC_SECURE_ERASE_ARG;
d9ddd629 1204
67716327 1205retry:
6a7a6b45
AW		 1206 if (card->quirks & MMC_QUIRK_INAND_CMD38) {
1207 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1208 INAND_CMD38_ARG_EXT_CSD,
1209 arg == MMC_SECURE_TRIM1_ARG ?
1210 INAND_CMD38_ARG_SECTRIM1 :
1211 INAND_CMD38_ARG_SECERASE,
1212 0);
1213 if (err)
28302812 1214 goto out_retry;
6a7a6b45 1215 }
28302812 1216
49804548 1217 err = mmc_erase(card, from, nr, arg);
28302812
AH		 1218 if (err == -EIO)
1219 goto out_retry;
1220 if (err)
1221 goto out;
1222
1223 if (arg == MMC_SECURE_TRIM1_ARG) {
6a7a6b45
AW		 1224 if (card->quirks & MMC_QUIRK_INAND_CMD38) {
1225 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1226 INAND_CMD38_ARG_EXT_CSD,
1227 INAND_CMD38_ARG_SECTRIM2,
1228 0);
1229 if (err)
28302812 1230 goto out_retry;
6a7a6b45 1231 }
28302812 1232
49804548 1233 err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG);
28302812
AH		 1234 if (err == -EIO)
1235 goto out_retry;
1236 if (err)
1237 goto out;
6a7a6b45 1238 }
28302812 1239
28302812
AH		 1240out_retry:
1241 if (err && !mmc_blk_reset(md, card->host, type))
67716327
AH		 1242 goto retry;
1243 if (!err)
1244 mmc_blk_reset_success(md, type);
28302812 1245out:
ecf8b5d0 1246 blk_end_request(req, err, blk_rq_bytes(req));
49804548 1247
49804548
AH		 1248 return err ? 0 : 1;
1249}
1250
f4c5522b
AW		 1251static int mmc_blk_issue_flush(struct mmc_queue *mq, struct request *req)
1252{
1253 struct mmc_blk_data *md = mq->data;
881d1c25
SJ		 1254 struct mmc_card *card = md->queue.card;
1255 int ret = 0;
1256
1257 ret = mmc_flush_cache(card);
1258 if (ret)
1259 ret = -EIO;
f4c5522b 1260
ecf8b5d0 1261 blk_end_request_all(req, ret);
f4c5522b 1262
881d1c25 1263 return ret ? 0 : 1;
f4c5522b
AW		 1264}
1265
1266/*
1267 * Reformat current write as a reliable write, supporting
1268 * both legacy and the enhanced reliable write MMC cards.
1269 * In each transfer we'll handle only as much as a single
1270 * reliable write can handle, thus finish the request in
1271 * partial completions.
1272 */
d0c97cfb
AW		 1273static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq,
1274 struct mmc_card *card,
1275 struct request *req)
f4c5522b 1276{
f4c5522b
AW		 1277 if (!(card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN)) {
1278 /* Legacy mode imposes restrictions on transfers. */
1279 if (!IS_ALIGNED(brq->cmd.arg, card->ext_csd.rel_sectors))
1280 brq->data.blocks = 1;
1281
1282 if (brq->data.blocks > card->ext_csd.rel_sectors)
1283 brq->data.blocks = card->ext_csd.rel_sectors;
1284 else if (brq->data.blocks < card->ext_csd.rel_sectors)
1285 brq->data.blocks = 1;
1286 }
f4c5522b
AW		 1287}
1288
4c2b8f26
RKAL		 1289#define CMD_ERRORS \
1290 (R1_OUT_OF_RANGE | /* Command argument out of range */ \
1291 R1_ADDRESS_ERROR | /* Misaligned address */ \
1292 R1_BLOCK_LEN_ERROR | /* Transferred block length incorrect */\
1293 R1_WP_VIOLATION | /* Tried to write to protected block */ \
1294 R1_CC_ERROR | /* Card controller error */ \
1295 R1_ERROR) /* General/unknown error */
1296
ee8a43a5
PF		 1297static int mmc_blk_err_check(struct mmc_card *card,
1298 struct mmc_async_req *areq)
d78d4a8a 1299{
ee8a43a5
PF		 1300 struct mmc_queue_req *mq_mrq = container_of(areq, struct mmc_queue_req,
1301 mmc_active);
1302 struct mmc_blk_request *brq = &mq_mrq->brq;
1303 struct request *req = mq_mrq->req;
b8360a49 1304 int need_retune = card->host->need_retune;
c8760069 1305 int ecc_err = 0, gen_err = 0;
d78d4a8a
PF		 1306
1307 /*
1308 * sbc.error indicates a problem with the set block count
1309 * command. No data will have been transferred.
1310 *
1311 * cmd.error indicates a problem with the r/w command. No
1312 * data will have been transferred.
1313 *
1314 * stop.error indicates a problem with the stop command. Data
1315 * may have been transferred, or may still be transferring.
1316 */
67716327
AH		 1317 if (brq->sbc.error || brq->cmd.error || brq->stop.error ||
1318 brq->data.error) {
c8760069 1319 switch (mmc_blk_cmd_recovery(card, req, brq, &ecc_err, &gen_err)) {
d78d4a8a
PF		 1320 case ERR_RETRY:
1321 return MMC_BLK_RETRY;
1322 case ERR_ABORT:
1323 return MMC_BLK_ABORT;
a8ad82cc
SRT		 1324 case ERR_NOMEDIUM:
1325 return MMC_BLK_NOMEDIUM;
d78d4a8a
PF		 1326 case ERR_CONTINUE:
1327 break;
1328 }
1329 }
1330
1331 /*
1332 * Check for errors relating to the execution of the
1333 * initial command - such as address errors. No data
1334 * has been transferred.
1335 */
1336 if (brq->cmd.resp[0] & CMD_ERRORS) {
1337 pr_err("%s: r/w command failed, status = %#x\n",
1338 req->rq_disk->disk_name, brq->cmd.resp[0]);
1339 return MMC_BLK_ABORT;
1340 }
1341
1342 /*
1343 * Everything else is either success, or a data error of some
1344 * kind. If it was a write, we may have transitioned to
1345 * program mode, which we have to wait for it to complete.
1346 */
1347 if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
c49433fb 1348 int err;
8fee476b 1349
c8760069
KY		 1350 /* Check stop command response */
1351 if (brq->stop.resp[0] & R1_ERROR) {
1352 pr_err("%s: %s: general error sending stop command, stop cmd response %#x\n",
1353 req->rq_disk->disk_name, __func__,
1354 brq->stop.resp[0]);
1355 gen_err = 1;
1356 }
1357
95a91298
UH		 1358 err = card_busy_detect(card, MMC_BLK_TIMEOUT_MS, false, req,
1359 &gen_err);
c49433fb
UH		 1360 if (err)
1361 return MMC_BLK_CMD_ERR;
d78d4a8a
PF		 1362 }
1363
c8760069
KY		 1364 /* if general error occurs, retry the write operation. */
1365 if (gen_err) {
1366 pr_warn("%s: retrying write for general error\n",
1367 req->rq_disk->disk_name);
1368 return MMC_BLK_RETRY;
1369 }
1370
d78d4a8a 1371 if (brq->data.error) {
b8360a49 1372 if (need_retune && !brq->retune_retry_done) {
09faf61d
RK		 1373 pr_debug("%s: retrying because a re-tune was needed\n",
1374 req->rq_disk->disk_name);
b8360a49
AH		 1375 brq->retune_retry_done = 1;
1376 return MMC_BLK_RETRY;
1377 }
d78d4a8a
PF		 1378 pr_err("%s: error %d transferring data, sector %u, nr %u, cmd response %#x, card status %#x\n",
1379 req->rq_disk->disk_name, brq->data.error,
1380 (unsigned)blk_rq_pos(req),
1381 (unsigned)blk_rq_sectors(req),
1382 brq->cmd.resp[0], brq->stop.resp[0]);
1383
1384 if (rq_data_dir(req) == READ) {
67716327
AH		 1385 if (ecc_err)
1386 return MMC_BLK_ECC_ERR;
d78d4a8a
PF		 1387 return MMC_BLK_DATA_ERR;
1388 } else {
1389 return MMC_BLK_CMD_ERR;
1390 }
1391 }
1392
67716327
AH		 1393 if (!brq->data.bytes_xfered)
1394 return MMC_BLK_RETRY;
d78d4a8a 1395
ce39f9d1
SJ		 1396 if (mmc_packed_cmd(mq_mrq->cmd_type)) {
1397 if (unlikely(brq->data.blocks << 9 != brq->data.bytes_xfered))
1398 return MMC_BLK_PARTIAL;
1399 else
1400 return MMC_BLK_SUCCESS;
1401 }
1402
67716327
AH		 1403 if (blk_rq_bytes(req) != brq->data.bytes_xfered)
1404 return MMC_BLK_PARTIAL;
1405
1406 return MMC_BLK_SUCCESS;
d78d4a8a
PF		 1407}
1408
ce39f9d1
SJ		 1409static int mmc_blk_packed_err_check(struct mmc_card *card,
1410 struct mmc_async_req *areq)
1411{
1412 struct mmc_queue_req *mq_rq = container_of(areq, struct mmc_queue_req,
1413 mmc_active);
1414 struct request *req = mq_rq->req;
1415 struct mmc_packed *packed = mq_rq->packed;
1416 int err, check, status;
1417 u8 *ext_csd;
1418
1419 BUG_ON(!packed);
1420
1421 packed->retries--;
1422 check = mmc_blk_err_check(card, areq);
1423 err = get_card_status(card, &status, 0);
1424 if (err) {
1425 pr_err("%s: error %d sending status command\n",
1426 req->rq_disk->disk_name, err);
1427 return MMC_BLK_ABORT;
1428 }
1429
1430 if (status & R1_EXCEPTION_EVENT) {
86817ffb 1431 err = mmc_get_ext_csd(card, &ext_csd);
ce39f9d1
SJ		 1432 if (err) {
1433 pr_err("%s: error %d sending ext_csd\n",
1434 req->rq_disk->disk_name, err);
86817ffb 1435 return MMC_BLK_ABORT;
ce39f9d1
SJ		 1436 }
1437
1438 if ((ext_csd[EXT_CSD_EXP_EVENTS_STATUS] &
1439 EXT_CSD_PACKED_FAILURE) &&
1440 (ext_csd[EXT_CSD_PACKED_CMD_STATUS] &
1441 EXT_CSD_PACKED_GENERIC_ERROR)) {
1442 if (ext_csd[EXT_CSD_PACKED_CMD_STATUS] &
1443 EXT_CSD_PACKED_INDEXED_ERROR) {
1444 packed->idx_failure =
1445 ext_csd[EXT_CSD_PACKED_FAILURE_INDEX] - 1;
1446 check = MMC_BLK_PARTIAL;
1447 }
1448 pr_err("%s: packed cmd failed, nr %u, sectors %u, "
1449 "failure index: %d\n",
1450 req->rq_disk->disk_name, packed->nr_entries,
1451 packed->blocks, packed->idx_failure);
1452 }
ce39f9d1
SJ		 1453 kfree(ext_csd);
1454 }
1455
1456 return check;
1457}
1458
54d49d77
PF		 1459static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
1460 struct mmc_card *card,
1461 int disable_multi,
1462 struct mmc_queue *mq)
1da177e4 1463{
54d49d77
PF		 1464 u32 readcmd, writecmd;
1465 struct mmc_blk_request *brq = &mqrq->brq;
1466 struct request *req = mqrq->req;
1da177e4 1467 struct mmc_blk_data *md = mq->data;
4265900e 1468 bool do_data_tag;
1da177e4 1469
f4c5522b
AW		 1470 /*
1471 * Reliable writes are used to implement Forced Unit Access and
d3df0465 1472 * are supported only on MMCs.
f4c5522b 1473 */
d3df0465 1474 bool do_rel_wr = (req->cmd_flags & REQ_FUA) &&
f4c5522b 1475 (rq_data_dir(req) == WRITE) &&
d0c97cfb 1476 (md->flags & MMC_BLK_REL_WR);
f4c5522b 1477
54d49d77
PF		 1478 memset(brq, 0, sizeof(struct mmc_blk_request));
1479 brq->mrq.cmd = &brq->cmd;
1480 brq->mrq.data = &brq->data;
1da177e4 1481
54d49d77
PF		 1482 brq->cmd.arg = blk_rq_pos(req);
1483 if (!mmc_card_blockaddr(card))
1484 brq->cmd.arg <<= 9;
1485 brq->cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
1486 brq->data.blksz = 512;
1487 brq->stop.opcode = MMC_STOP_TRANSMISSION;
1488 brq->stop.arg = 0;
54d49d77 1489 brq->data.blocks = blk_rq_sectors(req);
6a79e391 1490
54d49d77
PF		 1491 /*
1492 * The block layer doesn't support all sector count
1493 * restrictions, so we need to be prepared for too big
1494 * requests.
1495 */
1496 if (brq->data.blocks > card->host->max_blk_count)
1497 brq->data.blocks = card->host->max_blk_count;
1da177e4 1498
2bf22b39
PW		 1499 if (brq->data.blocks > 1) {
1500 /*
1501 * After a read error, we redo the request one sector
1502 * at a time in order to accurately determine which
1503 * sectors can be read successfully.
1504 */
1505 if (disable_multi)
1506 brq->data.blocks = 1;
1507
2e47e842
KM		 1508 /*
1509 * Some controllers have HW issues while operating
1510 * in multiple I/O mode
1511 */
1512 if (card->host->ops->multi_io_quirk)
1513 brq->data.blocks = card->host->ops->multi_io_quirk(card,
1514 (rq_data_dir(req) == READ) ?
1515 MMC_DATA_READ : MMC_DATA_WRITE,
1516 brq->data.blocks);
2bf22b39 1517 }
d0c97cfb 1518
54d49d77
PF		 1519 if (brq->data.blocks > 1 || do_rel_wr) {
1520 /* SPI multiblock writes terminate using a special
1521 * token, not a STOP_TRANSMISSION request.
d0c97cfb 1522 */
54d49d77
PF		 1523 if (!mmc_host_is_spi(card->host) ||
1524 rq_data_dir(req) == READ)
1525 brq->mrq.stop = &brq->stop;
1526 readcmd = MMC_READ_MULTIPLE_BLOCK;
1527 writecmd = MMC_WRITE_MULTIPLE_BLOCK;
1528 } else {
1529 brq->mrq.stop = NULL;
1530 readcmd = MMC_READ_SINGLE_BLOCK;
1531 writecmd = MMC_WRITE_BLOCK;
1532 }
1533 if (rq_data_dir(req) == READ) {
1534 brq->cmd.opcode = readcmd;
f53f1102 1535 brq->data.flags = MMC_DATA_READ;
bcc3e172
UH		 1536 if (brq->mrq.stop)
1537 brq->stop.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 |
1538 MMC_CMD_AC;
54d49d77
PF		 1539 } else {
1540 brq->cmd.opcode = writecmd;
f53f1102 1541 brq->data.flags = MMC_DATA_WRITE;
bcc3e172
UH		 1542 if (brq->mrq.stop)
1543 brq->stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B |
1544 MMC_CMD_AC;
54d49d77 1545 }
d0c97cfb 1546
54d49d77
PF		 1547 if (do_rel_wr)
1548 mmc_apply_rel_rw(brq, card, req);
f4c5522b 1549
4265900e
SD		 1550 /*
1551 * Data tag is used only during writing meta data to speed
1552 * up write and any subsequent read of this meta data
1553 */
1554 do_data_tag = (card->ext_csd.data_tag_unit_size) &&
1555 (req->cmd_flags & REQ_META) &&
1556 (rq_data_dir(req) == WRITE) &&
1557 ((brq->data.blocks * brq->data.blksz) >=
1558 card->ext_csd.data_tag_unit_size);
1559
54d49d77
PF		 1560 /*
1561 * Pre-defined multi-block transfers are preferable to
1562 * open ended-ones (and necessary for reliable writes).
1563 * However, it is not sufficient to just send CMD23,
1564 * and avoid the final CMD12, as on an error condition
1565 * CMD12 (stop) needs to be sent anyway. This, coupled
1566 * with Auto-CMD23 enhancements provided by some
1567 * hosts, means that the complexity of dealing
1568 * with this is best left to the host. If CMD23 is
1569 * supported by card and host, we'll fill sbc in and let
1570 * the host deal with handling it correctly. This means
1571 * that for hosts that don't expose MMC_CAP_CMD23, no
1572 * change of behavior will be observed.
1573 *
1574 * N.B: Some MMC cards experience perf degradation.
1575 * We'll avoid using CMD23-bounded multiblock writes for
1576 * these, while retaining features like reliable writes.
1577 */
4265900e
SD		 1578 if ((md->flags & MMC_BLK_CMD23) && mmc_op_multi(brq->cmd.opcode) &&
1579 (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23) ||
1580 do_data_tag)) {
54d49d77
PF		 1581 brq->sbc.opcode = MMC_SET_BLOCK_COUNT;
1582 brq->sbc.arg = brq->data.blocks |
4265900e
SD		 1583 (do_rel_wr ? (1 << 31) : 0) |
1584 (do_data_tag ? (1 << 29) : 0);
54d49d77
PF		 1585 brq->sbc.flags = MMC_RSP_R1 | MMC_CMD_AC;
1586 brq->mrq.sbc = &brq->sbc;
1587 }
98ccf149 1588
54d49d77
PF		 1589 mmc_set_data_timeout(&brq->data, card);
1590
1591 brq->data.sg = mqrq->sg;
1592 brq->data.sg_len = mmc_queue_map_sg(mq, mqrq);
1593
1594 /*
1595 * Adjust the sg list so it is the same size as the
1596 * request.
1597 */
1598 if (brq->data.blocks != blk_rq_sectors(req)) {
1599 int i, data_size = brq->data.blocks << 9;
1600 struct scatterlist *sg;
1601
1602 for_each_sg(brq->data.sg, sg, brq->data.sg_len, i) {
1603 data_size -= sg->length;
1604 if (data_size <= 0) {
1605 sg->length += data_size;
1606 i++;
1607 break;
6a79e391 1608 }
6a79e391 1609 }
54d49d77
PF		 1610 brq->data.sg_len = i;
1611 }
1612
ee8a43a5
PF		 1613 mqrq->mmc_active.mrq = &brq->mrq;
1614 mqrq->mmc_active.err_check = mmc_blk_err_check;
1615
54d49d77
PF		 1616 mmc_queue_bounce_pre(mqrq);
1617}
6a79e391 1618
ce39f9d1
SJ		 1619static inline u8 mmc_calc_packed_hdr_segs(struct request_queue *q,
1620 struct mmc_card *card)
1621{
1622 unsigned int hdr_sz = mmc_large_sector(card) ? 4096 : 512;
1623 unsigned int max_seg_sz = queue_max_segment_size(q);
1624 unsigned int len, nr_segs = 0;
1625
1626 do {
1627 len = min(hdr_sz, max_seg_sz);
1628 hdr_sz -= len;
1629 nr_segs++;
1630 } while (hdr_sz);
1631
1632 return nr_segs;
1633}
1634
1635static u8 mmc_blk_prep_packed_list(struct mmc_queue *mq, struct request *req)
1636{
1637 struct request_queue *q = mq->queue;
1638 struct mmc_card *card = mq->card;
1639 struct request *cur = req, *next = NULL;
1640 struct mmc_blk_data *md = mq->data;
1641 struct mmc_queue_req *mqrq = mq->mqrq_cur;
1642 bool en_rel_wr = card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN;
1643 unsigned int req_sectors = 0, phys_segments = 0;
1644 unsigned int max_blk_count, max_phys_segs;
1645 bool put_back = true;
1646 u8 max_packed_rw = 0;
1647 u8 reqs = 0;
1648
1649 if (!(md->flags & MMC_BLK_PACKED_CMD))
1650 goto no_packed;
1651
1652 if ((rq_data_dir(cur) == WRITE) &&
1653 mmc_host_packed_wr(card->host))
1654 max_packed_rw = card->ext_csd.max_packed_writes;
1655
1656 if (max_packed_rw == 0)
1657 goto no_packed;
1658
1659 if (mmc_req_rel_wr(cur) &&
1660 (md->flags & MMC_BLK_REL_WR) && !en_rel_wr)
1661 goto no_packed;
1662
1663 if (mmc_large_sector(card) &&
1664 !IS_ALIGNED(blk_rq_sectors(cur), 8))
1665 goto no_packed;
1666
1667 mmc_blk_clear_packed(mqrq);
1668
1669 max_blk_count = min(card->host->max_blk_count,
1670 card->host->max_req_size >> 9);
1671 if (unlikely(max_blk_count > 0xffff))
1672 max_blk_count = 0xffff;
1673
1674 max_phys_segs = queue_max_segments(q);
1675 req_sectors += blk_rq_sectors(cur);
1676 phys_segments += cur->nr_phys_segments;
1677
1678 if (rq_data_dir(cur) == WRITE) {
1679 req_sectors += mmc_large_sector(card) ? 8 : 1;
1680 phys_segments += mmc_calc_packed_hdr_segs(q, card);
1681 }
1682
1683 do {
1684 if (reqs >= max_packed_rw - 1) {
1685 put_back = false;
1686 break;
1687 }
1688
1689 spin_lock_irq(q->queue_lock);
1690 next = blk_fetch_request(q);
1691 spin_unlock_irq(q->queue_lock);
1692 if (!next) {
1693 put_back = false;
1694 break;
1695 }
1696
1697 if (mmc_large_sector(card) &&
1698 !IS_ALIGNED(blk_rq_sectors(next), 8))
1699 break;
1700
1701 if (next->cmd_flags & REQ_DISCARD ||
1702 next->cmd_flags & REQ_FLUSH)
1703 break;
1704
1705 if (rq_data_dir(cur) != rq_data_dir(next))
1706 break;
1707
1708 if (mmc_req_rel_wr(next) &&
1709 (md->flags & MMC_BLK_REL_WR) && !en_rel_wr)
1710 break;
1711
1712 req_sectors += blk_rq_sectors(next);
1713 if (req_sectors > max_blk_count)
1714 break;
1715
1716 phys_segments += next->nr_phys_segments;
1717 if (phys_segments > max_phys_segs)
1718 break;
1719
1720 list_add_tail(&next->queuelist, &mqrq->packed->list);
1721 cur = next;
1722 reqs++;
1723 } while (1);
1724
1725 if (put_back) {
1726 spin_lock_irq(q->queue_lock);
1727 blk_requeue_request(q, next);
1728 spin_unlock_irq(q->queue_lock);
1729 }
1730
1731 if (reqs > 0) {
1732 list_add(&req->queuelist, &mqrq->packed->list);
1733 mqrq->packed->nr_entries = ++reqs;
1734 mqrq->packed->retries = reqs;
1735 return reqs;
1736 }
1737
1738no_packed:
1739 mqrq->cmd_type = MMC_PACKED_NONE;
1740 return 0;
1741}
1742
1743static void mmc_blk_packed_hdr_wrq_prep(struct mmc_queue_req *mqrq,
1744 struct mmc_card *card,
1745 struct mmc_queue *mq)
1746{
1747 struct mmc_blk_request *brq = &mqrq->brq;
1748 struct request *req = mqrq->req;
1749 struct request *prq;
1750 struct mmc_blk_data *md = mq->data;
1751 struct mmc_packed *packed = mqrq->packed;
1752 bool do_rel_wr, do_data_tag;
1753 u32 *packed_cmd_hdr;
1754 u8 hdr_blocks;
1755 u8 i = 1;
1756
1757 BUG_ON(!packed);
1758
1759 mqrq->cmd_type = MMC_PACKED_WRITE;
1760 packed->blocks = 0;
1761 packed->idx_failure = MMC_PACKED_NR_IDX;
1762
1763 packed_cmd_hdr = packed->cmd_hdr;
1764 memset(packed_cmd_hdr, 0, sizeof(packed->cmd_hdr));
1765 packed_cmd_hdr[0] = (packed->nr_entries << 16) |
1766 (PACKED_CMD_WR << 8) | PACKED_CMD_VER;
1767 hdr_blocks = mmc_large_sector(card) ? 8 : 1;
1768
1769 /*
1770 * Argument for each entry of packed group
1771 */
1772 list_for_each_entry(prq, &packed->list, queuelist) {
1773 do_rel_wr = mmc_req_rel_wr(prq) && (md->flags & MMC_BLK_REL_WR);
1774 do_data_tag = (card->ext_csd.data_tag_unit_size) &&
1775 (prq->cmd_flags & REQ_META) &&
1776 (rq_data_dir(prq) == WRITE) &&
1777 ((brq->data.blocks * brq->data.blksz) >=
1778 card->ext_csd.data_tag_unit_size);
1779 /* Argument of CMD23 */
1780 packed_cmd_hdr[(i * 2)] =
1781 (do_rel_wr ? MMC_CMD23_ARG_REL_WR : 0) |
1782 (do_data_tag ? MMC_CMD23_ARG_TAG_REQ : 0) |
1783 blk_rq_sectors(prq);
1784 /* Argument of CMD18 or CMD25 */
1785 packed_cmd_hdr[((i * 2)) + 1] =
1786 mmc_card_blockaddr(card) ?
1787 blk_rq_pos(prq) : blk_rq_pos(prq) << 9;
1788 packed->blocks += blk_rq_sectors(prq);
1789 i++;
1790 }
1791
1792 memset(brq, 0, sizeof(struct mmc_blk_request));
1793 brq->mrq.cmd = &brq->cmd;
1794 brq->mrq.data = &brq->data;
1795 brq->mrq.sbc = &brq->sbc;
1796 brq->mrq.stop = &brq->stop;
1797
1798 brq->sbc.opcode = MMC_SET_BLOCK_COUNT;
1799 brq->sbc.arg = MMC_CMD23_ARG_PACKED | (packed->blocks + hdr_blocks);
1800 brq->sbc.flags = MMC_RSP_R1 | MMC_CMD_AC;
1801
1802 brq->cmd.opcode = MMC_WRITE_MULTIPLE_BLOCK;
1803 brq->cmd.arg = blk_rq_pos(req);
1804 if (!mmc_card_blockaddr(card))
1805 brq->cmd.arg <<= 9;
1806 brq->cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
1807
1808 brq->data.blksz = 512;
1809 brq->data.blocks = packed->blocks + hdr_blocks;
f53f1102 1810 brq->data.flags = MMC_DATA_WRITE;
ce39f9d1
SJ		 1811
1812 brq->stop.opcode = MMC_STOP_TRANSMISSION;
1813 brq->stop.arg = 0;
1814 brq->stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
1815
1816 mmc_set_data_timeout(&brq->data, card);
1817
1818 brq->data.sg = mqrq->sg;
1819 brq->data.sg_len = mmc_queue_map_sg(mq, mqrq);
1820
1821 mqrq->mmc_active.mrq = &brq->mrq;
1822 mqrq->mmc_active.err_check = mmc_blk_packed_err_check;
1823
1824 mmc_queue_bounce_pre(mqrq);
1825}
1826
67716327
AH		 1827static int mmc_blk_cmd_err(struct mmc_blk_data *md, struct mmc_card *card,
1828 struct mmc_blk_request *brq, struct request *req,
1829 int ret)
1830{
ce39f9d1
SJ		 1831 struct mmc_queue_req *mq_rq;
1832 mq_rq = container_of(brq, struct mmc_queue_req, brq);
1833
67716327
AH		 1834 /*
1835 * If this is an SD card and we're writing, we can first
1836 * mark the known good sectors as ok.
1837 *
1838 * If the card is not SD, we can still ok written sectors
1839 * as reported by the controller (which might be less than
1840 * the real number of written sectors, but never more).
1841 */
1842 if (mmc_card_sd(card)) {
1843 u32 blocks;
1844
1845 blocks = mmc_sd_num_wr_blocks(card);
1846 if (blocks != (u32)-1) {
ecf8b5d0 1847 ret = blk_end_request(req, 0, blocks << 9);
67716327
AH		 1848 }
1849 } else {
ce39f9d1
SJ		 1850 if (!mmc_packed_cmd(mq_rq->cmd_type))
1851 ret = blk_end_request(req, 0, brq->data.bytes_xfered);
67716327
AH		 1852 }
1853 return ret;
1854}
1855
ce39f9d1
SJ		 1856static int mmc_blk_end_packed_req(struct mmc_queue_req *mq_rq)
1857{
1858 struct request *prq;
1859 struct mmc_packed *packed = mq_rq->packed;
1860 int idx = packed->idx_failure, i = 0;
1861 int ret = 0;
1862
1863 BUG_ON(!packed);
1864
1865 while (!list_empty(&packed->list)) {
1866 prq = list_entry_rq(packed->list.next);
1867 if (idx == i) {
1868 /* retry from error index */
1869 packed->nr_entries -= idx;
1870 mq_rq->req = prq;
1871 ret = 1;
1872
1873 if (packed->nr_entries == MMC_PACKED_NR_SINGLE) {
1874 list_del_init(&prq->queuelist);
1875 mmc_blk_clear_packed(mq_rq);
1876 }
1877 return ret;
1878 }
1879 list_del_init(&prq->queuelist);
1880 blk_end_request(prq, 0, blk_rq_bytes(prq));
1881 i++;
1882 }
1883
1884 mmc_blk_clear_packed(mq_rq);
1885 return ret;
1886}
1887
1888static void mmc_blk_abort_packed_req(struct mmc_queue_req *mq_rq)
1889{
1890 struct request *prq;
1891 struct mmc_packed *packed = mq_rq->packed;
1892
1893 BUG_ON(!packed);
1894
1895 while (!list_empty(&packed->list)) {
1896 prq = list_entry_rq(packed->list.next);
1897 list_del_init(&prq->queuelist);
1898 blk_end_request(prq, -EIO, blk_rq_bytes(prq));
1899 }
1900
1901 mmc_blk_clear_packed(mq_rq);
1902}
1903
1904static void mmc_blk_revert_packed_req(struct mmc_queue *mq,
1905 struct mmc_queue_req *mq_rq)
1906{
1907 struct request *prq;
1908 struct request_queue *q = mq->queue;
1909 struct mmc_packed *packed = mq_rq->packed;
1910
1911 BUG_ON(!packed);
1912
1913 while (!list_empty(&packed->list)) {
1914 prq = list_entry_rq(packed->list.prev);
1915 if (prq->queuelist.prev != &packed->list) {
1916 list_del_init(&prq->queuelist);
1917 spin_lock_irq(q->queue_lock);
1918 blk_requeue_request(mq->queue, prq);
1919 spin_unlock_irq(q->queue_lock);
1920 } else {
1921 list_del_init(&prq->queuelist);
1922 }
1923 }
1924
1925 mmc_blk_clear_packed(mq_rq);
1926}
1927
ee8a43a5 1928static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
54d49d77
PF		 1929{
1930 struct mmc_blk_data *md = mq->data;
1931 struct mmc_card *card = md->queue.card;
1932 struct mmc_blk_request *brq = &mq->mqrq_cur->brq;
b8360a49 1933 int ret = 1, disable_multi = 0, retry = 0, type, retune_retry_done = 0;
d78d4a8a 1934 enum mmc_blk_status status;
ee8a43a5 1935 struct mmc_queue_req *mq_rq;
a5075eb9 1936 struct request *req = rqc;
ee8a43a5 1937 struct mmc_async_req *areq;
ce39f9d1
SJ		 1938 const u8 packed_nr = 2;
1939 u8 reqs = 0;
1da177e4 1940
ee8a43a5
PF		 1941 if (!rqc && !mq->mqrq_prev->req)
1942 return 0;
98ccf149 1943
ce39f9d1
SJ		 1944 if (rqc)
1945 reqs = mmc_blk_prep_packed_list(mq, rqc);
1946
ee8a43a5
PF		 1947 do {
1948 if (rqc) {
a5075eb9
SD		 1949 /*
1950 * When 4KB native sector is enabled, only 8 blocks
1951 * multiple read or write is allowed
1952 */
1953 if ((brq->data.blocks & 0x07) &&
1954 (card->ext_csd.data_sector_size == 4096)) {
1955 pr_err("%s: Transfer size is not 4KB sector size aligned\n",
1956 req->rq_disk->disk_name);
ce39f9d1 1957 mq_rq = mq->mqrq_cur;
a5075eb9
SD		 1958 goto cmd_abort;
1959 }
ce39f9d1
SJ		 1960
1961 if (reqs >= packed_nr)
1962 mmc_blk_packed_hdr_wrq_prep(mq->mqrq_cur,
1963 card, mq);
1964 else
1965 mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq);
ee8a43a5
PF		 1966 areq = &mq->mqrq_cur->mmc_active;
1967 } else
1968 areq = NULL;
1969 areq = mmc_start_req(card->host, areq, (int *) &status);
2220eedf
KD		 1970 if (!areq) {
1971 if (status == MMC_BLK_NEW_REQUEST)
1972 mq->flags |= MMC_QUEUE_NEW_REQUEST;
ee8a43a5 1973 return 0;
2220eedf 1974 }
ee8a43a5
PF		 1975
1976 mq_rq = container_of(areq, struct mmc_queue_req, mmc_active);
1977 brq = &mq_rq->brq;
1978 req = mq_rq->req;
67716327 1979 type = rq_data_dir(req) == READ ? MMC_BLK_READ : MMC_BLK_WRITE;
ee8a43a5 1980 mmc_queue_bounce_post(mq_rq);
98ccf149 1981
d78d4a8a
PF		 1982 switch (status) {
1983 case MMC_BLK_SUCCESS:
1984 case MMC_BLK_PARTIAL:
1985 /*
1986 * A block was successfully transferred.
1987 */
67716327 1988 mmc_blk_reset_success(md, type);
ce39f9d1
SJ		 1989
1990 if (mmc_packed_cmd(mq_rq->cmd_type)) {
1991 ret = mmc_blk_end_packed_req(mq_rq);
1992 break;
1993 } else {
1994 ret = blk_end_request(req, 0,
d78d4a8a 1995 brq->data.bytes_xfered);
ce39f9d1
SJ		 1996 }
1997
67716327
AH		 1998 /*
1999 * If the blk_end_request function returns non-zero even
2000 * though all data has been transferred and no errors
2001 * were returned by the host controller, it's a bug.
2002 */
ee8a43a5 2003 if (status == MMC_BLK_SUCCESS && ret) {
a3c76eb9 2004 pr_err("%s BUG rq_tot %d d_xfer %d\n",
ee8a43a5
PF		 2005 __func__, blk_rq_bytes(req),
2006 brq->data.bytes_xfered);
2007 rqc = NULL;
2008 goto cmd_abort;
2009 }
d78d4a8a
PF		 2010 break;
2011 case MMC_BLK_CMD_ERR:
67716327 2012 ret = mmc_blk_cmd_err(md, card, brq, req, ret);
29535f7b
DW		 2013 if (mmc_blk_reset(md, card->host, type))
2014 goto cmd_abort;
2015 if (!ret)
2016 goto start_new_req;
2017 break;
d78d4a8a 2018 case MMC_BLK_RETRY:
b8360a49 2019 retune_retry_done = brq->retune_retry_done;
d78d4a8a 2020 if (retry++ < 5)
a01f3ccf 2021 break;
67716327 2022 /* Fall through */
d78d4a8a 2023 case MMC_BLK_ABORT:
67716327
AH		 2024 if (!mmc_blk_reset(md, card->host, type))
2025 break;
4c2b8f26 2026 goto cmd_abort;
67716327
AH		 2027 case MMC_BLK_DATA_ERR: {
2028 int err;
2029
2030 err = mmc_blk_reset(md, card->host, type);
2031 if (!err)
2032 break;
ce39f9d1
SJ		 2033 if (err == -ENODEV ||
2034 mmc_packed_cmd(mq_rq->cmd_type))
67716327
AH		 2035 goto cmd_abort;
2036 /* Fall through */
2037 }
2038 case MMC_BLK_ECC_ERR:
2039 if (brq->data.blocks > 1) {
2040 /* Redo read one sector at a time */
6606110d
JP		 2041 pr_warn("%s: retrying using single block read\n",
2042 req->rq_disk->disk_name);
67716327
AH		 2043 disable_multi = 1;
2044 break;
2045 }
d78d4a8a
PF		 2046 /*
2047 * After an error, we redo I/O one sector at a
2048 * time, so we only reach here after trying to
2049 * read a single sector.
2050 */
ecf8b5d0 2051 ret = blk_end_request(req, -EIO,
d78d4a8a 2052 brq->data.blksz);
ee8a43a5
PF		 2053 if (!ret)
2054 goto start_new_req;
d78d4a8a 2055 break;
a8ad82cc
SRT		 2056 case MMC_BLK_NOMEDIUM:
2057 goto cmd_abort;
2220eedf
KD		 2058 default:
2059 pr_err("%s: Unhandled return value (%d)",
2060 req->rq_disk->disk_name, status);
2061 goto cmd_abort;
4c2b8f26
RKAL		 2062 }
2063
ee8a43a5 2064 if (ret) {
ce39f9d1
SJ		 2065 if (mmc_packed_cmd(mq_rq->cmd_type)) {
2066 if (!mq_rq->packed->retries)
2067 goto cmd_abort;
2068 mmc_blk_packed_hdr_wrq_prep(mq_rq, card, mq);
2069 mmc_start_req(card->host,
2070 &mq_rq->mmc_active, NULL);
2071 } else {
2072
2073 /*
2074 * In case of a incomplete request
2075 * prepare it again and resend.
2076 */
2077 mmc_blk_rw_rq_prep(mq_rq, card,
2078 disable_multi, mq);
2079 mmc_start_req(card->host,
2080 &mq_rq->mmc_active, NULL);
2081 }
b8360a49 2082 mq_rq->brq.retune_retry_done = retune_retry_done;
ee8a43a5 2083 }
1da177e4
LT		 2084 } while (ret);
2085
1da177e4
LT		 2086 return 1;
2087
a01f3ccf 2088 cmd_abort:
ce39f9d1
SJ		 2089 if (mmc_packed_cmd(mq_rq->cmd_type)) {
2090 mmc_blk_abort_packed_req(mq_rq);
2091 } else {
2092 if (mmc_card_removed(card))
2093 req->cmd_flags |= REQ_QUIET;
2094 while (ret)
2095 ret = blk_end_request(req, -EIO,
2096 blk_rq_cur_bytes(req));
2097 }
1da177e4 2098
ee8a43a5
PF		 2099 start_new_req:
2100 if (rqc) {
7a81902f
SJ		 2101 if (mmc_card_removed(card)) {
2102 rqc->cmd_flags |= REQ_QUIET;
2103 blk_end_request_all(rqc, -EIO);
2104 } else {
ce39f9d1
SJ		 2105 /*
2106 * If current request is packed, it needs to put back.
2107 */
2108 if (mmc_packed_cmd(mq->mqrq_cur->cmd_type))
2109 mmc_blk_revert_packed_req(mq, mq->mqrq_cur);
2110
7a81902f
SJ		 2111 mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq);
2112 mmc_start_req(card->host,
2113 &mq->mqrq_cur->mmc_active, NULL);
2114 }
ee8a43a5
PF		 2115 }
2116
1da177e4
LT		 2117 return 0;
2118}
2119
bd788c96
AH		 2120static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
2121{
1a258db6
AW		 2122 int ret;
2123 struct mmc_blk_data *md = mq->data;
2124 struct mmc_card *card = md->queue.card;
2220eedf
KD		 2125 struct mmc_host *host = card->host;
2126 unsigned long flags;
f662ae48 2127 unsigned int cmd_flags = req ? req->cmd_flags : 0;
1a258db6 2128
ee8a43a5
PF		 2129 if (req && !mq->mqrq_prev->req)
2130 /* claim host only for the first request */
e94cfef6 2131 mmc_get_card(card);
ee8a43a5 2132
371a689f
AW		 2133 ret = mmc_blk_part_switch(card, md);
2134 if (ret) {
0d7d85ca 2135 if (req) {
ecf8b5d0 2136 blk_end_request_all(req, -EIO);
0d7d85ca 2137 }
371a689f
AW		 2138 ret = 0;
2139 goto out;
2140 }
1a258db6 2141
2220eedf 2142 mq->flags &= ~MMC_QUEUE_NEW_REQUEST;
f662ae48 2143 if (cmd_flags & REQ_DISCARD) {
ee8a43a5
PF		 2144 /* complete ongoing async transfer before issuing discard */
2145 if (card->host->areq)
2146 mmc_blk_issue_rw_rq(mq, NULL);
5204d00f 2147 if (req->cmd_flags & REQ_SECURE)
1a258db6 2148 ret = mmc_blk_issue_secdiscard_rq(mq, req);
49804548 2149 else
1a258db6 2150 ret = mmc_blk_issue_discard_rq(mq, req);
f662ae48 2151 } else if (cmd_flags & REQ_FLUSH) {
393f9a08
JC		 2152 /* complete ongoing async transfer before issuing flush */
2153 if (card->host->areq)
2154 mmc_blk_issue_rw_rq(mq, NULL);
1a258db6 2155 ret = mmc_blk_issue_flush(mq, req);
49804548 2156 } else {
2220eedf
KD		 2157 if (!req && host->areq) {
2158 spin_lock_irqsave(&host->context_info.lock, flags);
2159 host->context_info.is_waiting_last_req = true;
2160 spin_unlock_irqrestore(&host->context_info.lock, flags);
2161 }
1a258db6 2162 ret = mmc_blk_issue_rw_rq(mq, req);
49804548 2163 }
1a258db6 2164
371a689f 2165out:
ef3a69c7 2166 if ((!req && !(mq->flags & MMC_QUEUE_NEW_REQUEST)) ||
f662ae48 2167 (cmd_flags & MMC_REQ_SPECIAL_MASK))
ef3a69c7
SJ		 2168 /*
2169 * Release host when there are no more requests
2170 * and after special request(discard, flush) is done.
2171 * In case sepecial request, there is no reentry to
2172 * the 'mmc_blk_issue_rq' with 'mqrq_prev->req'.
2173 */
e94cfef6 2174 mmc_put_card(card);
1a258db6 2175 return ret;
bd788c96 2176}
1da177e4 2177
a6f6c96b
RK		 2178static inline int mmc_blk_readonly(struct mmc_card *card)
2179{
2180 return mmc_card_readonly(card) ||
2181 !(card->csd.cmdclass & CCC_BLOCK_WRITE);
2182}
2183
371a689f
AW		 2184static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
2185 struct device *parent,
2186 sector_t size,
2187 bool default_ro,
add710ea
JR		 2188 const char *subname,
2189 int area_type)
1da177e4
LT		 2190{
2191 struct mmc_blk_data *md;
2192 int devidx, ret;
2193
5e71b7a6
OJ		 2194 devidx = find_first_zero_bit(dev_use, max_devices);
2195 if (devidx >= max_devices)
1da177e4
LT		 2196 return ERR_PTR(-ENOSPC);
2197 __set_bit(devidx, dev_use);
2198
dd00cc48 2199 md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
a6f6c96b
RK		 2200 if (!md) {
2201 ret = -ENOMEM;
2202 goto out;
2203 }
1da177e4 2204
f06c9153
AW		 2205 /*
2206 * !subname implies we are creating main mmc_blk_data that will be
fc95e30b 2207 * associated with mmc_card with dev_set_drvdata. Due to device
f06c9153
AW		 2208 * partitions, devidx will not coincide with a per-physical card
2209 * index anymore so we keep track of a name index.
2210 */
2211 if (!subname) {
2212 md->name_idx = find_first_zero_bit(name_use, max_devices);
2213 __set_bit(md->name_idx, name_use);
add710ea 2214 } else
f06c9153
AW		 2215 md->name_idx = ((struct mmc_blk_data *)
2216 dev_to_disk(parent)->private_data)->name_idx;
2217
add710ea
JR		 2218 md->area_type = area_type;
2219
a6f6c96b
RK		 2220 /*
2221 * Set the read-only status based on the supported commands
2222 * and the write protect switch.
2223 */
2224 md->read_only = mmc_blk_readonly(card);
1da177e4 2225
5e71b7a6 2226 md->disk = alloc_disk(perdev_minors);
a6f6c96b
RK		 2227 if (md->disk == NULL) {
2228 ret = -ENOMEM;
2229 goto err_kfree;
2230 }
1da177e4 2231
a6f6c96b 2232 spin_lock_init(&md->lock);
371a689f 2233 INIT_LIST_HEAD(&md->part);
a6f6c96b 2234 md->usage = 1;
1da177e4 2235
d09408ad 2236 ret = mmc_init_queue(&md->queue, card, &md->lock, subname);
a6f6c96b
RK		 2237 if (ret)
2238 goto err_putdisk;
1da177e4 2239
a6f6c96b
RK		 2240 md->queue.issue_fn = mmc_blk_issue_rq;
2241 md->queue.data = md;
d2b18394 2242
fe6b4c88 2243 md->disk->major = MMC_BLOCK_MAJOR;
5e71b7a6 2244 md->disk->first_minor = devidx * perdev_minors;
a6f6c96b
RK		 2245 md->disk->fops = &mmc_bdops;
2246 md->disk->private_data = md;
2247 md->disk->queue = md->queue.queue;
371a689f
AW		 2248 md->disk->driverfs_dev = parent;
2249 set_disk_ro(md->disk, md->read_only || default_ro);
382c55f8 2250 md->disk->flags = GENHD_FL_EXT_DEVT;
f5b4d71f 2251 if (area_type & (MMC_BLK_DATA_AREA_RPMB | MMC_BLK_DATA_AREA_BOOT))
53d8f974 2252 md->disk->flags |= GENHD_FL_NO_PART_SCAN;
a6f6c96b
RK		 2253
2254 /*
2255 * As discussed on lkml, GENHD_FL_REMOVABLE should:
2256 *
2257 * - be set for removable media with permanent block devices
2258 * - be unset for removable block devices with permanent media
2259 *
2260 * Since MMC block devices clearly fall under the second
2261 * case, we do not set GENHD_FL_REMOVABLE. Userspace
2262 * should use the block device creation/destruction hotplug
2263 * messages to tell when the card is present.
2264 */
2265
f06c9153 2266 snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
fe821915 2267 "mmcblk%u%s", md->name_idx, subname ? subname : "");
a6f6c96b 2268
a5075eb9
SD		 2269 if (mmc_card_mmc(card))
2270 blk_queue_logical_block_size(md->queue.queue,
2271 card->ext_csd.data_sector_size);
2272 else
2273 blk_queue_logical_block_size(md->queue.queue, 512);
2274
371a689f 2275 set_capacity(md->disk, size);
d0c97cfb 2276
f0d89972
AW		 2277 if (mmc_host_cmd23(card->host)) {
2278 if (mmc_card_mmc(card) ||
2279 (mmc_card_sd(card) &&
2280 card->scr.cmds & SD_SCR_CMD23_SUPPORT))
2281 md->flags |= MMC_BLK_CMD23;
2282 }
d0c97cfb
AW		 2283
2284 if (mmc_card_mmc(card) &&
2285 md->flags & MMC_BLK_CMD23 &&
2286 ((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) ||
2287 card->ext_csd.rel_sectors)) {
2288 md->flags |= MMC_BLK_REL_WR;
2289 blk_queue_flush(md->queue.queue, REQ_FLUSH | REQ_FUA);
2290 }
2291
ce39f9d1
SJ		 2292 if (mmc_card_mmc(card) &&
2293 (area_type == MMC_BLK_DATA_AREA_MAIN) &&
2294 (md->flags & MMC_BLK_CMD23) &&
2295 card->ext_csd.packed_event_en) {
2296 if (!mmc_packed_init(&md->queue, card))
2297 md->flags |= MMC_BLK_PACKED_CMD;
2298 }
2299
371a689f
AW		 2300 return md;
2301
2302 err_putdisk:
2303 put_disk(md->disk);
2304 err_kfree:
2305 kfree(md);
2306 out:
2307 return ERR_PTR(ret);
2308}
2309
2310static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
2311{
2312 sector_t size;
a6f6c96b 2313
85a18ad9
PO		 2314 if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
2315 /*
2316 * The EXT_CSD sector count is in number or 512 byte
2317 * sectors.
2318 */
371a689f 2319 size = card->ext_csd.sectors;
85a18ad9
PO		 2320 } else {
2321 /*
2322 * The CSD capacity field is in units of read_blkbits.
2323 * set_capacity takes units of 512 bytes.
2324 */
087de9ed
KM		 2325 size = (typeof(sector_t))card->csd.capacity
2326 << (card->csd.read_blkbits - 9);
85a18ad9 2327 }
371a689f 2328
7a30f2af 2329 return mmc_blk_alloc_req(card, &card->dev, size, false, NULL,
add710ea 2330 MMC_BLK_DATA_AREA_MAIN);
371a689f 2331}
a6f6c96b 2332
371a689f
AW		 2333static int mmc_blk_alloc_part(struct mmc_card *card,
2334 struct mmc_blk_data *md,
2335 unsigned int part_type,
2336 sector_t size,
2337 bool default_ro,
add710ea
JR		 2338 const char *subname,
2339 int area_type)
371a689f
AW		 2340{
2341 char cap_str[10];
2342 struct mmc_blk_data *part_md;
2343
2344 part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro,
add710ea 2345 subname, area_type);
371a689f
AW		 2346 if (IS_ERR(part_md))
2347 return PTR_ERR(part_md);
2348 part_md->part_type = part_type;
2349 list_add(&part_md->part, &md->part);
2350
b9f28d86 2351 string_get_size((u64)get_capacity(part_md->disk), 512, STRING_UNITS_2,
371a689f 2352 cap_str, sizeof(cap_str));
a3c76eb9 2353 pr_info("%s: %s %s partition %u %s\n",
371a689f
AW		 2354 part_md->disk->disk_name, mmc_card_id(card),
2355 mmc_card_name(card), part_md->part_type, cap_str);
2356 return 0;
2357}
2358
e0c368d5
NJ		 2359/* MMC Physical partitions consist of two boot partitions and
2360 * up to four general purpose partitions.
2361 * For each partition enabled in EXT_CSD a block device will be allocatedi
2362 * to provide access to the partition.
2363 */
2364
371a689f
AW		 2365static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
2366{
e0c368d5 2367 int idx, ret = 0;
371a689f
AW		 2368
2369 if (!mmc_card_mmc(card))
2370 return 0;
2371
e0c368d5
NJ		 2372 for (idx = 0; idx < card->nr_parts; idx++) {
2373 if (card->part[idx].size) {
2374 ret = mmc_blk_alloc_part(card, md,
2375 card->part[idx].part_cfg,
2376 card->part[idx].size >> 9,
2377 card->part[idx].force_ro,
add710ea
JR		 2378 card->part[idx].name,
2379 card->part[idx].area_type);
e0c368d5
NJ		 2380 if (ret)
2381 return ret;
2382 }
371a689f
AW		 2383 }
2384
2385 return ret;
1da177e4
LT		 2386}
2387
371a689f
AW		 2388static void mmc_blk_remove_req(struct mmc_blk_data *md)
2389{
add710ea
JR		 2390 struct mmc_card *card;
2391
371a689f 2392 if (md) {
fdfa20c1
PT		 2393 /*
2394 * Flush remaining requests and free queues. It
2395 * is freeing the queue that stops new requests
2396 * from being accepted.
2397 */
8efb83a2 2398 card = md->queue.card;
fdfa20c1
PT		 2399 mmc_cleanup_queue(&md->queue);
2400 if (md->flags & MMC_BLK_PACKED_CMD)
2401 mmc_packed_clean(&md->queue);
371a689f
AW		 2402 if (md->disk->flags & GENHD_FL_UP) {
2403 device_remove_file(disk_to_dev(md->disk), &md->force_ro);
add710ea
JR		 2404 if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
2405 card->ext_csd.boot_ro_lockable)
2406 device_remove_file(disk_to_dev(md->disk),
2407 &md->power_ro_lock);
371a689f 2408
371a689f
AW		 2409 del_gendisk(md->disk);
2410 }
371a689f
AW		 2411 mmc_blk_put(md);
2412 }
2413}
2414
2415static void mmc_blk_remove_parts(struct mmc_card *card,
2416 struct mmc_blk_data *md)
2417{
2418 struct list_head *pos, *q;
2419 struct mmc_blk_data *part_md;
2420
f06c9153 2421 __clear_bit(md->name_idx, name_use);
371a689f
AW		 2422 list_for_each_safe(pos, q, &md->part) {
2423 part_md = list_entry(pos, struct mmc_blk_data, part);
2424 list_del(pos);
2425 mmc_blk_remove_req(part_md);
2426 }
2427}
2428
2429static int mmc_add_disk(struct mmc_blk_data *md)
2430{
2431 int ret;
add710ea 2432 struct mmc_card *card = md->queue.card;
371a689f
AW		 2433
2434 add_disk(md->disk);
2435 md->force_ro.show = force_ro_show;
2436 md->force_ro.store = force_ro_store;
641c3187 2437 sysfs_attr_init(&md->force_ro.attr);
371a689f
AW		 2438 md->force_ro.attr.name = "force_ro";
2439 md->force_ro.attr.mode = S_IRUGO | S_IWUSR;
2440 ret = device_create_file(disk_to_dev(md->disk), &md->force_ro);
2441 if (ret)
add710ea
JR		 2442 goto force_ro_fail;
2443
2444 if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
2445 card->ext_csd.boot_ro_lockable) {
88187398 2446 umode_t mode;
add710ea
JR		 2447
2448 if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_DIS)
2449 mode = S_IRUGO;
2450 else
2451 mode = S_IRUGO | S_IWUSR;
2452
2453 md->power_ro_lock.show = power_ro_lock_show;
2454 md->power_ro_lock.store = power_ro_lock_store;
00d9ac08 2455 sysfs_attr_init(&md->power_ro_lock.attr);
add710ea
JR		 2456 md->power_ro_lock.attr.mode = mode;
2457 md->power_ro_lock.attr.name =
2458 "ro_lock_until_next_power_on";
2459 ret = device_create_file(disk_to_dev(md->disk),
2460 &md->power_ro_lock);
2461 if (ret)
2462 goto power_ro_lock_fail;
2463 }
2464 return ret;
2465
2466power_ro_lock_fail:
2467 device_remove_file(disk_to_dev(md->disk), &md->force_ro);
2468force_ro_fail:
2469 del_gendisk(md->disk);
371a689f
AW		 2470
2471 return ret;
2472}
2473
c59d4473
CB		 2474#define CID_MANFID_SANDISK 0x2
2475#define CID_MANFID_TOSHIBA 0x11
2476#define CID_MANFID_MICRON 0x13
3550ccdb 2477#define CID_MANFID_SAMSUNG 0x15
b5b4ff0a 2478#define CID_MANFID_KINGSTON 0x70
c59d4473 2479
6f60c222
AW		 2480static const struct mmc_fixup blk_fixups[] =
2481{
c59d4473
CB		 2482 MMC_FIXUP("SEM02G", CID_MANFID_SANDISK, 0x100, add_quirk,
2483 MMC_QUIRK_INAND_CMD38),
2484 MMC_FIXUP("SEM04G", CID_MANFID_SANDISK, 0x100, add_quirk,
2485 MMC_QUIRK_INAND_CMD38),
2486 MMC_FIXUP("SEM08G", CID_MANFID_SANDISK, 0x100, add_quirk,
2487 MMC_QUIRK_INAND_CMD38),
2488 MMC_FIXUP("SEM16G", CID_MANFID_SANDISK, 0x100, add_quirk,
2489 MMC_QUIRK_INAND_CMD38),
2490 MMC_FIXUP("SEM32G", CID_MANFID_SANDISK, 0x100, add_quirk,
2491 MMC_QUIRK_INAND_CMD38),
d0c97cfb
AW		 2492
2493 /*
2494 * Some MMC cards experience performance degradation with CMD23
2495 * instead of CMD12-bounded multiblock transfers. For now we'll
2496 * black list what's bad...
2497 * - Certain Toshiba cards.
2498 *
2499 * N.B. This doesn't affect SD cards.
2500 */
7d70d476
YL		 2501 MMC_FIXUP("SDMB-32", CID_MANFID_SANDISK, CID_OEMID_ANY, add_quirk_mmc,
2502 MMC_QUIRK_BLK_NO_CMD23),
2503 MMC_FIXUP("SDM032", CID_MANFID_SANDISK, CID_OEMID_ANY, add_quirk_mmc,
2504 MMC_QUIRK_BLK_NO_CMD23),
c59d4473 2505 MMC_FIXUP("MMC08G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
d0c97cfb 2506 MMC_QUIRK_BLK_NO_CMD23),
c59d4473 2507 MMC_FIXUP("MMC16G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
d0c97cfb 2508 MMC_QUIRK_BLK_NO_CMD23),
c59d4473 2509 MMC_FIXUP("MMC32G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
d0c97cfb 2510 MMC_QUIRK_BLK_NO_CMD23),
6de5fc9c
SNX		 2511
2512 /*
2513 * Some Micron MMC cards needs longer data read timeout than
2514 * indicated in CSD.
2515 */
c59d4473 2516 MMC_FIXUP(CID_NAME_ANY, CID_MANFID_MICRON, 0x200, add_quirk_mmc,
6de5fc9c
SNX		 2517 MMC_QUIRK_LONG_READ_TIME),
2518
3550ccdb
IC		 2519 /*
2520 * On these Samsung MoviNAND parts, performing secure erase or
2521 * secure trim can result in unrecoverable corruption due to a
2522 * firmware bug.
2523 */
2524 MMC_FIXUP("M8G2FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2525 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2526 MMC_FIXUP("MAG4FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2527 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2528 MMC_FIXUP("MBG8FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2529 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2530 MMC_FIXUP("MCGAFA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2531 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2532 MMC_FIXUP("VAL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2533 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2534 MMC_FIXUP("VYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2535 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2536 MMC_FIXUP("KYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2537 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2538 MMC_FIXUP("VZL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
2539 MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
2540
b5b4ff0a
SL		 2541 /*
2542 * On Some Kingston eMMCs, performing trim can result in
2543 * unrecoverable data conrruption occasionally due to a firmware bug.
2544 */
2545 MMC_FIXUP("V10008", CID_MANFID_KINGSTON, CID_OEMID_ANY, add_quirk_mmc,
2546 MMC_QUIRK_TRIM_BROKEN),
2547 MMC_FIXUP("V10016", CID_MANFID_KINGSTON, CID_OEMID_ANY, add_quirk_mmc,
2548 MMC_QUIRK_TRIM_BROKEN),
2549
6f60c222
AW		 2550 END_FIXUP
2551};
2552
96541bac 2553static int mmc_blk_probe(struct mmc_card *card)
1da177e4 2554{
371a689f 2555 struct mmc_blk_data *md, *part_md;
a7bbb573
PO		 2556 char cap_str[10];
2557
912490db
PO		 2558 /*
2559 * Check that the card supports the command class(es) we need.
2560 */
2561 if (!(card->csd.cmdclass & CCC_BLOCK_READ))
1da177e4
LT		 2562 return -ENODEV;
2563
5204d00f
LC		 2564 mmc_fixup_device(card, blk_fixups);
2565
1da177e4
LT		 2566 md = mmc_blk_alloc(card);
2567 if (IS_ERR(md))
2568 return PTR_ERR(md);
2569
b9f28d86 2570 string_get_size((u64)get_capacity(md->disk), 512, STRING_UNITS_2,
a7bbb573 2571 cap_str, sizeof(cap_str));
a3c76eb9 2572 pr_info("%s: %s %s %s %s\n",
1da177e4 2573 md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
a7bbb573 2574 cap_str, md->read_only ? "(ro)" : "");
1da177e4 2575
371a689f
AW		 2576 if (mmc_blk_alloc_parts(card, md))
2577 goto out;
2578
96541bac 2579 dev_set_drvdata(&card->dev, md);
6f60c222 2580
371a689f
AW		 2581 if (mmc_add_disk(md))
2582 goto out;
2583
2584 list_for_each_entry(part_md, &md->part, part) {
2585 if (mmc_add_disk(part_md))
2586 goto out;
2587 }
e94cfef6
UH		 2588
2589 pm_runtime_set_autosuspend_delay(&card->dev, 3000);
2590 pm_runtime_use_autosuspend(&card->dev);
2591
2592 /*
2593 * Don't enable runtime PM for SD-combo cards here. Leave that
2594 * decision to be taken during the SDIO init sequence instead.
2595 */
2596 if (card->type != MMC_TYPE_SD_COMBO) {
2597 pm_runtime_set_active(&card->dev);
2598 pm_runtime_enable(&card->dev);
2599 }
2600
1da177e4
LT		 2601 return 0;
2602
2603 out:
371a689f
AW		 2604 mmc_blk_remove_parts(card, md);
2605 mmc_blk_remove_req(md);
5865f287 2606 return 0;
1da177e4
LT		 2607}
2608
96541bac 2609static void mmc_blk_remove(struct mmc_card *card)
1da177e4 2610{
96541bac 2611 struct mmc_blk_data *md = dev_get_drvdata(&card->dev);
1da177e4 2612
371a689f 2613 mmc_blk_remove_parts(card, md);
e94cfef6 2614 pm_runtime_get_sync(&card->dev);
ddd6fa7e
AH		 2615 mmc_claim_host(card->host);
2616 mmc_blk_part_switch(card, md);
2617 mmc_release_host(card->host);
e94cfef6
UH		 2618 if (card->type != MMC_TYPE_SD_COMBO)
2619 pm_runtime_disable(&card->dev);
2620 pm_runtime_put_noidle(&card->dev);
371a689f 2621 mmc_blk_remove_req(md);
96541bac 2622 dev_set_drvdata(&card->dev, NULL);
1da177e4
LT		 2623}
2624
96541bac 2625static int _mmc_blk_suspend(struct mmc_card *card)
1da177e4 2626{
371a689f 2627 struct mmc_blk_data *part_md;
96541bac 2628 struct mmc_blk_data *md = dev_get_drvdata(&card->dev);
1da177e4
LT		 2629
2630 if (md) {
2631 mmc_queue_suspend(&md->queue);
371a689f
AW		 2632 list_for_each_entry(part_md, &md->part, part) {
2633 mmc_queue_suspend(&part_md->queue);
2634 }
1da177e4
LT		 2635 }
2636 return 0;
2637}
2638
96541bac 2639static void mmc_blk_shutdown(struct mmc_card *card)
76287748 2640{
96541bac 2641 _mmc_blk_suspend(card);
76287748
UH		 2642}
2643
0967edc6
UH		 2644#ifdef CONFIG_PM_SLEEP
2645static int mmc_blk_suspend(struct device *dev)
76287748 2646{
96541bac
UH		 2647 struct mmc_card *card = mmc_dev_to_card(dev);
2648
2649 return _mmc_blk_suspend(card);
76287748
UH		 2650}
2651
0967edc6 2652static int mmc_blk_resume(struct device *dev)
1da177e4 2653{
371a689f 2654 struct mmc_blk_data *part_md;
fc95e30b 2655 struct mmc_blk_data *md = dev_get_drvdata(dev);
1da177e4
LT		 2656
2657 if (md) {
371a689f
AW		 2658 /*
2659 * Resume involves the card going into idle state,
2660 * so current partition is always the main one.
2661 */
2662 md->part_curr = md->part_type;
1da177e4 2663 mmc_queue_resume(&md->queue);
371a689f
AW		 2664 list_for_each_entry(part_md, &md->part, part) {
2665 mmc_queue_resume(&part_md->queue);
2666 }
1da177e4
LT		 2667 }
2668 return 0;
2669}
1da177e4
LT		 2670#endif
2671
0967edc6
UH		 2672static SIMPLE_DEV_PM_OPS(mmc_blk_pm_ops, mmc_blk_suspend, mmc_blk_resume);
2673
96541bac
UH		 2674static struct mmc_driver mmc_driver = {
2675 .drv = {
2676 .name = "mmcblk",
2677 .pm = &mmc_blk_pm_ops,
2678 },
1da177e4
LT		 2679 .probe = mmc_blk_probe,
2680 .remove = mmc_blk_remove,
76287748 2681 .shutdown = mmc_blk_shutdown,
1da177e4
LT		 2682};
2683
2684static int __init mmc_blk_init(void)
2685{
9d4e98e9 2686 int res;
1da177e4 2687
5e71b7a6
OJ		 2688 if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
2689 pr_info("mmcblk: using %d minors per device\n", perdev_minors);
2690
a26eba61 2691 max_devices = min(MAX_DEVICES, (1 << MINORBITS) / perdev_minors);
5e71b7a6 2692
fe6b4c88
PO		 2693 res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
2694 if (res)
1da177e4 2695 goto out;
1da177e4 2696
9d4e98e9
AM		 2697 res = mmc_register_driver(&mmc_driver);
2698 if (res)
2699 goto out2;
1da177e4 2700
9d4e98e9
AM		 2701 return 0;
2702 out2:
2703 unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
1da177e4
LT		 2704 out:
2705 return res;
2706}
2707
2708static void __exit mmc_blk_exit(void)
2709{
2710 mmc_unregister_driver(&mmc_driver);
fe6b4c88 2711 unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
1da177e4
LT		 2712}
2713
2714module_init(mmc_blk_init);
2715module_exit(mmc_blk_exit);
2716
2717MODULE_LICENSE("GPL");
2718MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
2719
Linux 6.x block layer and io_uring tree(s)