summaryrefslogtreecommitdiff
path: root/drivers/mmc/card
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/mmc/card')
-rw-r--r--drivers/mmc/card/Kconfig70
-rw-r--r--drivers/mmc/card/Makefile10
-rw-r--r--drivers/mmc/card/block.c2336
-rw-r--r--drivers/mmc/card/block.h1
-rw-r--r--drivers/mmc/card/mmc_test.c3314
-rw-r--r--drivers/mmc/card/queue.c491
-rw-r--r--drivers/mmc/card/queue.h64
-rw-r--r--drivers/mmc/card/sdio_uart.c1200
8 files changed, 0 insertions, 7486 deletions
diff --git a/drivers/mmc/card/Kconfig b/drivers/mmc/card/Kconfig
deleted file mode 100644
index 5562308699bc..000000000000
--- a/drivers/mmc/card/Kconfig
+++ /dev/null
@@ -1,70 +0,0 @@
-#
-# MMC/SD card drivers
-#
-
-comment "MMC/SD/SDIO Card Drivers"
-
-config MMC_BLOCK
- tristate "MMC block device driver"
- depends on BLOCK
- default y
- help
- Say Y here to enable the MMC block device driver support.
- This provides a block device driver, which you can use to
- mount the filesystem. Almost everyone wishing MMC support
- should say Y or M here.
-
-config MMC_BLOCK_MINORS
- int "Number of minors per block device"
- depends on MMC_BLOCK
- range 4 256
- default 8
- help
- Number of minors per block device. One is needed for every
- partition on the disk (plus one for the whole disk).
-
- Number of total MMC minors available is 256, so your number
- of supported block devices will be limited to 256 divided
- by this number.
-
- Default is 8 to be backwards compatible with previous
- hardwired device numbering.
-
- If unsure, say 8 here.
-
-config MMC_BLOCK_BOUNCE
- bool "Use bounce buffer for simple hosts"
- depends on MMC_BLOCK
- default y
- help
- SD/MMC is a high latency protocol where it is crucial to
- send large requests in order to get high performance. Many
- controllers, however, are restricted to continuous memory
- (i.e. they can't do scatter-gather), something the kernel
- rarely can provide.
-
- Say Y here to help these restricted hosts by bouncing
- requests back and forth from a large buffer. You will get
- a big performance gain at the cost of up to 64 KiB of
- physical memory.
-
- If unsure, say Y here.
-
-config SDIO_UART
- tristate "SDIO UART/GPS class support"
- depends on TTY
- help
- SDIO function driver for SDIO cards that implements the UART
- class, as well as the GPS class which appears like a UART.
-
-config MMC_TEST
- tristate "MMC host test driver"
- help
- Development driver that performs a series of reads and writes
- to a memory card in order to expose certain well known bugs
- in host controllers. The tests are executed by writing to the
- "test" file in debugfs under each card. Note that whatever is
- on your card will be overwritten by these tests.
-
- This driver is only of interest to those developing or
- testing a host driver. Most people should say N here.
diff --git a/drivers/mmc/card/Makefile b/drivers/mmc/card/Makefile
deleted file mode 100644
index c73b406a06cd..000000000000
--- a/drivers/mmc/card/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-#
-# Makefile for MMC/SD card drivers
-#
-
-obj-$(CONFIG_MMC_BLOCK) += mmc_block.o
-mmc_block-objs := block.o queue.o
-obj-$(CONFIG_MMC_TEST) += mmc_test.o
-
-obj-$(CONFIG_SDIO_UART) += sdio_uart.o
-
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
deleted file mode 100644
index 646d1a1fa6ca..000000000000
--- a/drivers/mmc/card/block.c
+++ /dev/null
@@ -1,2336 +0,0 @@
-/*
- * Block driver for media (i.e., flash cards)
- *
- * Copyright 2002 Hewlett-Packard Company
- * Copyright 2005-2008 Pierre Ossman
- *
- * Use consistent with the GNU GPL is permitted,
- * provided that this copyright notice is
- * preserved in its entirety in all copies and derived works.
- *
- * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED,
- * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS
- * FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- * Many thanks to Alessandro Rubini and Jonathan Corbet!
- *
- * Author: Andrew Christian
- * 28 May 2002
- */
-#include <linux/moduleparam.h>
-#include <linux/module.h>
-#include <linux/init.h>
-
-#include <linux/kernel.h>
-#include <linux/fs.h>
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/hdreg.h>
-#include <linux/kdev_t.h>
-#include <linux/blkdev.h>
-#include <linux/mutex.h>
-#include <linux/scatterlist.h>
-#include <linux/string_helpers.h>
-#include <linux/delay.h>
-#include <linux/capability.h>
-#include <linux/compat.h>
-#include <linux/pm_runtime.h>
-#include <linux/idr.h>
-
-#include <linux/mmc/ioctl.h>
-#include <linux/mmc/card.h>
-#include <linux/mmc/host.h>
-#include <linux/mmc/mmc.h>
-#include <linux/mmc/sd.h>
-
-#include <asm/uaccess.h>
-
-#include "queue.h"
-#include "block.h"
-
-MODULE_ALIAS("mmc:block");
-#ifdef MODULE_PARAM_PREFIX
-#undef MODULE_PARAM_PREFIX
-#endif
-#define MODULE_PARAM_PREFIX "mmcblk."
-
-#define INAND_CMD38_ARG_EXT_CSD 113
-#define INAND_CMD38_ARG_ERASE 0x00
-#define INAND_CMD38_ARG_TRIM 0x01
-#define INAND_CMD38_ARG_SECERASE 0x80
-#define INAND_CMD38_ARG_SECTRIM1 0x81
-#define INAND_CMD38_ARG_SECTRIM2 0x88
-#define MMC_BLK_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */
-#define MMC_SANITIZE_REQ_TIMEOUT 240000
-#define MMC_EXTRACT_INDEX_FROM_ARG(x) ((x & 0x00FF0000) >> 16)
-
-#define mmc_req_rel_wr(req) ((req->cmd_flags & REQ_FUA) && \
- (rq_data_dir(req) == WRITE))
-static DEFINE_MUTEX(block_mutex);
-
-/*
- * The defaults come from config options but can be overriden by module
- * or bootarg options.
- */
-static int perdev_minors = CONFIG_MMC_BLOCK_MINORS;
-
-/*
- * We've only got one major, so number of mmcblk devices is
- * limited to (1 << 20) / number of minors per device. It is also
- * limited by the MAX_DEVICES below.
- */
-static int max_devices;
-
-#define MAX_DEVICES 256
-
-static DEFINE_IDA(mmc_blk_ida);
-static DEFINE_SPINLOCK(mmc_blk_lock);
-
-/*
- * There is one mmc_blk_data per slot.
- */
-struct mmc_blk_data {
- spinlock_t lock;
- struct device *parent;
- struct gendisk *disk;
- struct mmc_queue queue;
- struct list_head part;
-
- unsigned int flags;
-#define MMC_BLK_CMD23 (1 << 0) /* Can do SET_BLOCK_COUNT for multiblock */
-#define MMC_BLK_REL_WR (1 << 1) /* MMC Reliable write support */
-
- unsigned int usage;
- unsigned int read_only;
- unsigned int part_type;
- unsigned int reset_done;
-#define MMC_BLK_READ BIT(0)
-#define MMC_BLK_WRITE BIT(1)
-#define MMC_BLK_DISCARD BIT(2)
-#define MMC_BLK_SECDISCARD BIT(3)
-
- /*
- * Only set in main mmc_blk_data associated
- * with mmc_card with dev_set_drvdata, and keeps
- * track of the current selected device partition.
- */
- unsigned int part_curr;
- struct device_attribute force_ro;
- struct device_attribute power_ro_lock;
- int area_type;
-};
-
-static DEFINE_MUTEX(open_lock);
-
-module_param(perdev_minors, int, 0444);
-MODULE_PARM_DESC(perdev_minors, "Minors numbers to allocate per device");
-
-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 struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
-{
- struct mmc_blk_data *md;
-
- mutex_lock(&open_lock);
- md = disk->private_data;
- if (md && md->usage == 0)
- md = NULL;
- if (md)
- md->usage++;
- mutex_unlock(&open_lock);
-
- return md;
-}
-
-static inline int mmc_get_devidx(struct gendisk *disk)
-{
- int devidx = disk->first_minor / perdev_minors;
- return devidx;
-}
-
-static void mmc_blk_put(struct mmc_blk_data *md)
-{
- mutex_lock(&open_lock);
- md->usage--;
- if (md->usage == 0) {
- int devidx = mmc_get_devidx(md->disk);
- blk_cleanup_queue(md->queue.queue);
-
- spin_lock(&mmc_blk_lock);
- ida_remove(&mmc_blk_ida, devidx);
- spin_unlock(&mmc_blk_lock);
-
- put_disk(md->disk);
- kfree(md);
- }
- mutex_unlock(&open_lock);
-}
-
-static ssize_t power_ro_lock_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- int ret;
- struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
- struct mmc_card *card = md->queue.card;
- int locked = 0;
-
- if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PERM_WP_EN)
- locked = 2;
- else if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_EN)
- locked = 1;
-
- ret = snprintf(buf, PAGE_SIZE, "%d\n", locked);
-
- mmc_blk_put(md);
-
- return ret;
-}
-
-static ssize_t power_ro_lock_store(struct device *dev,
- struct device_attribute *attr, const char *buf, size_t count)
-{
- int ret;
- struct mmc_blk_data *md, *part_md;
- struct mmc_card *card;
- unsigned long set;
-
- if (kstrtoul(buf, 0, &set))
- return -EINVAL;
-
- if (set != 1)
- return count;
-
- md = mmc_blk_get(dev_to_disk(dev));
- card = md->queue.card;
-
- mmc_get_card(card);
-
- ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_WP,
- card->ext_csd.boot_ro_lock |
- EXT_CSD_BOOT_WP_B_PWR_WP_EN,
- card->ext_csd.part_time);
- if (ret)
- pr_err("%s: Locking boot partition ro until next power on failed: %d\n", md->disk->disk_name, ret);
- else
- card->ext_csd.boot_ro_lock |= EXT_CSD_BOOT_WP_B_PWR_WP_EN;
-
- mmc_put_card(card);
-
- if (!ret) {
- pr_info("%s: Locking boot partition ro until next power on\n",
- md->disk->disk_name);
- set_disk_ro(md->disk, 1);
-
- list_for_each_entry(part_md, &md->part, part)
- if (part_md->area_type == MMC_BLK_DATA_AREA_BOOT) {
- pr_info("%s: Locking boot partition ro until next power on\n", part_md->disk->disk_name);
- set_disk_ro(part_md->disk, 1);
- }
- }
-
- mmc_blk_put(md);
- return count;
-}
-
-static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- int ret;
- struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
-
- ret = snprintf(buf, PAGE_SIZE, "%d\n",
- get_disk_ro(dev_to_disk(dev)) ^
- md->read_only);
- mmc_blk_put(md);
- return ret;
-}
-
-static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- int ret;
- char *end;
- struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
- unsigned long set = simple_strtoul(buf, &end, 0);
- if (end == buf) {
- ret = -EINVAL;
- goto out;
- }
-
- set_disk_ro(dev_to_disk(dev), set || md->read_only);
- ret = count;
-out:
- mmc_blk_put(md);
- return ret;
-}
-
-static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
-{
- struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
- int ret = -ENXIO;
-
- mutex_lock(&block_mutex);
- if (md) {
- if (md->usage == 2)
- check_disk_change(bdev);
- ret = 0;
-
- if ((mode & FMODE_WRITE) && md->read_only) {
- mmc_blk_put(md);
- ret = -EROFS;
- }
- }
- mutex_unlock(&block_mutex);
-
- return ret;
-}
-
-static void mmc_blk_release(struct gendisk *disk, fmode_t mode)
-{
- struct mmc_blk_data *md = disk->private_data;
-
- mutex_lock(&block_mutex);
- mmc_blk_put(md);
- mutex_unlock(&block_mutex);
-}
-
-static int
-mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
-{
- geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
- geo->heads = 4;
- geo->sectors = 16;
- return 0;
-}
-
-struct mmc_blk_ioc_data {
- struct mmc_ioc_cmd ic;
- unsigned char *buf;
- u64 buf_bytes;
-};
-
-static struct mmc_blk_ioc_data *mmc_blk_ioctl_copy_from_user(
- struct mmc_ioc_cmd __user *user)
-{
- struct mmc_blk_ioc_data *idata;
- int err;
-
- idata = kmalloc(sizeof(*idata), GFP_KERNEL);
- if (!idata) {
- err = -ENOMEM;
- goto out;
- }
-
- if (copy_from_user(&idata->ic, user, sizeof(idata->ic))) {
- err = -EFAULT;
- goto idata_err;
- }
-
- idata->buf_bytes = (u64) idata->ic.blksz * idata->ic.blocks;
- if (idata->buf_bytes > MMC_IOC_MAX_BYTES) {
- err = -EOVERFLOW;
- goto idata_err;
- }
-
- if (!idata->buf_bytes) {
- idata->buf = NULL;
- return idata;
- }
-
- idata->buf = kmalloc(idata->buf_bytes, GFP_KERNEL);
- if (!idata->buf) {
- err = -ENOMEM;
- goto idata_err;
- }
-
- if (copy_from_user(idata->buf, (void __user *)(unsigned long)
- idata->ic.data_ptr, idata->buf_bytes)) {
- err = -EFAULT;
- goto copy_err;
- }
-
- return idata;
-
-copy_err:
- kfree(idata->buf);
-idata_err:
- kfree(idata);
-out:
- return ERR_PTR(err);
-}
-
-static int mmc_blk_ioctl_copy_to_user(struct mmc_ioc_cmd __user *ic_ptr,
- struct mmc_blk_ioc_data *idata)
-{
- struct mmc_ioc_cmd *ic = &idata->ic;
-
- if (copy_to_user(&(ic_ptr->response), ic->response,
- sizeof(ic->response)))
- return -EFAULT;
-
- if (!idata->ic.write_flag) {
- if (copy_to_user((void __user *)(unsigned long)ic->data_ptr,
- idata->buf, idata->buf_bytes))
- return -EFAULT;
- }
-
- return 0;
-}
-
-static int ioctl_rpmb_card_status_poll(struct mmc_card *card, u32 *status,
- u32 retries_max)
-{
- int err;
- u32 retry_count = 0;
-
- if (!status || !retries_max)
- return -EINVAL;
-
- do {
- err = get_card_status(card, status, 5);
- if (err)
- break;
-
- if (!R1_STATUS(*status) &&
- (R1_CURRENT_STATE(*status) != R1_STATE_PRG))
- break; /* RPMB programming operation complete */
-
- /*
- * Rechedule to give the MMC device a chance to continue
- * processing the previous command without being polled too
- * frequently.
- */
- usleep_range(1000, 5000);
- } while (++retry_count < retries_max);
-
- if (retry_count == retries_max)
- err = -EPERM;
-
- return err;
-}
-
-static int ioctl_do_sanitize(struct mmc_card *card)
-{
- int err;
-
- if (!mmc_can_sanitize(card)) {
- pr_warn("%s: %s - SANITIZE is not supported\n",
- mmc_hostname(card->host), __func__);
- err = -EOPNOTSUPP;
- goto out;
- }
-
- pr_debug("%s: %s - SANITIZE IN PROGRESS...\n",
- mmc_hostname(card->host), __func__);
-
- err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
- EXT_CSD_SANITIZE_START, 1,
- MMC_SANITIZE_REQ_TIMEOUT);
-
- if (err)
- pr_err("%s: %s - EXT_CSD_SANITIZE_START failed. err=%d\n",
- mmc_hostname(card->host), __func__, err);
-
- pr_debug("%s: %s - SANITIZE COMPLETED\n", mmc_hostname(card->host),
- __func__);
-out:
- return err;
-}
-
-static int __mmc_blk_ioctl_cmd(struct mmc_card *card, struct mmc_blk_data *md,
- struct mmc_blk_ioc_data *idata)
-{
- struct mmc_command cmd = {0};
- struct mmc_data data = {0};
- struct mmc_request mrq = {NULL};
- struct scatterlist sg;
- int err;
- int is_rpmb = false;
- u32 status = 0;
-
- if (!card || !md || !idata)
- return -EINVAL;
-
- if (md->area_type & MMC_BLK_DATA_AREA_RPMB)
- is_rpmb = true;
-
- cmd.opcode = idata->ic.opcode;
- cmd.arg = idata->ic.arg;
- cmd.flags = idata->ic.flags;
-
- if (idata->buf_bytes) {
- data.sg = &sg;
- data.sg_len = 1;
- data.blksz = idata->ic.blksz;
- data.blocks = idata->ic.blocks;
-
- sg_init_one(data.sg, idata->buf, idata->buf_bytes);
-
- if (idata->ic.write_flag)
- data.flags = MMC_DATA_WRITE;
- else
- data.flags = MMC_DATA_READ;
-
- /* data.flags must already be set before doing this. */
- mmc_set_data_timeout(&data, card);
-
- /* Allow overriding the timeout_ns for empirical tuning. */
- if (idata->ic.data_timeout_ns)
- data.timeout_ns = idata->ic.data_timeout_ns;
-
- if ((cmd.flags & MMC_RSP_R1B) == MMC_RSP_R1B) {
- /*
- * Pretend this is a data transfer and rely on the
- * host driver to compute timeout. When all host
- * drivers support cmd.cmd_timeout for R1B, this
- * can be changed to:
- *
- * mrq.data = NULL;
- * cmd.cmd_timeout = idata->ic.cmd_timeout_ms;
- */
- data.timeout_ns = idata->ic.cmd_timeout_ms * 1000000;
- }
-
- mrq.data = &data;
- }
-
- mrq.cmd = &cmd;
-
- err = mmc_blk_part_switch(card, md);
- if (err)
- return err;
-
- if (idata->ic.is_acmd) {
- err = mmc_app_cmd(card->host, card);
- if (err)
- return err;
- }
-
- if (is_rpmb) {
- err = mmc_set_blockcount(card, data.blocks,
- idata->ic.write_flag & (1 << 31));
- if (err)
- return err;
- }
-
- if ((MMC_EXTRACT_INDEX_FROM_ARG(cmd.arg) == EXT_CSD_SANITIZE_START) &&
- (cmd.opcode == MMC_SWITCH)) {
- err = ioctl_do_sanitize(card);
-
- if (err)
- pr_err("%s: ioctl_do_sanitize() failed. err = %d",
- __func__, err);
-
- return err;
- }
-
- mmc_wait_for_req(card->host, &mrq);
-
- if (cmd.error) {
- dev_err(mmc_dev(card->host), "%s: cmd error %d\n",
- __func__, cmd.error);
- return cmd.error;
- }
- if (data.error) {
- dev_err(mmc_dev(card->host), "%s: data error %d\n",
- __func__, data.error);
- return data.error;
- }
-
- /*
- * According to the SD specs, some commands require a delay after
- * issuing the command.
- */
- if (idata->ic.postsleep_min_us)
- usleep_range(idata->ic.postsleep_min_us, idata->ic.postsleep_max_us);
-
- memcpy(&(idata->ic.response), cmd.resp, sizeof(cmd.resp));
-
- if (is_rpmb) {
- /*
- * Ensure RPMB command has completed by polling CMD13
- * "Send Status".
- */
- err = ioctl_rpmb_card_status_poll(card, &status, 5);
- if (err)
- dev_err(mmc_dev(card->host),
- "%s: Card Status=0x%08X, error %d\n",
- __func__, status, err);
- }
-
- return err;
-}
-
-static int mmc_blk_ioctl_cmd(struct block_device *bdev,
- struct mmc_ioc_cmd __user *ic_ptr)
-{
- struct mmc_blk_ioc_data *idata;
- struct mmc_blk_data *md;
- struct mmc_card *card;
- int err = 0, ioc_err = 0;
-
- /*
- * The caller must have CAP_SYS_RAWIO, and must be calling this on the
- * whole block device, not on a partition. This prevents overspray
- * between sibling partitions.
- */
- if ((!capable(CAP_SYS_RAWIO)) || (bdev != bdev->bd_contains))
- return -EPERM;
-
- idata = mmc_blk_ioctl_copy_from_user(ic_ptr);
- if (IS_ERR(idata))
- return PTR_ERR(idata);
-
- md = mmc_blk_get(bdev->bd_disk);
- if (!md) {
- err = -EINVAL;
- goto cmd_err;
- }
-
- card = md->queue.card;
- if (IS_ERR(card)) {
- err = PTR_ERR(card);
- goto cmd_done;
- }
-
- mmc_get_card(card);
-
- ioc_err = __mmc_blk_ioctl_cmd(card, md, idata);
-
- /* Always switch back to main area after RPMB access */
- if (md->area_type & MMC_BLK_DATA_AREA_RPMB)
- mmc_blk_part_switch(card, dev_get_drvdata(&card->dev));
-
- mmc_put_card(card);
-
- err = mmc_blk_ioctl_copy_to_user(ic_ptr, idata);
-
-cmd_done:
- mmc_blk_put(md);
-cmd_err:
- kfree(idata->buf);
- kfree(idata);
- return ioc_err ? ioc_err : err;
-}
-
-static int mmc_blk_ioctl_multi_cmd(struct block_device *bdev,
- struct mmc_ioc_multi_cmd __user *user)
-{
- struct mmc_blk_ioc_data **idata = NULL;
- struct mmc_ioc_cmd __user *cmds = user->cmds;
- struct mmc_card *card;
- struct mmc_blk_data *md;
- int i, err = 0, ioc_err = 0;
- __u64 num_of_cmds;
-
- /*
- * The caller must have CAP_SYS_RAWIO, and must be calling this on the
- * whole block device, not on a partition. This prevents overspray
- * between sibling partitions.
- */
- if ((!capable(CAP_SYS_RAWIO)) || (bdev != bdev->bd_contains))
- return -EPERM;
-
- if (copy_from_user(&num_of_cmds, &user->num_of_cmds,
- sizeof(num_of_cmds)))
- return -EFAULT;
-
- if (num_of_cmds > MMC_IOC_MAX_CMDS)
- return -EINVAL;
-
- idata = kcalloc(num_of_cmds, sizeof(*idata), GFP_KERNEL);
- if (!idata)
- return -ENOMEM;
-
- for (i = 0; i < num_of_cmds; i++) {
- idata[i] = mmc_blk_ioctl_copy_from_user(&cmds[i]);
- if (IS_ERR(idata[i])) {
- err = PTR_ERR(idata[i]);
- num_of_cmds = i;
- goto cmd_err;
- }
- }
-
- md = mmc_blk_get(bdev->bd_disk);
- if (!md) {
- err = -EINVAL;
- goto cmd_err;
- }
-
- card = md->queue.card;
- if (IS_ERR(card)) {
- err = PTR_ERR(card);
- goto cmd_done;
- }
-
- mmc_get_card(card);
-
- for (i = 0; i < num_of_cmds && !ioc_err; i++)
- ioc_err = __mmc_blk_ioctl_cmd(card, md, idata[i]);
-
- /* Always switch back to main area after RPMB access */
- if (md->area_type & MMC_BLK_DATA_AREA_RPMB)
- mmc_blk_part_switch(card, dev_get_drvdata(&card->dev));
-
- mmc_put_card(card);
-
- /* copy to user if data and response */
- for (i = 0; i < num_of_cmds && !err; i++)
- err = mmc_blk_ioctl_copy_to_user(&cmds[i], idata[i]);
-
-cmd_done:
- mmc_blk_put(md);
-cmd_err:
- for (i = 0; i < num_of_cmds; i++) {
- kfree(idata[i]->buf);
- kfree(idata[i]);
- }
- kfree(idata);
- return ioc_err ? ioc_err : err;
-}
-
-static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode,
- unsigned int cmd, unsigned long arg)
-{
- switch (cmd) {
- case MMC_IOC_CMD:
- return mmc_blk_ioctl_cmd(bdev,
- (struct mmc_ioc_cmd __user *)arg);
- case MMC_IOC_MULTI_CMD:
- return mmc_blk_ioctl_multi_cmd(bdev,
- (struct mmc_ioc_multi_cmd __user *)arg);
- default:
- return -EINVAL;
- }
-}
-
-#ifdef CONFIG_COMPAT
-static int mmc_blk_compat_ioctl(struct block_device *bdev, fmode_t mode,
- unsigned int cmd, unsigned long arg)
-{
- return mmc_blk_ioctl(bdev, mode, cmd, (unsigned long) compat_ptr(arg));
-}
-#endif
-
-static const struct block_device_operations mmc_bdops = {
- .open = mmc_blk_open,
- .release = mmc_blk_release,
- .getgeo = mmc_blk_getgeo,
- .owner = THIS_MODULE,
- .ioctl = mmc_blk_ioctl,
-#ifdef CONFIG_COMPAT
- .compat_ioctl = mmc_blk_compat_ioctl,
-#endif
-};
-
-static inline int mmc_blk_part_switch(struct mmc_card *card,
- struct mmc_blk_data *md)
-{
- int ret;
- struct mmc_blk_data *main_md = dev_get_drvdata(&card->dev);
-
- if (main_md->part_curr == md->part_type)
- return 0;
-
- 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);
-
- part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
- part_config |= md->part_type;
-
- ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
- 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);
- 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);
- }
-
- main_md->part_curr = md->part_type;
- return 0;
-}
-
-static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
-{
- int err;
- u32 result;
- __be32 *blocks;
-
- struct mmc_request mrq = {NULL};
- struct mmc_command cmd = {0};
- struct mmc_data data = {0};
-
- struct scatterlist sg;
-
- cmd.opcode = MMC_APP_CMD;
- cmd.arg = card->rca << 16;
- cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
-
- err = mmc_wait_for_cmd(card->host, &cmd, 0);
- if (err)
- return (u32)-1;
- if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD))
- return (u32)-1;
-
- memset(&cmd, 0, sizeof(struct mmc_command));
-
- cmd.opcode = SD_APP_SEND_NUM_WR_BLKS;
- cmd.arg = 0;
- cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
-
- data.blksz = 4;
- data.blocks = 1;
- data.flags = MMC_DATA_READ;
- data.sg = &sg;
- data.sg_len = 1;
- mmc_set_data_timeout(&data, card);
-
- mrq.cmd = &cmd;
- mrq.data = &data;
-
- blocks = kmalloc(4, GFP_KERNEL);
- if (!blocks)
- return (u32)-1;
-
- sg_init_one(&sg, blocks, 4);
-
- mmc_wait_for_req(card->host, &mrq);
-
- result = ntohl(*blocks);
- kfree(blocks);
-
- if (cmd.error || data.error)
- result = (u32)-1;
-
- return result;
-}
-
-static int get_card_status(struct mmc_card *card, u32 *status, int retries)
-{
- struct mmc_command cmd = {0};
- int err;
-
- cmd.opcode = MMC_SEND_STATUS;
- if (!mmc_host_is_spi(card->host))
- cmd.arg = card->rca << 16;
- cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
- err = mmc_wait_for_cmd(card->host, &cmd, retries);
- if (err == 0)
- *status = cmd.resp[0];
- return err;
-}
-
-static int card_busy_detect(struct mmc_card *card, unsigned int timeout_ms,
- bool hw_busy_detect, struct request *req, bool *gen_err)
-{
- unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
- int err = 0;
- u32 status;
-
- do {
- err = get_card_status(card, &status, 5);
- if (err) {
- pr_err("%s: error %d requesting status\n",
- req->rq_disk->disk_name, err);
- return err;
- }
-
- if (status & R1_ERROR) {
- pr_err("%s: %s: error sending status cmd, status %#x\n",
- req->rq_disk->disk_name, __func__, status);
- *gen_err = true;
- }
-
- /* We may rely on the host hw to handle busy detection.*/
- if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) &&
- hw_busy_detect)
- break;
-
- /*
- * Timeout if the device never becomes ready for data and never
- * leaves the program state.
- */
- if (time_after(jiffies, timeout)) {
- pr_err("%s: Card stuck in programming state! %s %s\n",
- mmc_hostname(card->host),
- req->rq_disk->disk_name, __func__);
- return -ETIMEDOUT;
- }
-
- /*
- * Some cards mishandle the status bits,
- * so make sure to check both the busy
- * indication and the card state.
- */
- } while (!(status & R1_READY_FOR_DATA) ||
- (R1_CURRENT_STATE(status) == R1_STATE_PRG));
-
- return err;
-}
-
-static int send_stop(struct mmc_card *card, unsigned int timeout_ms,
- struct request *req, bool *gen_err, u32 *stop_status)
-{
- struct mmc_host *host = card->host;
- struct mmc_command cmd = {0};
- int err;
- bool use_r1b_resp = rq_data_dir(req) == WRITE;
-
- /*
- * Normally we use R1B responses for WRITE, but in cases where the host
- * has specified a max_busy_timeout we need to validate it. A failure
- * means we need to prevent the host from doing hw busy detection, which
- * is done by converting to a R1 response instead.
- */
- if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout))
- use_r1b_resp = false;
-
- cmd.opcode = MMC_STOP_TRANSMISSION;
- if (use_r1b_resp) {
- cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
- cmd.busy_timeout = timeout_ms;
- } else {
- cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
- }
-
- err = mmc_wait_for_cmd(host, &cmd, 5);
- if (err)
- return err;
-
- *stop_status = cmd.resp[0];
-
- /* No need to check card status in case of READ. */
- if (rq_data_dir(req) == READ)
- return 0;
-
- if (!mmc_host_is_spi(host) &&
- (*stop_status & R1_ERROR)) {
- pr_err("%s: %s: general error sending stop command, resp %#x\n",
- req->rq_disk->disk_name, __func__, *stop_status);
- *gen_err = true;
- }
-
- return card_busy_detect(card, timeout_ms, use_r1b_resp, req, gen_err);
-}
-
-#define ERR_NOMEDIUM 3
-#define ERR_RETRY 2
-#define ERR_ABORT 1
-#define ERR_CONTINUE 0
-
-static int mmc_blk_cmd_error(struct request *req, const char *name, int error,
- bool status_valid, u32 status)
-{
- switch (error) {
- case -EILSEQ:
- /* response crc error, retry the r/w cmd */
- pr_err("%s: %s sending %s command, card status %#x\n",
- req->rq_disk->disk_name, "response CRC error",
- name, status);
- return ERR_RETRY;
-
- case -ETIMEDOUT:
- pr_err("%s: %s sending %s command, card status %#x\n",
- req->rq_disk->disk_name, "timed out", name, status);
-
- /* If the status cmd initially failed, retry the r/w cmd */
- if (!status_valid) {
- pr_err("%s: status not valid, retrying timeout\n",
- req->rq_disk->disk_name);
- return ERR_RETRY;
- }
-
- /*
- * If it was a r/w cmd crc error, or illegal command
- * (eg, issued in wrong state) then retry - we should
- * have corrected the state problem above.
- */
- if (status & (R1_COM_CRC_ERROR | R1_ILLEGAL_COMMAND)) {
- pr_err("%s: command error, retrying timeout\n",
- req->rq_disk->disk_name);
- return ERR_RETRY;
- }
-
- /* Otherwise abort the command */
- return ERR_ABORT;
-
- default:
- /* We don't understand the error code the driver gave us */
- pr_err("%s: unknown error %d sending read/write command, card status %#x\n",
- req->rq_disk->disk_name, error, status);
- return ERR_ABORT;
- }
-}
-
-/*
- * Initial r/w and stop cmd error recovery.
- * We don't know whether the card received the r/w cmd or not, so try to
- * restore things back to a sane state. Essentially, we do this as follows:
- * - Obtain card status. If the first attempt to obtain card status fails,
- * the status word will reflect the failed status cmd, not the failed
- * r/w cmd. If we fail to obtain card status, it suggests we can no
- * longer communicate with the card.
- * - Check the card state. If the card received the cmd but there was a
- * transient problem with the response, it might still be in a data transfer
- * mode. Try to send it a stop command. If this fails, we can't recover.
- * - If the r/w cmd failed due to a response CRC error, it was probably
- * transient, so retry the cmd.
- * - If the r/w cmd timed out, but we didn't get the r/w cmd status, retry.
- * - If the r/w cmd timed out, and the r/w cmd failed due to CRC error or
- * illegal cmd, retry.
- * Otherwise we don't understand what happened, so abort.
- */
-static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
- struct mmc_blk_request *brq, bool *ecc_err, bool *gen_err)
-{
- bool prev_cmd_status_valid = true;
- u32 status, stop_status = 0;
- int err, retry;
-
- if (mmc_card_removed(card))
- return ERR_NOMEDIUM;
-
- /*
- * Try to get card status which indicates both the card state
- * and why there was no response. If the first attempt fails,
- * we can't be sure the returned status is for the r/w command.
- */
- for (retry = 2; retry >= 0; retry--) {
- err = get_card_status(card, &status, 0);
- if (!err)
- break;
-
- /* Re-tune if needed */
- mmc_retune_recheck(card->host);
-
- prev_cmd_status_valid = false;
- pr_err("%s: error %d sending status command, %sing\n",
- req->rq_disk->disk_name, err, retry ? "retry" : "abort");
- }
-
- /* We couldn't get a response from the card. Give up. */
- if (err) {
- /* Check if the card is removed */
- if (mmc_detect_card_removed(card->host))
- return ERR_NOMEDIUM;
- return ERR_ABORT;
- }
-
- /* Flag ECC errors */
- if ((status & R1_CARD_ECC_FAILED) ||
- (brq->stop.resp[0] & R1_CARD_ECC_FAILED) ||
- (brq->cmd.resp[0] & R1_CARD_ECC_FAILED))
- *ecc_err = true;
-
- /* Flag General errors */
- if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ)
- if ((status & R1_ERROR) ||
- (brq->stop.resp[0] & R1_ERROR)) {
- pr_err("%s: %s: general error sending stop or status command, stop cmd response %#x, card status %#x\n",
- req->rq_disk->disk_name, __func__,
- brq->stop.resp[0], status);
- *gen_err = true;
- }
-
- /*
- * Check the current card state. If it is in some data transfer
- * mode, tell it to stop (and hopefully transition back to TRAN.)
- */
- if (R1_CURRENT_STATE(status) == R1_STATE_DATA ||
- R1_CURRENT_STATE(status) == R1_STATE_RCV) {
- err = send_stop(card,
- DIV_ROUND_UP(brq->data.timeout_ns, 1000000),
- req, gen_err, &stop_status);
- if (err) {
- pr_err("%s: error %d sending stop command\n",
- req->rq_disk->disk_name, err);
- /*
- * If the stop cmd also timed out, the card is probably
- * not present, so abort. Other errors are bad news too.
- */
- return ERR_ABORT;
- }
-
- if (stop_status & R1_CARD_ECC_FAILED)
- *ecc_err = true;
- }
-
- /* Check for set block count errors */
- if (brq->sbc.error)
- return mmc_blk_cmd_error(req, "SET_BLOCK_COUNT", brq->sbc.error,
- prev_cmd_status_valid, status);
-
- /* Check for r/w command errors */
- if (brq->cmd.error)
- return mmc_blk_cmd_error(req, "r/w cmd", brq->cmd.error,
- prev_cmd_status_valid, status);
-
- /* Data errors */
- if (!brq->stop.error)
- return ERR_CONTINUE;
-
- /* Now for stop errors. These aren't fatal to the transfer. */
- pr_info("%s: error %d sending stop command, original cmd response %#x, card status %#x\n",
- req->rq_disk->disk_name, brq->stop.error,
- brq->cmd.resp[0], status);
-
- /*
- * Subsitute in our own stop status as this will give the error
- * state which happened during the execution of the r/w command.
- */
- if (stop_status) {
- brq->stop.resp[0] = stop_status;
- brq->stop.error = 0;
- }
- return ERR_CONTINUE;
-}
-
-static int mmc_blk_reset(struct mmc_blk_data *md, struct mmc_host *host,
- int type)
-{
- int err;
-
- if (md->reset_done & type)
- return -EEXIST;
-
- md->reset_done |= type;
- err = mmc_hw_reset(host);
- /* Ensure we switch back to the correct partition */
- if (err != -EOPNOTSUPP) {
- struct mmc_blk_data *main_md =
- dev_get_drvdata(&host->card->dev);
- int part_err;
-
- main_md->part_curr = main_md->part_type;
- part_err = mmc_blk_part_switch(host->card, md);
- if (part_err) {
- /*
- * We have failed to get back into the correct
- * partition, so we need to abort the whole request.
- */
- return -ENODEV;
- }
- }
- return err;
-}
-
-static inline void mmc_blk_reset_success(struct mmc_blk_data *md, int type)
-{
- md->reset_done &= ~type;
-}
-
-int mmc_access_rpmb(struct mmc_queue *mq)
-{
- struct mmc_blk_data *md = mq->blkdata;
- /*
- * If this is a RPMB partition access, return ture
- */
- if (md && md->part_type == EXT_CSD_PART_CONFIG_ACC_RPMB)
- return true;
-
- return false;
-}
-
-static int mmc_blk_issue_discard_rq(struct mmc_queue *mq, struct request *req)
-{
- struct mmc_blk_data *md = mq->blkdata;
- struct mmc_card *card = md->queue.card;
- unsigned int from, nr, arg;
- int err = 0, type = MMC_BLK_DISCARD;
-
- if (!mmc_can_erase(card)) {
- err = -EOPNOTSUPP;
- goto out;
- }
-
- from = blk_rq_pos(req);
- nr = blk_rq_sectors(req);
-
- if (mmc_can_discard(card))
- arg = MMC_DISCARD_ARG;
- else if (mmc_can_trim(card))
- arg = MMC_TRIM_ARG;
- else
- arg = MMC_ERASE_ARG;
-retry:
- if (card->quirks & MMC_QUIRK_INAND_CMD38) {
- err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
- INAND_CMD38_ARG_EXT_CSD,
- arg == MMC_TRIM_ARG ?
- INAND_CMD38_ARG_TRIM :
- INAND_CMD38_ARG_ERASE,
- 0);
- if (err)
- goto out;
- }
- err = mmc_erase(card, from, nr, arg);
-out:
- if (err == -EIO && !mmc_blk_reset(md, card->host, type))
- goto retry;
- if (!err)
- mmc_blk_reset_success(md, type);
- blk_end_request(req, err, blk_rq_bytes(req));
-
- return err ? 0 : 1;
-}
-
-static int mmc_blk_issue_secdiscard_rq(struct mmc_queue *mq,
- struct request *req)
-{
- struct mmc_blk_data *md = mq->blkdata;
- struct mmc_card *card = md->queue.card;
- unsigned int from, nr, arg;
- int err = 0, type = MMC_BLK_SECDISCARD;
-
- if (!(mmc_can_secure_erase_trim(card))) {
- err = -EOPNOTSUPP;
- goto out;
- }
-
- from = blk_rq_pos(req);
- nr = blk_rq_sectors(req);
-
- if (mmc_can_trim(card) && !mmc_erase_group_aligned(card, from, nr))
- arg = MMC_SECURE_TRIM1_ARG;
- else
- arg = MMC_SECURE_ERASE_ARG;
-
-retry:
- if (card->quirks & MMC_QUIRK_INAND_CMD38) {
- err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
- INAND_CMD38_ARG_EXT_CSD,
- arg == MMC_SECURE_TRIM1_ARG ?
- INAND_CMD38_ARG_SECTRIM1 :
- INAND_CMD38_ARG_SECERASE,
- 0);
- if (err)
- goto out_retry;
- }
-
- err = mmc_erase(card, from, nr, arg);
- if (err == -EIO)
- goto out_retry;
- if (err)
- goto out;
-
- if (arg == MMC_SECURE_TRIM1_ARG) {
- if (card->quirks & MMC_QUIRK_INAND_CMD38) {
- err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
- INAND_CMD38_ARG_EXT_CSD,
- INAND_CMD38_ARG_SECTRIM2,
- 0);
- if (err)
- goto out_retry;
- }
-
- err = mmc_erase(card, from, nr, MMC_SECURE_TRIM2_ARG);
- if (err == -EIO)
- goto out_retry;
- if (err)
- goto out;
- }
-
-out_retry:
- if (err && !mmc_blk_reset(md, card->host, type))
- goto retry;
- if (!err)
- mmc_blk_reset_success(md, type);
-out:
- blk_end_request(req, err, blk_rq_bytes(req));
-
- return err ? 0 : 1;
-}
-
-static int mmc_blk_issue_flush(struct mmc_queue *mq, struct request *req)
-{
- struct mmc_blk_data *md = mq->blkdata;
- struct mmc_card *card = md->queue.card;
- int ret = 0;
-
- ret = mmc_flush_cache(card);
- if (ret)
- ret = -EIO;
-
- blk_end_request_all(req, ret);
-
- return ret ? 0 : 1;
-}
-
-/*
- * Reformat current write as a reliable write, supporting
- * both legacy and the enhanced reliable write MMC cards.
- * In each transfer we'll handle only as much as a single
- * reliable write can handle, thus finish the request in
- * partial completions.
- */
-static inline void mmc_apply_rel_rw(struct mmc_blk_request *brq,
- struct mmc_card *card,
- struct request *req)
-{
- 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))
- brq->data.blocks = 1;
-
- if (brq->data.blocks > card->ext_csd.rel_sectors)
- brq->data.blocks = card->ext_csd.rel_sectors;
- else if (brq->data.blocks < card->ext_csd.rel_sectors)
- brq->data.blocks = 1;
- }
-}
-
-#define CMD_ERRORS \
- (R1_OUT_OF_RANGE | /* Command argument out of range */ \
- R1_ADDRESS_ERROR | /* Misaligned address */ \
- R1_BLOCK_LEN_ERROR | /* Transferred block length incorrect */\
- R1_WP_VIOLATION | /* Tried to write to protected block */ \
- R1_CC_ERROR | /* Card controller error */ \
- R1_ERROR) /* General/unknown error */
-
-static enum mmc_blk_status mmc_blk_err_check(struct mmc_card *card,
- struct mmc_async_req *areq)
-{
- struct mmc_queue_req *mq_mrq = container_of(areq, struct mmc_queue_req,
- mmc_active);
- struct mmc_blk_request *brq = &mq_mrq->brq;
- struct request *req = mq_mrq->req;
- int need_retune = card->host->need_retune;
- bool ecc_err = false;
- bool gen_err = false;
-
- /*
- * sbc.error indicates a problem with the set block count
- * command. No data will have been transferred.
- *
- * cmd.error indicates a problem with the r/w command. No
- * data will have been transferred.
- *
- * stop.error indicates a problem with the stop command. Data
- * may have been transferred, or may still be transferring.
- */
- if (brq->sbc.error || brq->cmd.error || brq->stop.error ||
- brq->data.error) {
- switch (mmc_blk_cmd_recovery(card, req, brq, &ecc_err, &gen_err)) {
- case ERR_RETRY:
- return MMC_BLK_RETRY;
- case ERR_ABORT:
- return MMC_BLK_ABORT;
- case ERR_NOMEDIUM:
- return MMC_BLK_NOMEDIUM;
- case ERR_CONTINUE:
- break;
- }
- }
-
- /*
- * Check for errors relating to the execution of the
- * initial command - such as address errors. No data
- * has been transferred.
- */
- if (brq->cmd.resp[0] & CMD_ERRORS) {
- pr_err("%s: r/w command failed, status = %#x\n",
- req->rq_disk->disk_name, brq->cmd.resp[0]);
- return MMC_BLK_ABORT;
- }
-
- /*
- * Everything else is either success, or a data error of some
- * kind. If it was a write, we may have transitioned to
- * program mode, which we have to wait for it to complete.
- */
- if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
- int err;
-
- /* Check stop command response */
- if (brq->stop.resp[0] & R1_ERROR) {
- pr_err("%s: %s: general error sending stop command, stop cmd response %#x\n",
- req->rq_disk->disk_name, __func__,
- brq->stop.resp[0]);
- gen_err = true;
- }
-
- err = card_busy_detect(card, MMC_BLK_TIMEOUT_MS, false, req,
- &gen_err);
- if (err)
- return MMC_BLK_CMD_ERR;
- }
-
- /* if general error occurs, retry the write operation. */
- if (gen_err) {
- pr_warn("%s: retrying write for general error\n",
- req->rq_disk->disk_name);
- return MMC_BLK_RETRY;
- }
-
- if (brq->data.error) {
- if (need_retune && !brq->retune_retry_done) {
- pr_debug("%s: retrying because a re-tune was needed\n",
- req->rq_disk->disk_name);
- brq->retune_retry_done = 1;
- return MMC_BLK_RETRY;
- }
- pr_err("%s: error %d transferring data, sector %u, nr %u, cmd response %#x, card status %#x\n",
- req->rq_disk->disk_name, brq->data.error,
- (unsigned)blk_rq_pos(req),
- (unsigned)blk_rq_sectors(req),
- brq->cmd.resp[0], brq->stop.resp[0]);
-
- if (rq_data_dir(req) == READ) {
- if (ecc_err)
- return MMC_BLK_ECC_ERR;
- return MMC_BLK_DATA_ERR;
- } else {
- return MMC_BLK_CMD_ERR;
- }
- }
-
- if (!brq->data.bytes_xfered)
- return MMC_BLK_RETRY;
-
- if (blk_rq_bytes(req) != brq->data.bytes_xfered)
- return MMC_BLK_PARTIAL;
-
- 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)
-{
- u32 readcmd, writecmd;
- 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);
-
- 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;
- brq->data.blocks = blk_rq_sectors(req);
-
- /*
- * The block layer doesn't support all sector count
- * restrictions, so we need to be prepared for too big
- * requests.
- */
- if (brq->data.blocks > card->host->max_blk_count)
- brq->data.blocks = card->host->max_blk_count;
-
- if (brq->data.blocks > 1) {
- /*
- * After a read error, we redo the request one sector
- * at a time in order to accurately determine which
- * sectors can be read successfully.
- */
- if (disable_multi)
- brq->data.blocks = 1;
-
- /*
- * Some controllers have HW issues while operating
- * in multiple I/O mode
- */
- if (card->host->ops->multi_io_quirk)
- brq->data.blocks = card->host->ops->multi_io_quirk(card,
- (rq_data_dir(req) == READ) ?
- MMC_DATA_READ : MMC_DATA_WRITE,
- brq->data.blocks);
- }
-
- if (brq->data.blocks > 1 || do_rel_wr) {
- /* SPI multiblock writes terminate using a special
- * token, not a STOP_TRANSMISSION request.
- */
- if (!mmc_host_is_spi(card->host) ||
- rq_data_dir(req) == READ)
- brq->mrq.stop = &brq->stop;
- readcmd = MMC_READ_MULTIPLE_BLOCK;
- writecmd = MMC_WRITE_MULTIPLE_BLOCK;
- } else {
- brq->mrq.stop = NULL;
- 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);
-
- /*
- * Pre-defined multi-block transfers are preferable to
- * open ended-ones (and necessary for reliable writes).
- * However, it is not sufficient to just send CMD23,
- * and avoid the final CMD12, as on an error condition
- * CMD12 (stop) needs to be sent anyway. This, coupled
- * with Auto-CMD23 enhancements provided by some
- * hosts, means that the complexity of dealing
- * with this is best left to the host. If CMD23 is
- * supported by card and host, we'll fill sbc in and let
- * the host deal with handling it correctly. This means
- * that for hosts that don't expose MMC_CAP_CMD23, no
- * change of behavior will be observed.
- *
- * N.B: Some MMC cards experience perf degradation.
- * We'll avoid using CMD23-bounded multiblock writes for
- * these, while retaining features like reliable writes.
- */
- if ((md->flags & MMC_BLK_CMD23) && mmc_op_multi(brq->cmd.opcode) &&
- (do_rel_wr || !(card->quirks & MMC_QUIRK_BLK_NO_CMD23) ||
- do_data_tag)) {
- brq->sbc.opcode = MMC_SET_BLOCK_COUNT;
- brq->sbc.arg = brq->data.blocks |
- (do_rel_wr ? (1 << 31) : 0) |
- (do_data_tag ? (1 << 29) : 0);
- brq->sbc.flags = MMC_RSP_R1 | MMC_CMD_AC;
- 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->mmc_active.mrq = &brq->mrq;
- mqrq->mmc_active.err_check = mmc_blk_err_check;
-
- mmc_queue_bounce_pre(mqrq);
-}
-
-static int mmc_blk_cmd_err(struct mmc_blk_data *md, struct mmc_card *card,
- struct mmc_blk_request *brq, struct request *req,
- int ret)
-{
- struct mmc_queue_req *mq_rq;
- mq_rq = container_of(brq, struct mmc_queue_req, brq);
-
- /*
- * If this is an SD card and we're writing, we can first
- * mark the known good sectors as ok.
- *
- * If the card is not SD, we can still ok written sectors
- * as reported by the controller (which might be less than
- * the real number of written sectors, but never more).
- */
- if (mmc_card_sd(card)) {
- u32 blocks;
-
- blocks = mmc_sd_num_wr_blocks(card);
- if (blocks != (u32)-1) {
- ret = blk_end_request(req, 0, blocks << 9);
- }
- } else {
- ret = blk_end_request(req, 0, brq->data.bytes_xfered);
- }
- return ret;
-}
-
-static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
-{
- struct mmc_blk_data *md = mq->blkdata;
- struct mmc_card *card = md->queue.card;
- struct mmc_blk_request *brq;
- int ret = 1, disable_multi = 0, retry = 0, type, retune_retry_done = 0;
- enum mmc_blk_status status;
- struct mmc_queue_req *mq_rq;
- struct request *req;
- struct mmc_async_req *areq;
-
- if (!rqc && !mq->mqrq_prev->req)
- return 0;
-
- do {
- if (rqc) {
- /*
- * When 4KB native sector is enabled, only 8 blocks
- * multiple read or write is allowed
- */
- if (mmc_large_sector(card) &&
- !IS_ALIGNED(blk_rq_sectors(rqc), 8)) {
- pr_err("%s: Transfer size is not 4KB sector size aligned\n",
- rqc->rq_disk->disk_name);
- mq_rq = mq->mqrq_cur;
- req = rqc;
- rqc = NULL;
- goto cmd_abort;
- }
-
- mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq);
- areq = &mq->mqrq_cur->mmc_active;
- } else
- areq = NULL;
- areq = mmc_start_req(card->host, areq, &status);
- if (!areq) {
- if (status == MMC_BLK_NEW_REQUEST)
- mq->flags |= MMC_QUEUE_NEW_REQUEST;
- return 0;
- }
-
- mq_rq = container_of(areq, struct mmc_queue_req, mmc_active);
- brq = &mq_rq->brq;
- req = mq_rq->req;
- type = rq_data_dir(req) == READ ? MMC_BLK_READ : MMC_BLK_WRITE;
- mmc_queue_bounce_post(mq_rq);
-
- switch (status) {
- case MMC_BLK_SUCCESS:
- case MMC_BLK_PARTIAL:
- /*
- * A block was successfully transferred.
- */
- mmc_blk_reset_success(md, type);
-
- ret = blk_end_request(req, 0,
- brq->data.bytes_xfered);
-
- /*
- * If the blk_end_request function returns non-zero even
- * though all data has been transferred and no errors
- * were returned by the host controller, it's a bug.
- */
- if (status == MMC_BLK_SUCCESS && ret) {
- pr_err("%s BUG rq_tot %d d_xfer %d\n",
- __func__, blk_rq_bytes(req),
- brq->data.bytes_xfered);
- rqc = NULL;
- goto cmd_abort;
- }
- break;
- case MMC_BLK_CMD_ERR:
- ret = mmc_blk_cmd_err(md, card, brq, req, ret);
- if (mmc_blk_reset(md, card->host, type))
- goto cmd_abort;
- if (!ret)
- goto start_new_req;
- break;
- case MMC_BLK_RETRY:
- retune_retry_done = brq->retune_retry_done;
- if (retry++ < 5)
- break;
- /* Fall through */
- case MMC_BLK_ABORT:
- if (!mmc_blk_reset(md, card->host, type))
- break;
- goto cmd_abort;
- case MMC_BLK_DATA_ERR: {
- int err;
-
- err = mmc_blk_reset(md, card->host, type);
- if (!err)
- break;
- if (err == -ENODEV)
- goto cmd_abort;
- /* Fall through */
- }
- case MMC_BLK_ECC_ERR:
- if (brq->data.blocks > 1) {
- /* Redo read one sector at a time */
- pr_warn("%s: retrying using single block read\n",
- req->rq_disk->disk_name);
- disable_multi = 1;
- break;
- }
- /*
- * After an error, we redo I/O one sector at a
- * time, so we only reach here after trying to
- * read a single sector.
- */
- ret = blk_end_request(req, -EIO,
- brq->data.blksz);
- if (!ret)
- goto start_new_req;
- break;
- case MMC_BLK_NOMEDIUM:
- goto cmd_abort;
- default:
- pr_err("%s: Unhandled return value (%d)",
- req->rq_disk->disk_name, status);
- goto cmd_abort;
- }
-
- if (ret) {
- /*
- * In case of a incomplete request
- * prepare it again and resend.
- */
- mmc_blk_rw_rq_prep(mq_rq, card,
- disable_multi, mq);
- mmc_start_req(card->host,
- &mq_rq->mmc_active, NULL);
- mq_rq->brq.retune_retry_done = retune_retry_done;
- }
- } while (ret);
-
- return 1;
-
- cmd_abort:
- if (mmc_card_removed(card))
- req->cmd_flags |= REQ_QUIET;
- while (ret)
- ret = blk_end_request(req, -EIO,
- blk_rq_cur_bytes(req));
-
- start_new_req:
- if (rqc) {
- if (mmc_card_removed(card)) {
- rqc->cmd_flags |= REQ_QUIET;
- blk_end_request_all(rqc, -EIO);
- } else {
- mmc_blk_rw_rq_prep(mq->mqrq_cur, card, 0, mq);
- mmc_start_req(card->host,
- &mq->mqrq_cur->mmc_active, NULL);
- }
- }
-
- return 0;
-}
-
-int 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)
- /* claim host only for the first request */
- mmc_get_card(card);
-
- ret = mmc_blk_part_switch(card, md);
- if (ret) {
- if (req) {
- blk_end_request_all(req, -EIO);
- }
- ret = 0;
- goto out;
- }
-
- mq->flags &= ~MMC_QUEUE_NEW_REQUEST;
- if (req && req_op(req) == REQ_OP_DISCARD) {
- /* complete ongoing async transfer before issuing discard */
- if (card->host->areq)
- mmc_blk_issue_rw_rq(mq, NULL);
- ret = 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)
- mmc_blk_issue_rw_rq(mq, NULL);
- ret = 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)
- mmc_blk_issue_rw_rq(mq, NULL);
- ret = mmc_blk_issue_flush(mq, req);
- } else {
- ret = mmc_blk_issue_rw_rq(mq, req);
- }
-
-out:
- if ((!req && !(mq->flags & MMC_QUEUE_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'.
- */
- mmc_put_card(card);
- return ret;
-}
-
-static inline int mmc_blk_readonly(struct mmc_card *card)
-{
- return mmc_card_readonly(card) ||
- !(card->csd.cmdclass & CCC_BLOCK_WRITE);
-}
-
-static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
- struct device *parent,
- sector_t size,
- bool default_ro,
- const char *subname,
- int area_type)
-{
- struct mmc_blk_data *md;
- int devidx, ret;
-
-again:
- if (!ida_pre_get(&mmc_blk_ida, GFP_KERNEL))
- return ERR_PTR(-ENOMEM);
-
- spin_lock(&mmc_blk_lock);
- ret = ida_get_new(&mmc_blk_ida, &devidx);
- spin_unlock(&mmc_blk_lock);
-
- if (ret == -EAGAIN)
- goto again;
- else if (ret)
- return ERR_PTR(ret);
-
- if (devidx >= max_devices) {
- ret = -ENOSPC;
- goto out;
- }
-
- md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
- if (!md) {
- ret = -ENOMEM;
- goto out;
- }
-
- md->area_type = area_type;
-
- /*
- * Set the read-only status based on the supported commands
- * and the write protect switch.
- */
- md->read_only = mmc_blk_readonly(card);
-
- md->disk = alloc_disk(perdev_minors);
- if (md->disk == NULL) {
- ret = -ENOMEM;
- goto err_kfree;
- }
-
- spin_lock_init(&md->lock);
- INIT_LIST_HEAD(&md->part);
- md->usage = 1;
-
- ret = mmc_init_queue(&md->queue, card, &md->lock, subname);
- if (ret)
- goto err_putdisk;
-
- md->queue.blkdata = md;
-
- md->disk->major = MMC_BLOCK_MAJOR;
- md->disk->first_minor = devidx * perdev_minors;
- md->disk->fops = &mmc_bdops;
- md->disk->private_data = md;
- md->disk->queue = md->queue.queue;
- md->parent = parent;
- set_disk_ro(md->disk, md->read_only || default_ro);
- md->disk->flags = GENHD_FL_EXT_DEVT;
- if (area_type & (MMC_BLK_DATA_AREA_RPMB | MMC_BLK_DATA_AREA_BOOT))
- md->disk->flags |= GENHD_FL_NO_PART_SCAN;
-
- /*
- * As discussed on lkml, GENHD_FL_REMOVABLE should:
- *
- * - be set for removable media with permanent block devices
- * - be unset for removable block devices with permanent media
- *
- * Since MMC block devices clearly fall under the second
- * case, we do not set GENHD_FL_REMOVABLE. Userspace
- * should use the block device creation/destruction hotplug
- * messages to tell when the card is present.
- */
-
- snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
- "mmcblk%u%s", card->host->index, subname ? subname : "");
-
- if (mmc_card_mmc(card))
- blk_queue_logical_block_size(md->queue.queue,
- card->ext_csd.data_sector_size);
- else
- blk_queue_logical_block_size(md->queue.queue, 512);
-
- set_capacity(md->disk, size);
-
- if (mmc_host_cmd23(card->host)) {
- if ((mmc_card_mmc(card) &&
- card->csd.mmca_vsn >= CSD_SPEC_VER_3) ||
- (mmc_card_sd(card) &&
- card->scr.cmds & SD_SCR_CMD23_SUPPORT))
- md->flags |= MMC_BLK_CMD23;
- }
-
- if (mmc_card_mmc(card) &&
- md->flags & MMC_BLK_CMD23 &&
- ((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) ||
- card->ext_csd.rel_sectors)) {
- md->flags |= MMC_BLK_REL_WR;
- blk_queue_write_cache(md->queue.queue, true, true);
- }
-
- return md;
-
- err_putdisk:
- put_disk(md->disk);
- err_kfree:
- kfree(md);
- out:
- spin_lock(&mmc_blk_lock);
- ida_remove(&mmc_blk_ida, devidx);
- spin_unlock(&mmc_blk_lock);
- return ERR_PTR(ret);
-}
-
-static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
-{
- sector_t size;
-
- if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
- /*
- * The EXT_CSD sector count is in number or 512 byte
- * sectors.
- */
- size = card->ext_csd.sectors;
- } else {
- /*
- * The CSD capacity field is in units of read_blkbits.
- * set_capacity takes units of 512 bytes.
- */
- size = (typeof(sector_t))card->csd.capacity
- << (card->csd.read_blkbits - 9);
- }
-
- return mmc_blk_alloc_req(card, &card->dev, size, false, NULL,
- MMC_BLK_DATA_AREA_MAIN);
-}
-
-static int mmc_blk_alloc_part(struct mmc_card *card,
- struct mmc_blk_data *md,
- unsigned int part_type,
- sector_t size,
- bool default_ro,
- const char *subname,
- int area_type)
-{
- char cap_str[10];
- struct mmc_blk_data *part_md;
-
- part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro,
- subname, area_type);
- if (IS_ERR(part_md))
- return PTR_ERR(part_md);
- part_md->part_type = part_type;
- list_add(&part_md->part, &md->part);
-
- string_get_size((u64)get_capacity(part_md->disk), 512, STRING_UNITS_2,
- cap_str, sizeof(cap_str));
- pr_info("%s: %s %s partition %u %s\n",
- part_md->disk->disk_name, mmc_card_id(card),
- mmc_card_name(card), part_md->part_type, cap_str);
- return 0;
-}
-
-/* MMC Physical partitions consist of two boot partitions and
- * up to four general purpose partitions.
- * For each partition enabled in EXT_CSD a block device will be allocatedi
- * to provide access to the partition.
- */
-
-static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
-{
- int idx, ret = 0;
-
- if (!mmc_card_mmc(card))
- return 0;
-
- for (idx = 0; idx < card->nr_parts; idx++) {
- if (card->part[idx].size) {
- ret = mmc_blk_alloc_part(card, md,
- card->part[idx].part_cfg,
- card->part[idx].size >> 9,
- card->part[idx].force_ro,
- card->part[idx].name,
- card->part[idx].area_type);
- if (ret)
- return ret;
- }
- }
-
- return ret;
-}
-
-static void mmc_blk_remove_req(struct mmc_blk_data *md)
-{
- struct mmc_card *card;
-
- if (md) {
- /*
- * Flush remaining requests and free queues. It
- * is freeing the queue that stops new requests
- * from being accepted.
- */
- card = md->queue.card;
- mmc_cleanup_queue(&md->queue);
- if (md->disk->flags & GENHD_FL_UP) {
- device_remove_file(disk_to_dev(md->disk), &md->force_ro);
- if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
- card->ext_csd.boot_ro_lockable)
- device_remove_file(disk_to_dev(md->disk),
- &md->power_ro_lock);
-
- del_gendisk(md->disk);
- }
- mmc_blk_put(md);
- }
-}
-
-static void mmc_blk_remove_parts(struct mmc_card *card,
- struct mmc_blk_data *md)
-{
- struct list_head *pos, *q;
- struct mmc_blk_data *part_md;
-
- list_for_each_safe(pos, q, &md->part) {
- part_md = list_entry(pos, struct mmc_blk_data, part);
- list_del(pos);
- mmc_blk_remove_req(part_md);
- }
-}
-
-static int mmc_add_disk(struct mmc_blk_data *md)
-{
- int ret;
- struct mmc_card *card = md->queue.card;
-
- device_add_disk(md->parent, md->disk);
- md->force_ro.show = force_ro_show;
- md->force_ro.store = force_ro_store;
- sysfs_attr_init(&md->force_ro.attr);
- md->force_ro.attr.name = "force_ro";
- md->force_ro.attr.mode = S_IRUGO | S_IWUSR;
- ret = device_create_file(disk_to_dev(md->disk), &md->force_ro);
- if (ret)
- goto force_ro_fail;
-
- if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
- card->ext_csd.boot_ro_lockable) {
- umode_t mode;
-
- if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_DIS)
- mode = S_IRUGO;
- else
- mode = S_IRUGO | S_IWUSR;
-
- md->power_ro_lock.show = power_ro_lock_show;
- md->power_ro_lock.store = power_ro_lock_store;
- sysfs_attr_init(&md->power_ro_lock.attr);
- md->power_ro_lock.attr.mode = mode;
- md->power_ro_lock.attr.name =
- "ro_lock_until_next_power_on";
- ret = device_create_file(disk_to_dev(md->disk),
- &md->power_ro_lock);
- if (ret)
- goto power_ro_lock_fail;
- }
- return ret;
-
-power_ro_lock_fail:
- device_remove_file(disk_to_dev(md->disk), &md->force_ro);
-force_ro_fail:
- del_gendisk(md->disk);
-
- return ret;
-}
-
-static const struct mmc_fixup blk_fixups[] =
-{
- MMC_FIXUP("SEM02G", CID_MANFID_SANDISK, 0x100, add_quirk,
- MMC_QUIRK_INAND_CMD38),
- MMC_FIXUP("SEM04G", CID_MANFID_SANDISK, 0x100, add_quirk,
- MMC_QUIRK_INAND_CMD38),
- MMC_FIXUP("SEM08G", CID_MANFID_SANDISK, 0x100, add_quirk,
- MMC_QUIRK_INAND_CMD38),
- MMC_FIXUP("SEM16G", CID_MANFID_SANDISK, 0x100, add_quirk,
- MMC_QUIRK_INAND_CMD38),
- MMC_FIXUP("SEM32G", CID_MANFID_SANDISK, 0x100, add_quirk,
- MMC_QUIRK_INAND_CMD38),
-
- /*
- * Some MMC cards experience performance degradation with CMD23
- * instead of CMD12-bounded multiblock transfers. For now we'll
- * black list what's bad...
- * - Certain Toshiba cards.
- *
- * N.B. This doesn't affect SD cards.
- */
- MMC_FIXUP("SDMB-32", CID_MANFID_SANDISK, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_BLK_NO_CMD23),
- MMC_FIXUP("SDM032", CID_MANFID_SANDISK, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_BLK_NO_CMD23),
- MMC_FIXUP("MMC08G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_BLK_NO_CMD23),
- MMC_FIXUP("MMC16G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_BLK_NO_CMD23),
- MMC_FIXUP("MMC32G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_BLK_NO_CMD23),
-
- /*
- * Some MMC cards need longer data read timeout than indicated in CSD.
- */
- MMC_FIXUP(CID_NAME_ANY, CID_MANFID_MICRON, 0x200, add_quirk_mmc,
- MMC_QUIRK_LONG_READ_TIME),
- MMC_FIXUP("008GE0", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_LONG_READ_TIME),
-
- /*
- * On these Samsung MoviNAND parts, performing secure erase or
- * secure trim can result in unrecoverable corruption due to a
- * firmware bug.
- */
- MMC_FIXUP("M8G2FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
- MMC_FIXUP("MAG4FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
- MMC_FIXUP("MBG8FA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
- MMC_FIXUP("MCGAFA", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
- MMC_FIXUP("VAL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
- MMC_FIXUP("VYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
- MMC_FIXUP("KYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
- MMC_FIXUP("VZL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_SEC_ERASE_TRIM_BROKEN),
-
- /*
- * On Some Kingston eMMCs, performing trim can result in
- * unrecoverable data conrruption occasionally due to a firmware bug.
- */
- MMC_FIXUP("V10008", CID_MANFID_KINGSTON, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_TRIM_BROKEN),
- MMC_FIXUP("V10016", CID_MANFID_KINGSTON, CID_OEMID_ANY, add_quirk_mmc,
- MMC_QUIRK_TRIM_BROKEN),
-
- END_FIXUP
-};
-
-static int mmc_blk_probe(struct mmc_card *card)
-{
- struct mmc_blk_data *md, *part_md;
- char cap_str[10];
-
- /*
- * Check that the card supports the command class(es) we need.
- */
- if (!(card->csd.cmdclass & CCC_BLOCK_READ))
- return -ENODEV;
-
- mmc_fixup_device(card, blk_fixups);
-
- md = mmc_blk_alloc(card);
- if (IS_ERR(md))
- return PTR_ERR(md);
-
- string_get_size((u64)get_capacity(md->disk), 512, STRING_UNITS_2,
- cap_str, sizeof(cap_str));
- pr_info("%s: %s %s %s %s\n",
- md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
- cap_str, md->read_only ? "(ro)" : "");
-
- if (mmc_blk_alloc_parts(card, md))
- goto out;
-
- dev_set_drvdata(&card->dev, md);
-
- if (mmc_add_disk(md))
- goto out;
-
- list_for_each_entry(part_md, &md->part, part) {
- if (mmc_add_disk(part_md))
- goto out;
- }
-
- pm_runtime_set_autosuspend_delay(&card->dev, 3000);
- pm_runtime_use_autosuspend(&card->dev);
-
- /*
- * Don't enable runtime PM for SD-combo cards here. Leave that
- * decision to be taken during the SDIO init sequence instead.
- */
- if (card->type != MMC_TYPE_SD_COMBO) {
- pm_runtime_set_active(&card->dev);
- pm_runtime_enable(&card->dev);
- }
-
- return 0;
-
- out:
- mmc_blk_remove_parts(card, md);
- mmc_blk_remove_req(md);
- return 0;
-}
-
-static void mmc_blk_remove(struct mmc_card *card)
-{
- struct mmc_blk_data *md = dev_get_drvdata(&card->dev);
-
- mmc_blk_remove_parts(card, md);
- pm_runtime_get_sync(&card->dev);
- mmc_claim_host(card->host);
- mmc_blk_part_switch(card, md);
- mmc_release_host(card->host);
- if (card->type != MMC_TYPE_SD_COMBO)
- pm_runtime_disable(&card->dev);
- pm_runtime_put_noidle(&card->dev);
- mmc_blk_remove_req(md);
- dev_set_drvdata(&card->dev, NULL);
-}
-
-static int _mmc_blk_suspend(struct mmc_card *card)
-{
- struct mmc_blk_data *part_md;
- struct mmc_blk_data *md = dev_get_drvdata(&card->dev);
-
- if (md) {
- mmc_queue_suspend(&md->queue);
- list_for_each_entry(part_md, &md->part, part) {
- mmc_queue_suspend(&part_md->queue);
- }
- }
- return 0;
-}
-
-static void mmc_blk_shutdown(struct mmc_card *card)
-{
- _mmc_blk_suspend(card);
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int mmc_blk_suspend(struct device *dev)
-{
- struct mmc_card *card = mmc_dev_to_card(dev);
-
- return _mmc_blk_suspend(card);
-}
-
-static int mmc_blk_resume(struct device *dev)
-{
- struct mmc_blk_data *part_md;
- struct mmc_blk_data *md = dev_get_drvdata(dev);
-
- if (md) {
- /*
- * Resume involves the card going into idle state,
- * so current partition is always the main one.
- */
- md->part_curr = md->part_type;
- mmc_queue_resume(&md->queue);
- list_for_each_entry(part_md, &md->part, part) {
- mmc_queue_resume(&part_md->queue);
- }
- }
- return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(mmc_blk_pm_ops, mmc_blk_suspend, mmc_blk_resume);
-
-static struct mmc_driver mmc_driver = {
- .drv = {
- .name = "mmcblk",
- .pm = &mmc_blk_pm_ops,
- },
- .probe = mmc_blk_probe,
- .remove = mmc_blk_remove,
- .shutdown = mmc_blk_shutdown,
-};
-
-static int __init mmc_blk_init(void)
-{
- int res;
-
- if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
- pr_info("mmcblk: using %d minors per device\n", perdev_minors);
-
- max_devices = min(MAX_DEVICES, (1 << MINORBITS) / perdev_minors);
-
- res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");
- if (res)
- goto out;
-
- res = mmc_register_driver(&mmc_driver);
- if (res)
- goto out2;
-
- return 0;
- out2:
- unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
- out:
- return res;
-}
-
-static void __exit mmc_blk_exit(void)
-{
- mmc_unregister_driver(&mmc_driver);
- unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
-}
-
-module_init(mmc_blk_init);
-module_exit(mmc_blk_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver");
-
diff --git a/drivers/mmc/card/block.h b/drivers/mmc/card/block.h
deleted file mode 100644
index cdabb2ee74be..000000000000
--- a/drivers/mmc/card/block.h
+++ /dev/null
@@ -1 +0,0 @@
-int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req);
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
deleted file mode 100644
index ec1d1c46eb90..000000000000
--- a/drivers/mmc/card/mmc_test.c
+++ /dev/null
@@ -1,3314 +0,0 @@
-/*
- * linux/drivers/mmc/card/mmc_test.c
- *
- * Copyright 2007-2008 Pierre Ossman
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- */
-
-#include <linux/mmc/core.h>
-#include <linux/mmc/card.h>
-#include <linux/mmc/host.h>
-#include <linux/mmc/mmc.h>
-#include <linux/slab.h>
-
-#include <linux/scatterlist.h>
-#include <linux/swap.h> /* For nr_free_buffer_pages() */
-#include <linux/list.h>
-
-#include <linux/debugfs.h>
-#include <linux/uaccess.h>
-#include <linux/seq_file.h>
-#include <linux/module.h>
-
-#define RESULT_OK 0
-#define RESULT_FAIL 1
-#define RESULT_UNSUP_HOST 2
-#define RESULT_UNSUP_CARD 3
-
-#define BUFFER_ORDER 2
-#define BUFFER_SIZE (PAGE_SIZE << BUFFER_ORDER)
-
-#define TEST_ALIGN_END 8
-
-/*
- * Limit the test area size to the maximum MMC HC erase group size. Note that
- * the maximum SD allocation unit size is just 4MiB.
- */
-#define TEST_AREA_MAX_SIZE (128 * 1024 * 1024)
-
-/**
- * struct mmc_test_pages - pages allocated by 'alloc_pages()'.
- * @page: first page in the allocation
- * @order: order of the number of pages allocated
- */
-struct mmc_test_pages {
- struct page *page;
- unsigned int order;
-};
-
-/**
- * struct mmc_test_mem - allocated memory.
- * @arr: array of allocations
- * @cnt: number of allocations
- */
-struct mmc_test_mem {
- struct mmc_test_pages *arr;
- unsigned int cnt;
-};
-
-/**
- * struct mmc_test_area - information for performance tests.
- * @max_sz: test area size (in bytes)
- * @dev_addr: address on card at which to do performance tests
- * @max_tfr: maximum transfer size allowed by driver (in bytes)
- * @max_segs: maximum segments allowed by driver in scatterlist @sg
- * @max_seg_sz: maximum segment size allowed by driver
- * @blocks: number of (512 byte) blocks currently mapped by @sg
- * @sg_len: length of currently mapped scatterlist @sg
- * @mem: allocated memory
- * @sg: scatterlist
- */
-struct mmc_test_area {
- unsigned long max_sz;
- unsigned int dev_addr;
- unsigned int max_tfr;
- unsigned int max_segs;
- unsigned int max_seg_sz;
- unsigned int blocks;
- unsigned int sg_len;
- struct mmc_test_mem *mem;
- struct scatterlist *sg;
-};
-
-/**
- * struct mmc_test_transfer_result - transfer results for performance tests.
- * @link: double-linked list
- * @count: amount of group of sectors to check
- * @sectors: amount of sectors to check in one group
- * @ts: time values of transfer
- * @rate: calculated transfer rate
- * @iops: I/O operations per second (times 100)
- */
-struct mmc_test_transfer_result {
- struct list_head link;
- unsigned int count;
- unsigned int sectors;
- struct timespec ts;
- unsigned int rate;
- unsigned int iops;
-};
-
-/**
- * struct mmc_test_general_result - results for tests.
- * @link: double-linked list
- * @card: card under test
- * @testcase: number of test case
- * @result: result of test run
- * @tr_lst: transfer measurements if any as mmc_test_transfer_result
- */
-struct mmc_test_general_result {
- struct list_head link;
- struct mmc_card *card;
- int testcase;
- int result;
- struct list_head tr_lst;
-};
-
-/**
- * struct mmc_test_dbgfs_file - debugfs related file.
- * @link: double-linked list
- * @card: card under test
- * @file: file created under debugfs
- */
-struct mmc_test_dbgfs_file {
- struct list_head link;
- struct mmc_card *card;
- struct dentry *file;
-};
-
-/**
- * struct mmc_test_card - test information.
- * @card: card under test
- * @scratch: transfer buffer
- * @buffer: transfer buffer
- * @highmem: buffer for highmem tests
- * @area: information for performance tests
- * @gr: pointer to results of current testcase
- */
-struct mmc_test_card {
- struct mmc_card *card;
-
- u8 scratch[BUFFER_SIZE];
- u8 *buffer;
-#ifdef CONFIG_HIGHMEM
- struct page *highmem;
-#endif
- struct mmc_test_area area;
- struct mmc_test_general_result *gr;
-};
-
-enum mmc_test_prep_media {
- MMC_TEST_PREP_NONE = 0,
- MMC_TEST_PREP_WRITE_FULL = 1 << 0,
- MMC_TEST_PREP_ERASE = 1 << 1,
-};
-
-struct mmc_test_multiple_rw {
- unsigned int *sg_len;
- unsigned int *bs;
- unsigned int len;
- unsigned int size;
- bool do_write;
- bool do_nonblock_req;
- enum mmc_test_prep_media prepare;
-};
-
-struct mmc_test_async_req {
- struct mmc_async_req areq;
- struct mmc_test_card *test;
-};
-
-/*******************************************************************/
-/* General helper functions */
-/*******************************************************************/
-
-/*
- * Configure correct block size in card
- */
-static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)
-{
- return mmc_set_blocklen(test->card, size);
-}
-
-static bool mmc_test_card_cmd23(struct mmc_card *card)
-{
- return mmc_card_mmc(card) ||
- (mmc_card_sd(card) && card->scr.cmds & SD_SCR_CMD23_SUPPORT);
-}
-
-static void mmc_test_prepare_sbc(struct mmc_test_card *test,
- struct mmc_request *mrq, unsigned int blocks)
-{
- struct mmc_card *card = test->card;
-
- if (!mrq->sbc || !mmc_host_cmd23(card->host) ||
- !mmc_test_card_cmd23(card) || !mmc_op_multi(mrq->cmd->opcode) ||
- (card->quirks & MMC_QUIRK_BLK_NO_CMD23)) {
- mrq->sbc = NULL;
- return;
- }
-
- mrq->sbc->opcode = MMC_SET_BLOCK_COUNT;
- mrq->sbc->arg = blocks;
- mrq->sbc->flags = MMC_RSP_R1 | MMC_CMD_AC;
-}
-
-/*
- * Fill in the mmc_request structure given a set of transfer parameters.
- */
-static void mmc_test_prepare_mrq(struct mmc_test_card *test,
- struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
- unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
-{
- if (WARN_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop))
- return;
-
- if (blocks > 1) {
- mrq->cmd->opcode = write ?
- MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
- } else {
- mrq->cmd->opcode = write ?
- MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
- }
-
- mrq->cmd->arg = dev_addr;
- if (!mmc_card_blockaddr(test->card))
- mrq->cmd->arg <<= 9;
-
- mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
-
- if (blocks == 1)
- mrq->stop = NULL;
- else {
- mrq->stop->opcode = MMC_STOP_TRANSMISSION;
- mrq->stop->arg = 0;
- mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
- }
-
- mrq->data->blksz = blksz;
- mrq->data->blocks = blocks;
- mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
- mrq->data->sg = sg;
- mrq->data->sg_len = sg_len;
-
- mmc_test_prepare_sbc(test, mrq, blocks);
-
- mmc_set_data_timeout(mrq->data, test->card);
-}
-
-static int mmc_test_busy(struct mmc_command *cmd)
-{
- return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
- (R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
-}
-
-/*
- * Wait for the card to finish the busy state
- */
-static int mmc_test_wait_busy(struct mmc_test_card *test)
-{
- int ret, busy;
- struct mmc_command cmd = {0};
-
- busy = 0;
- do {
- memset(&cmd, 0, sizeof(struct mmc_command));
-
- cmd.opcode = MMC_SEND_STATUS;
- cmd.arg = test->card->rca << 16;
- cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
-
- ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
- if (ret)
- break;
-
- if (!busy && mmc_test_busy(&cmd)) {
- busy = 1;
- if (test->card->host->caps & MMC_CAP_WAIT_WHILE_BUSY)
- pr_info("%s: Warning: Host did not "
- "wait for busy state to end.\n",
- mmc_hostname(test->card->host));
- }
- } while (mmc_test_busy(&cmd));
-
- return ret;
-}
-
-/*
- * Transfer a single sector of kernel addressable data
- */
-static int mmc_test_buffer_transfer(struct mmc_test_card *test,
- u8 *buffer, unsigned addr, unsigned blksz, int write)
-{
- struct mmc_request mrq = {0};
- struct mmc_command cmd = {0};
- struct mmc_command stop = {0};
- struct mmc_data data = {0};
-
- struct scatterlist sg;
-
- mrq.cmd = &cmd;
- mrq.data = &data;
- mrq.stop = &stop;
-
- sg_init_one(&sg, buffer, blksz);
-
- mmc_test_prepare_mrq(test, &mrq, &sg, 1, addr, 1, blksz, write);
-
- mmc_wait_for_req(test->card->host, &mrq);
-
- if (cmd.error)
- return cmd.error;
- if (data.error)
- return data.error;
-
- return mmc_test_wait_busy(test);
-}
-
-static void mmc_test_free_mem(struct mmc_test_mem *mem)
-{
- if (!mem)
- return;
- while (mem->cnt--)
- __free_pages(mem->arr[mem->cnt].page,
- mem->arr[mem->cnt].order);
- kfree(mem->arr);
- kfree(mem);
-}
-
-/*
- * Allocate a lot of memory, preferably max_sz but at least min_sz. In case
- * there isn't much memory do not exceed 1/16th total lowmem pages. Also do
- * not exceed a maximum number of segments and try not to make segments much
- * bigger than maximum segment size.
- */
-static struct mmc_test_mem *mmc_test_alloc_mem(unsigned long min_sz,
- unsigned long max_sz,
- unsigned int max_segs,
- unsigned int max_seg_sz)
-{
- unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE);
- unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE);
- unsigned long max_seg_page_cnt = DIV_ROUND_UP(max_seg_sz, PAGE_SIZE);
- unsigned long page_cnt = 0;
- unsigned long limit = nr_free_buffer_pages() >> 4;
- struct mmc_test_mem *mem;
-
- if (max_page_cnt > limit)
- max_page_cnt = limit;
- if (min_page_cnt > max_page_cnt)
- min_page_cnt = max_page_cnt;
-
- if (max_seg_page_cnt > max_page_cnt)
- max_seg_page_cnt = max_page_cnt;
-
- if (max_segs > max_page_cnt)
- max_segs = max_page_cnt;
-
- mem = kzalloc(sizeof(struct mmc_test_mem), GFP_KERNEL);
- if (!mem)
- return NULL;
-
- mem->arr = kzalloc(sizeof(struct mmc_test_pages) * max_segs,
- GFP_KERNEL);
- if (!mem->arr)
- goto out_free;
-
- while (max_page_cnt) {
- struct page *page;
- unsigned int order;
- gfp_t flags = GFP_KERNEL | GFP_DMA | __GFP_NOWARN |
- __GFP_NORETRY;
-
- order = get_order(max_seg_page_cnt << PAGE_SHIFT);
- while (1) {
- page = alloc_pages(flags, order);
- if (page || !order)
- break;
- order -= 1;
- }
- if (!page) {
- if (page_cnt < min_page_cnt)
- goto out_free;
- break;
- }
- mem->arr[mem->cnt].page = page;
- mem->arr[mem->cnt].order = order;
- mem->cnt += 1;
- if (max_page_cnt <= (1UL << order))
- break;
- max_page_cnt -= 1UL << order;
- page_cnt += 1UL << order;
- if (mem->cnt >= max_segs) {
- if (page_cnt < min_page_cnt)
- goto out_free;
- break;
- }
- }
-
- return mem;
-
-out_free:
- mmc_test_free_mem(mem);
- return NULL;
-}
-
-/*
- * Map memory into a scatterlist. Optionally allow the same memory to be
- * mapped more than once.
- */
-static int mmc_test_map_sg(struct mmc_test_mem *mem, unsigned long size,
- struct scatterlist *sglist, int repeat,
- unsigned int max_segs, unsigned int max_seg_sz,
- unsigned int *sg_len, int min_sg_len)
-{
- struct scatterlist *sg = NULL;
- unsigned int i;
- unsigned long sz = size;
-
- sg_init_table(sglist, max_segs);
- if (min_sg_len > max_segs)
- min_sg_len = max_segs;
-
- *sg_len = 0;
- do {
- for (i = 0; i < mem->cnt; i++) {
- unsigned long len = PAGE_SIZE << mem->arr[i].order;
-
- if (min_sg_len && (size / min_sg_len < len))
- len = ALIGN(size / min_sg_len, 512);
- if (len > sz)
- len = sz;
- if (len > max_seg_sz)
- len = max_seg_sz;
- if (sg)
- sg = sg_next(sg);
- else
- sg = sglist;
- if (!sg)
- return -EINVAL;
- sg_set_page(sg, mem->arr[i].page, len, 0);
- sz -= len;
- *sg_len += 1;
- if (!sz)
- break;
- }
- } while (sz && repeat);
-
- if (sz)
- return -EINVAL;
-
- if (sg)
- sg_mark_end(sg);
-
- return 0;
-}
-
-/*
- * Map memory into a scatterlist so that no pages are contiguous. Allow the
- * same memory to be mapped more than once.
- */
-static int mmc_test_map_sg_max_scatter(struct mmc_test_mem *mem,
- unsigned long sz,
- struct scatterlist *sglist,
- unsigned int max_segs,
- unsigned int max_seg_sz,
- unsigned int *sg_len)
-{
- struct scatterlist *sg = NULL;
- unsigned int i = mem->cnt, cnt;
- unsigned long len;
- void *base, *addr, *last_addr = NULL;
-
- sg_init_table(sglist, max_segs);
-
- *sg_len = 0;
- while (sz) {
- base = page_address(mem->arr[--i].page);
- cnt = 1 << mem->arr[i].order;
- while (sz && cnt) {
- addr = base + PAGE_SIZE * --cnt;
- if (last_addr && last_addr + PAGE_SIZE == addr)
- continue;
- last_addr = addr;
- len = PAGE_SIZE;
- if (len > max_seg_sz)
- len = max_seg_sz;
- if (len > sz)
- len = sz;
- if (sg)
- sg = sg_next(sg);
- else
- sg = sglist;
- if (!sg)
- return -EINVAL;
- sg_set_page(sg, virt_to_page(addr), len, 0);
- sz -= len;
- *sg_len += 1;
- }
- if (i == 0)
- i = mem->cnt;
- }
-
- if (sg)
- sg_mark_end(sg);
-
- return 0;
-}
-
-/*
- * Calculate transfer rate in bytes per second.
- */
-static unsigned int mmc_test_rate(uint64_t bytes, struct timespec *ts)
-{
- uint64_t ns;
-
- ns = ts->tv_sec;
- ns *= 1000000000;
- ns += ts->tv_nsec;
-
- bytes *= 1000000000;
-
- while (ns > UINT_MAX) {
- bytes >>= 1;
- ns >>= 1;
- }
-
- if (!ns)
- return 0;
-
- do_div(bytes, (uint32_t)ns);
-
- return bytes;
-}
-
-/*
- * Save transfer results for future usage
- */
-static void mmc_test_save_transfer_result(struct mmc_test_card *test,
- unsigned int count, unsigned int sectors, struct timespec ts,
- unsigned int rate, unsigned int iops)
-{
- struct mmc_test_transfer_result *tr;
-
- if (!test->gr)
- return;
-
- tr = kmalloc(sizeof(struct mmc_test_transfer_result), GFP_KERNEL);
- if (!tr)
- return;
-
- tr->count = count;
- tr->sectors = sectors;
- tr->ts = ts;
- tr->rate = rate;
- tr->iops = iops;
-
- list_add_tail(&tr->link, &test->gr->tr_lst);
-}
-
-/*
- * Print the transfer rate.
- */
-static void mmc_test_print_rate(struct mmc_test_card *test, uint64_t bytes,
- struct timespec *ts1, struct timespec *ts2)
-{
- unsigned int rate, iops, sectors = bytes >> 9;
- struct timespec ts;
-
- ts = timespec_sub(*ts2, *ts1);
-
- rate = mmc_test_rate(bytes, &ts);
- iops = mmc_test_rate(100, &ts); /* I/O ops per sec x 100 */
-
- pr_info("%s: Transfer of %u sectors (%u%s KiB) took %lu.%09lu "
- "seconds (%u kB/s, %u KiB/s, %u.%02u IOPS)\n",
- mmc_hostname(test->card->host), sectors, sectors >> 1,
- (sectors & 1 ? ".5" : ""), (unsigned long)ts.tv_sec,
- (unsigned long)ts.tv_nsec, rate / 1000, rate / 1024,
- iops / 100, iops % 100);
-
- mmc_test_save_transfer_result(test, 1, sectors, ts, rate, iops);
-}
-
-/*
- * Print the average transfer rate.
- */
-static void mmc_test_print_avg_rate(struct mmc_test_card *test, uint64_t bytes,
- unsigned int count, struct timespec *ts1,
- struct timespec *ts2)
-{
- unsigned int rate, iops, sectors = bytes >> 9;
- uint64_t tot = bytes * count;
- struct timespec ts;
-
- ts = timespec_sub(*ts2, *ts1);
-
- rate = mmc_test_rate(tot, &ts);
- iops = mmc_test_rate(count * 100, &ts); /* I/O ops per sec x 100 */
-
- pr_info("%s: Transfer of %u x %u sectors (%u x %u%s KiB) took "
- "%lu.%09lu seconds (%u kB/s, %u KiB/s, "
- "%u.%02u IOPS, sg_len %d)\n",
- mmc_hostname(test->card->host), count, sectors, count,
- sectors >> 1, (sectors & 1 ? ".5" : ""),
- (unsigned long)ts.tv_sec, (unsigned long)ts.tv_nsec,
- rate / 1000, rate / 1024, iops / 100, iops % 100,
- test->area.sg_len);
-
- mmc_test_save_transfer_result(test, count, sectors, ts, rate, iops);
-}
-
-/*
- * Return the card size in sectors.
- */
-static unsigned int mmc_test_capacity(struct mmc_card *card)
-{
- if (!mmc_card_sd(card) && mmc_card_blockaddr(card))
- return card->ext_csd.sectors;
- else
- return card->csd.capacity << (card->csd.read_blkbits - 9);
-}
-
-/*******************************************************************/
-/* Test preparation and cleanup */
-/*******************************************************************/
-
-/*
- * Fill the first couple of sectors of the card with known data
- * so that bad reads/writes can be detected
- */
-static int __mmc_test_prepare(struct mmc_test_card *test, int write)
-{
- int ret, i;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- if (write)
- memset(test->buffer, 0xDF, 512);
- else {
- for (i = 0;i < 512;i++)
- test->buffer[i] = i;
- }
-
- for (i = 0;i < BUFFER_SIZE / 512;i++) {
- ret = mmc_test_buffer_transfer(test, test->buffer, i, 512, 1);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_prepare_write(struct mmc_test_card *test)
-{
- return __mmc_test_prepare(test, 1);
-}
-
-static int mmc_test_prepare_read(struct mmc_test_card *test)
-{
- return __mmc_test_prepare(test, 0);
-}
-
-static int mmc_test_cleanup(struct mmc_test_card *test)
-{
- int ret, i;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- memset(test->buffer, 0, 512);
-
- for (i = 0;i < BUFFER_SIZE / 512;i++) {
- ret = mmc_test_buffer_transfer(test, test->buffer, i, 512, 1);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-/*******************************************************************/
-/* Test execution helpers */
-/*******************************************************************/
-
-/*
- * Modifies the mmc_request to perform the "short transfer" tests
- */
-static void mmc_test_prepare_broken_mrq(struct mmc_test_card *test,
- struct mmc_request *mrq, int write)
-{
- if (WARN_ON(!mrq || !mrq->cmd || !mrq->data))
- return;
-
- if (mrq->data->blocks > 1) {
- mrq->cmd->opcode = write ?
- MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
- mrq->stop = NULL;
- } else {
- mrq->cmd->opcode = MMC_SEND_STATUS;
- mrq->cmd->arg = test->card->rca << 16;
- }
-}
-
-/*
- * Checks that a normal transfer didn't have any errors
- */
-static int mmc_test_check_result(struct mmc_test_card *test,
- struct mmc_request *mrq)
-{
- int ret;
-
- if (WARN_ON(!mrq || !mrq->cmd || !mrq->data))
- return -EINVAL;
-
- ret = 0;
-
- if (mrq->sbc && mrq->sbc->error)
- ret = mrq->sbc->error;
- if (!ret && mrq->cmd->error)
- ret = mrq->cmd->error;
- if (!ret && mrq->data->error)
- ret = mrq->data->error;
- if (!ret && mrq->stop && mrq->stop->error)
- ret = mrq->stop->error;
- if (!ret && mrq->data->bytes_xfered !=
- mrq->data->blocks * mrq->data->blksz)
- ret = RESULT_FAIL;
-
- if (ret == -EINVAL)
- ret = RESULT_UNSUP_HOST;
-
- return ret;
-}
-
-static enum mmc_blk_status mmc_test_check_result_async(struct mmc_card *card,
- struct mmc_async_req *areq)
-{
- struct mmc_test_async_req *test_async =
- container_of(areq, struct mmc_test_async_req, areq);
- int ret;
-
- mmc_test_wait_busy(test_async->test);
-
- /*
- * FIXME: this would earlier just casts a regular error code,
- * either of the kernel type -ERRORCODE or the local test framework
- * RESULT_* errorcode, into an enum mmc_blk_status and return as
- * result check. Instead, convert it to some reasonable type by just
- * returning either MMC_BLK_SUCCESS or MMC_BLK_CMD_ERR.
- * If possible, a reasonable error code should be returned.
- */
- ret = mmc_test_check_result(test_async->test, areq->mrq);
- if (ret)
- return MMC_BLK_CMD_ERR;
-
- return MMC_BLK_SUCCESS;
-}
-
-/*
- * Checks that a "short transfer" behaved as expected
- */
-static int mmc_test_check_broken_result(struct mmc_test_card *test,
- struct mmc_request *mrq)
-{
- int ret;
-
- if (WARN_ON(!mrq || !mrq->cmd || !mrq->data))
- return -EINVAL;
-
- ret = 0;
-
- if (!ret && mrq->cmd->error)
- ret = mrq->cmd->error;
- if (!ret && mrq->data->error == 0)
- ret = RESULT_FAIL;
- if (!ret && mrq->data->error != -ETIMEDOUT)
- ret = mrq->data->error;
- if (!ret && mrq->stop && mrq->stop->error)
- ret = mrq->stop->error;
- if (mrq->data->blocks > 1) {
- if (!ret && mrq->data->bytes_xfered > mrq->data->blksz)
- ret = RESULT_FAIL;
- } else {
- if (!ret && mrq->data->bytes_xfered > 0)
- ret = RESULT_FAIL;
- }
-
- if (ret == -EINVAL)
- ret = RESULT_UNSUP_HOST;
-
- return ret;
-}
-
-/*
- * Tests nonblock transfer with certain parameters
- */
-static void mmc_test_nonblock_reset(struct mmc_request *mrq,
- struct mmc_command *cmd,
- struct mmc_command *stop,
- struct mmc_data *data)
-{
- memset(mrq, 0, sizeof(struct mmc_request));
- memset(cmd, 0, sizeof(struct mmc_command));
- memset(data, 0, sizeof(struct mmc_data));
- memset(stop, 0, sizeof(struct mmc_command));
-
- mrq->cmd = cmd;
- mrq->data = data;
- mrq->stop = stop;
-}
-static int mmc_test_nonblock_transfer(struct mmc_test_card *test,
- struct scatterlist *sg, unsigned sg_len,
- unsigned dev_addr, unsigned blocks,
- unsigned blksz, int write, int count)
-{
- struct mmc_request mrq1;
- struct mmc_command cmd1;
- struct mmc_command stop1;
- struct mmc_data data1;
-
- struct mmc_request mrq2;
- struct mmc_command cmd2;
- struct mmc_command stop2;
- struct mmc_data data2;
-
- struct mmc_test_async_req test_areq[2];
- 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;
- enum mmc_blk_status status;
- 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);
-
- cur_areq->mrq = &mrq1;
- cur_areq->err_check = mmc_test_check_result_async;
- other_areq->mrq = &mrq2;
- other_areq->err_check = mmc_test_check_result_async;
-
- for (i = 0; i < count; i++) {
- mmc_test_prepare_mrq(test, cur_areq->mrq, sg, sg_len, dev_addr,
- blocks, blksz, write);
- done_areq = mmc_start_req(test->card->host, cur_areq, &status);
-
- if (status != MMC_BLK_SUCCESS || (!done_areq && i > 0)) {
- ret = RESULT_FAIL;
- goto err;
- }
-
- if (done_areq) {
- if (done_areq->mrq == &mrq2)
- mmc_test_nonblock_reset(&mrq2, &cmd2,
- &stop2, &data2);
- else
- mmc_test_nonblock_reset(&mrq1, &cmd1,
- &stop1, &data1);
- }
- swap(cur_areq, other_areq);
- dev_addr += blocks;
- }
-
- done_areq = mmc_start_req(test->card->host, NULL, &status);
- if (status != MMC_BLK_SUCCESS)
- ret = RESULT_FAIL;
-
- return ret;
-err:
- return ret;
-}
-
-/*
- * Tests a basic transfer with certain parameters
- */
-static int mmc_test_simple_transfer(struct mmc_test_card *test,
- struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
- unsigned blocks, unsigned blksz, int write)
-{
- struct mmc_request mrq = {0};
- struct mmc_command cmd = {0};
- struct mmc_command stop = {0};
- struct mmc_data data = {0};
-
- mrq.cmd = &cmd;
- mrq.data = &data;
- mrq.stop = &stop;
-
- mmc_test_prepare_mrq(test, &mrq, sg, sg_len, dev_addr,
- blocks, blksz, write);
-
- mmc_wait_for_req(test->card->host, &mrq);
-
- mmc_test_wait_busy(test);
-
- return mmc_test_check_result(test, &mrq);
-}
-
-/*
- * Tests a transfer where the card will fail completely or partly
- */
-static int mmc_test_broken_transfer(struct mmc_test_card *test,
- unsigned blocks, unsigned blksz, int write)
-{
- struct mmc_request mrq = {0};
- struct mmc_command cmd = {0};
- struct mmc_command stop = {0};
- struct mmc_data data = {0};
-
- struct scatterlist sg;
-
- mrq.cmd = &cmd;
- mrq.data = &data;
- mrq.stop = &stop;
-
- sg_init_one(&sg, test->buffer, blocks * blksz);
-
- mmc_test_prepare_mrq(test, &mrq, &sg, 1, 0, blocks, blksz, write);
- mmc_test_prepare_broken_mrq(test, &mrq, write);
-
- mmc_wait_for_req(test->card->host, &mrq);
-
- mmc_test_wait_busy(test);
-
- return mmc_test_check_broken_result(test, &mrq);
-}
-
-/*
- * Does a complete transfer test where data is also validated
- *
- * Note: mmc_test_prepare() must have been done before this call
- */
-static int mmc_test_transfer(struct mmc_test_card *test,
- struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
- unsigned blocks, unsigned blksz, int write)
-{
- int ret, i;
- unsigned long flags;
-
- if (write) {
- for (i = 0;i < blocks * blksz;i++)
- test->scratch[i] = i;
- } else {
- memset(test->scratch, 0, BUFFER_SIZE);
- }
- local_irq_save(flags);
- sg_copy_from_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
- local_irq_restore(flags);
-
- ret = mmc_test_set_blksize(test, blksz);
- if (ret)
- return ret;
-
- ret = mmc_test_simple_transfer(test, sg, sg_len, dev_addr,
- blocks, blksz, write);
- if (ret)
- return ret;
-
- if (write) {
- int sectors;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- sectors = (blocks * blksz + 511) / 512;
- if ((sectors * 512) == (blocks * blksz))
- sectors++;
-
- if ((sectors * 512) > BUFFER_SIZE)
- return -EINVAL;
-
- memset(test->buffer, 0, sectors * 512);
-
- for (i = 0;i < sectors;i++) {
- ret = mmc_test_buffer_transfer(test,
- test->buffer + i * 512,
- dev_addr + i, 512, 0);
- if (ret)
- return ret;
- }
-
- for (i = 0;i < blocks * blksz;i++) {
- if (test->buffer[i] != (u8)i)
- return RESULT_FAIL;
- }
-
- for (;i < sectors * 512;i++) {
- if (test->buffer[i] != 0xDF)
- return RESULT_FAIL;
- }
- } else {
- local_irq_save(flags);
- sg_copy_to_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
- local_irq_restore(flags);
- for (i = 0;i < blocks * blksz;i++) {
- if (test->scratch[i] != (u8)i)
- return RESULT_FAIL;
- }
- }
-
- return 0;
-}
-
-/*******************************************************************/
-/* Tests */
-/*******************************************************************/
-
-struct mmc_test_case {
- const char *name;
-
- int (*prepare)(struct mmc_test_card *);
- int (*run)(struct mmc_test_card *);
- int (*cleanup)(struct mmc_test_card *);
-};
-
-static int mmc_test_basic_write(struct mmc_test_card *test)
-{
- int ret;
- struct scatterlist sg;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- sg_init_one(&sg, test->buffer, 512);
-
- return mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 1);
-}
-
-static int mmc_test_basic_read(struct mmc_test_card *test)
-{
- int ret;
- struct scatterlist sg;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- sg_init_one(&sg, test->buffer, 512);
-
- return mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 0);
-}
-
-static int mmc_test_verify_write(struct mmc_test_card *test)
-{
- struct scatterlist sg;
-
- sg_init_one(&sg, test->buffer, 512);
-
- return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
-}
-
-static int mmc_test_verify_read(struct mmc_test_card *test)
-{
- struct scatterlist sg;
-
- sg_init_one(&sg, test->buffer, 512);
-
- return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
-}
-
-static int mmc_test_multi_write(struct mmc_test_card *test)
-{
- unsigned int size;
- struct scatterlist sg;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- size = PAGE_SIZE * 2;
- size = min(size, test->card->host->max_req_size);
- size = min(size, test->card->host->max_seg_size);
- size = min(size, test->card->host->max_blk_count * 512);
-
- if (size < 1024)
- return RESULT_UNSUP_HOST;
-
- sg_init_one(&sg, test->buffer, size);
-
- return mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
-}
-
-static int mmc_test_multi_read(struct mmc_test_card *test)
-{
- unsigned int size;
- struct scatterlist sg;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- size = PAGE_SIZE * 2;
- size = min(size, test->card->host->max_req_size);
- size = min(size, test->card->host->max_seg_size);
- size = min(size, test->card->host->max_blk_count * 512);
-
- if (size < 1024)
- return RESULT_UNSUP_HOST;
-
- sg_init_one(&sg, test->buffer, size);
-
- return mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
-}
-
-static int mmc_test_pow2_write(struct mmc_test_card *test)
-{
- int ret, i;
- struct scatterlist sg;
-
- if (!test->card->csd.write_partial)
- return RESULT_UNSUP_CARD;
-
- for (i = 1; i < 512;i <<= 1) {
- sg_init_one(&sg, test->buffer, i);
- ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_pow2_read(struct mmc_test_card *test)
-{
- int ret, i;
- struct scatterlist sg;
-
- if (!test->card->csd.read_partial)
- return RESULT_UNSUP_CARD;
-
- for (i = 1; i < 512;i <<= 1) {
- sg_init_one(&sg, test->buffer, i);
- ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_weird_write(struct mmc_test_card *test)
-{
- int ret, i;
- struct scatterlist sg;
-
- if (!test->card->csd.write_partial)
- return RESULT_UNSUP_CARD;
-
- for (i = 3; i < 512;i += 7) {
- sg_init_one(&sg, test->buffer, i);
- ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_weird_read(struct mmc_test_card *test)
-{
- int ret, i;
- struct scatterlist sg;
-
- if (!test->card->csd.read_partial)
- return RESULT_UNSUP_CARD;
-
- for (i = 3; i < 512;i += 7) {
- sg_init_one(&sg, test->buffer, i);
- ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_align_write(struct mmc_test_card *test)
-{
- int ret, i;
- struct scatterlist sg;
-
- for (i = 1; i < TEST_ALIGN_END; i++) {
- sg_init_one(&sg, test->buffer + i, 512);
- ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_align_read(struct mmc_test_card *test)
-{
- int ret, i;
- struct scatterlist sg;
-
- for (i = 1; i < TEST_ALIGN_END; i++) {
- sg_init_one(&sg, test->buffer + i, 512);
- ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_align_multi_write(struct mmc_test_card *test)
-{
- int ret, i;
- unsigned int size;
- struct scatterlist sg;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- size = PAGE_SIZE * 2;
- size = min(size, test->card->host->max_req_size);
- size = min(size, test->card->host->max_seg_size);
- size = min(size, test->card->host->max_blk_count * 512);
-
- if (size < 1024)
- return RESULT_UNSUP_HOST;
-
- for (i = 1; i < TEST_ALIGN_END; i++) {
- sg_init_one(&sg, test->buffer + i, size);
- ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_align_multi_read(struct mmc_test_card *test)
-{
- int ret, i;
- unsigned int size;
- struct scatterlist sg;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- size = PAGE_SIZE * 2;
- size = min(size, test->card->host->max_req_size);
- size = min(size, test->card->host->max_seg_size);
- size = min(size, test->card->host->max_blk_count * 512);
-
- if (size < 1024)
- return RESULT_UNSUP_HOST;
-
- for (i = 1; i < TEST_ALIGN_END; i++) {
- sg_init_one(&sg, test->buffer + i, size);
- ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static int mmc_test_xfersize_write(struct mmc_test_card *test)
-{
- int ret;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- return mmc_test_broken_transfer(test, 1, 512, 1);
-}
-
-static int mmc_test_xfersize_read(struct mmc_test_card *test)
-{
- int ret;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- return mmc_test_broken_transfer(test, 1, 512, 0);
-}
-
-static int mmc_test_multi_xfersize_write(struct mmc_test_card *test)
-{
- int ret;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- return mmc_test_broken_transfer(test, 2, 512, 1);
-}
-
-static int mmc_test_multi_xfersize_read(struct mmc_test_card *test)
-{
- int ret;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- return mmc_test_broken_transfer(test, 2, 512, 0);
-}
-
-#ifdef CONFIG_HIGHMEM
-
-static int mmc_test_write_high(struct mmc_test_card *test)
-{
- struct scatterlist sg;
-
- sg_init_table(&sg, 1);
- sg_set_page(&sg, test->highmem, 512, 0);
-
- return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
-}
-
-static int mmc_test_read_high(struct mmc_test_card *test)
-{
- struct scatterlist sg;
-
- sg_init_table(&sg, 1);
- sg_set_page(&sg, test->highmem, 512, 0);
-
- return mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
-}
-
-static int mmc_test_multi_write_high(struct mmc_test_card *test)
-{
- unsigned int size;
- struct scatterlist sg;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- size = PAGE_SIZE * 2;
- size = min(size, test->card->host->max_req_size);
- size = min(size, test->card->host->max_seg_size);
- size = min(size, test->card->host->max_blk_count * 512);
-
- if (size < 1024)
- return RESULT_UNSUP_HOST;
-
- sg_init_table(&sg, 1);
- sg_set_page(&sg, test->highmem, size, 0);
-
- return mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
-}
-
-static int mmc_test_multi_read_high(struct mmc_test_card *test)
-{
- unsigned int size;
- struct scatterlist sg;
-
- if (test->card->host->max_blk_count == 1)
- return RESULT_UNSUP_HOST;
-
- size = PAGE_SIZE * 2;
- size = min(size, test->card->host->max_req_size);
- size = min(size, test->card->host->max_seg_size);
- size = min(size, test->card->host->max_blk_count * 512);
-
- if (size < 1024)
- return RESULT_UNSUP_HOST;
-
- sg_init_table(&sg, 1);
- sg_set_page(&sg, test->highmem, size, 0);
-
- return mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
-}
-
-#else
-
-static int mmc_test_no_highmem(struct mmc_test_card *test)
-{
- pr_info("%s: Highmem not configured - test skipped\n",
- mmc_hostname(test->card->host));
- return 0;
-}
-
-#endif /* CONFIG_HIGHMEM */
-
-/*
- * Map sz bytes so that it can be transferred.
- */
-static int mmc_test_area_map(struct mmc_test_card *test, unsigned long sz,
- int max_scatter, int min_sg_len)
-{
- struct mmc_test_area *t = &test->area;
- int err;
-
- t->blocks = sz >> 9;
-
- if (max_scatter) {
- err = mmc_test_map_sg_max_scatter(t->mem, sz, t->sg,
- t->max_segs, t->max_seg_sz,
- &t->sg_len);
- } else {
- err = mmc_test_map_sg(t->mem, sz, t->sg, 1, t->max_segs,
- t->max_seg_sz, &t->sg_len, min_sg_len);
- }
- if (err)
- pr_info("%s: Failed to map sg list\n",
- mmc_hostname(test->card->host));
- return err;
-}
-
-/*
- * Transfer bytes mapped by mmc_test_area_map().
- */
-static int mmc_test_area_transfer(struct mmc_test_card *test,
- unsigned int dev_addr, int write)
-{
- struct mmc_test_area *t = &test->area;
-
- return mmc_test_simple_transfer(test, t->sg, t->sg_len, dev_addr,
- t->blocks, 512, write);
-}
-
-/*
- * Map and transfer bytes for multiple transfers.
- */
-static int mmc_test_area_io_seq(struct mmc_test_card *test, unsigned long sz,
- unsigned int dev_addr, int write,
- int max_scatter, int timed, int count,
- bool nonblock, int min_sg_len)
-{
- struct timespec ts1, ts2;
- int ret = 0;
- int i;
- struct mmc_test_area *t = &test->area;
-
- /*
- * In the case of a maximally scattered transfer, the maximum transfer
- * size is further limited by using PAGE_SIZE segments.
- */
- if (max_scatter) {
- struct mmc_test_area *t = &test->area;
- unsigned long max_tfr;
-
- if (t->max_seg_sz >= PAGE_SIZE)
- max_tfr = t->max_segs * PAGE_SIZE;
- else
- max_tfr = t->max_segs * t->max_seg_sz;
- if (sz > max_tfr)
- sz = max_tfr;
- }
-
- ret = mmc_test_area_map(test, sz, max_scatter, min_sg_len);
- if (ret)
- return ret;
-
- if (timed)
- getnstimeofday(&ts1);
- if (nonblock)
- ret = mmc_test_nonblock_transfer(test, t->sg, t->sg_len,
- dev_addr, t->blocks, 512, write, count);
- else
- for (i = 0; i < count && ret == 0; i++) {
- ret = mmc_test_area_transfer(test, dev_addr, write);
- dev_addr += sz >> 9;
- }
-
- if (ret)
- return ret;
-
- if (timed)
- getnstimeofday(&ts2);
-
- if (timed)
- mmc_test_print_avg_rate(test, sz, count, &ts1, &ts2);
-
- return 0;
-}
-
-static int mmc_test_area_io(struct mmc_test_card *test, unsigned long sz,
- unsigned int dev_addr, int write, int max_scatter,
- int timed)
-{
- return mmc_test_area_io_seq(test, sz, dev_addr, write, max_scatter,
- timed, 1, false, 0);
-}
-
-/*
- * Write the test area entirely.
- */
-static int mmc_test_area_fill(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
-
- return mmc_test_area_io(test, t->max_tfr, t->dev_addr, 1, 0, 0);
-}
-
-/*
- * Erase the test area entirely.
- */
-static int mmc_test_area_erase(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
-
- if (!mmc_can_erase(test->card))
- return 0;
-
- return mmc_erase(test->card, t->dev_addr, t->max_sz >> 9,
- MMC_ERASE_ARG);
-}
-
-/*
- * Cleanup struct mmc_test_area.
- */
-static int mmc_test_area_cleanup(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
-
- kfree(t->sg);
- mmc_test_free_mem(t->mem);
-
- return 0;
-}
-
-/*
- * Initialize an area for testing large transfers. The test area is set to the
- * middle of the card because cards may have different charateristics at the
- * front (for FAT file system optimization). Optionally, the area is erased
- * (if the card supports it) which may improve write performance. Optionally,
- * the area is filled with data for subsequent read tests.
- */
-static int mmc_test_area_init(struct mmc_test_card *test, int erase, int fill)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long min_sz = 64 * 1024, sz;
- int ret;
-
- ret = mmc_test_set_blksize(test, 512);
- if (ret)
- return ret;
-
- /* Make the test area size about 4MiB */
- sz = (unsigned long)test->card->pref_erase << 9;
- t->max_sz = sz;
- while (t->max_sz < 4 * 1024 * 1024)
- t->max_sz += sz;
- while (t->max_sz > TEST_AREA_MAX_SIZE && t->max_sz > sz)
- t->max_sz -= sz;
-
- t->max_segs = test->card->host->max_segs;
- t->max_seg_sz = test->card->host->max_seg_size;
- t->max_seg_sz -= t->max_seg_sz % 512;
-
- t->max_tfr = t->max_sz;
- if (t->max_tfr >> 9 > test->card->host->max_blk_count)
- t->max_tfr = test->card->host->max_blk_count << 9;
- if (t->max_tfr > test->card->host->max_req_size)
- t->max_tfr = test->card->host->max_req_size;
- if (t->max_tfr / t->max_seg_sz > t->max_segs)
- t->max_tfr = t->max_segs * t->max_seg_sz;
-
- /*
- * Try to allocate enough memory for a max. sized transfer. Less is OK
- * because the same memory can be mapped into the scatterlist more than
- * once. Also, take into account the limits imposed on scatterlist
- * segments by the host driver.
- */
- t->mem = mmc_test_alloc_mem(min_sz, t->max_tfr, t->max_segs,
- t->max_seg_sz);
- if (!t->mem)
- return -ENOMEM;
-
- t->sg = kmalloc(sizeof(struct scatterlist) * t->max_segs, GFP_KERNEL);
- if (!t->sg) {
- ret = -ENOMEM;
- goto out_free;
- }
-
- t->dev_addr = mmc_test_capacity(test->card) / 2;
- t->dev_addr -= t->dev_addr % (t->max_sz >> 9);
-
- if (erase) {
- ret = mmc_test_area_erase(test);
- if (ret)
- goto out_free;
- }
-
- if (fill) {
- ret = mmc_test_area_fill(test);
- if (ret)
- goto out_free;
- }
-
- return 0;
-
-out_free:
- mmc_test_area_cleanup(test);
- return ret;
-}
-
-/*
- * Prepare for large transfers. Do not erase the test area.
- */
-static int mmc_test_area_prepare(struct mmc_test_card *test)
-{
- return mmc_test_area_init(test, 0, 0);
-}
-
-/*
- * Prepare for large transfers. Do erase the test area.
- */
-static int mmc_test_area_prepare_erase(struct mmc_test_card *test)
-{
- return mmc_test_area_init(test, 1, 0);
-}
-
-/*
- * Prepare for large transfers. Erase and fill the test area.
- */
-static int mmc_test_area_prepare_fill(struct mmc_test_card *test)
-{
- return mmc_test_area_init(test, 1, 1);
-}
-
-/*
- * Test best-case performance. Best-case performance is expected from
- * a single large transfer.
- *
- * An additional option (max_scatter) allows the measurement of the same
- * transfer but with no contiguous pages in the scatter list. This tests
- * the efficiency of DMA to handle scattered pages.
- */
-static int mmc_test_best_performance(struct mmc_test_card *test, int write,
- int max_scatter)
-{
- struct mmc_test_area *t = &test->area;
-
- return mmc_test_area_io(test, t->max_tfr, t->dev_addr, write,
- max_scatter, 1);
-}
-
-/*
- * Best-case read performance.
- */
-static int mmc_test_best_read_performance(struct mmc_test_card *test)
-{
- return mmc_test_best_performance(test, 0, 0);
-}
-
-/*
- * Best-case write performance.
- */
-static int mmc_test_best_write_performance(struct mmc_test_card *test)
-{
- return mmc_test_best_performance(test, 1, 0);
-}
-
-/*
- * Best-case read performance into scattered pages.
- */
-static int mmc_test_best_read_perf_max_scatter(struct mmc_test_card *test)
-{
- return mmc_test_best_performance(test, 0, 1);
-}
-
-/*
- * Best-case write performance from scattered pages.
- */
-static int mmc_test_best_write_perf_max_scatter(struct mmc_test_card *test)
-{
- return mmc_test_best_performance(test, 1, 1);
-}
-
-/*
- * Single read performance by transfer size.
- */
-static int mmc_test_profile_read_perf(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long sz;
- unsigned int dev_addr;
- int ret;
-
- for (sz = 512; sz < t->max_tfr; sz <<= 1) {
- dev_addr = t->dev_addr + (sz >> 9);
- ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
- if (ret)
- return ret;
- }
- sz = t->max_tfr;
- dev_addr = t->dev_addr;
- return mmc_test_area_io(test, sz, dev_addr, 0, 0, 1);
-}
-
-/*
- * Single write performance by transfer size.
- */
-static int mmc_test_profile_write_perf(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long sz;
- unsigned int dev_addr;
- int ret;
-
- ret = mmc_test_area_erase(test);
- if (ret)
- return ret;
- for (sz = 512; sz < t->max_tfr; sz <<= 1) {
- dev_addr = t->dev_addr + (sz >> 9);
- ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
- if (ret)
- return ret;
- }
- ret = mmc_test_area_erase(test);
- if (ret)
- return ret;
- sz = t->max_tfr;
- dev_addr = t->dev_addr;
- return mmc_test_area_io(test, sz, dev_addr, 1, 0, 1);
-}
-
-/*
- * Single trim performance by transfer size.
- */
-static int mmc_test_profile_trim_perf(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long sz;
- unsigned int dev_addr;
- struct timespec ts1, ts2;
- int ret;
-
- if (!mmc_can_trim(test->card))
- return RESULT_UNSUP_CARD;
-
- if (!mmc_can_erase(test->card))
- return RESULT_UNSUP_HOST;
-
- for (sz = 512; sz < t->max_sz; sz <<= 1) {
- dev_addr = t->dev_addr + (sz >> 9);
- getnstimeofday(&ts1);
- ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
- if (ret)
- return ret;
- getnstimeofday(&ts2);
- mmc_test_print_rate(test, sz, &ts1, &ts2);
- }
- dev_addr = t->dev_addr;
- getnstimeofday(&ts1);
- ret = mmc_erase(test->card, dev_addr, sz >> 9, MMC_TRIM_ARG);
- if (ret)
- return ret;
- getnstimeofday(&ts2);
- mmc_test_print_rate(test, sz, &ts1, &ts2);
- return 0;
-}
-
-static int mmc_test_seq_read_perf(struct mmc_test_card *test, unsigned long sz)
-{
- struct mmc_test_area *t = &test->area;
- unsigned int dev_addr, i, cnt;
- struct timespec ts1, ts2;
- int ret;
-
- cnt = t->max_sz / sz;
- dev_addr = t->dev_addr;
- getnstimeofday(&ts1);
- for (i = 0; i < cnt; i++) {
- ret = mmc_test_area_io(test, sz, dev_addr, 0, 0, 0);
- if (ret)
- return ret;
- dev_addr += (sz >> 9);
- }
- getnstimeofday(&ts2);
- mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
- return 0;
-}
-
-/*
- * Consecutive read performance by transfer size.
- */
-static int mmc_test_profile_seq_read_perf(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long sz;
- int ret;
-
- for (sz = 512; sz < t->max_tfr; sz <<= 1) {
- ret = mmc_test_seq_read_perf(test, sz);
- if (ret)
- return ret;
- }
- sz = t->max_tfr;
- return mmc_test_seq_read_perf(test, sz);
-}
-
-static int mmc_test_seq_write_perf(struct mmc_test_card *test, unsigned long sz)
-{
- struct mmc_test_area *t = &test->area;
- unsigned int dev_addr, i, cnt;
- struct timespec ts1, ts2;
- int ret;
-
- ret = mmc_test_area_erase(test);
- if (ret)
- return ret;
- cnt = t->max_sz / sz;
- dev_addr = t->dev_addr;
- getnstimeofday(&ts1);
- for (i = 0; i < cnt; i++) {
- ret = mmc_test_area_io(test, sz, dev_addr, 1, 0, 0);
- if (ret)
- return ret;
- dev_addr += (sz >> 9);
- }
- getnstimeofday(&ts2);
- mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
- return 0;
-}
-
-/*
- * Consecutive write performance by transfer size.
- */
-static int mmc_test_profile_seq_write_perf(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long sz;
- int ret;
-
- for (sz = 512; sz < t->max_tfr; sz <<= 1) {
- ret = mmc_test_seq_write_perf(test, sz);
- if (ret)
- return ret;
- }
- sz = t->max_tfr;
- return mmc_test_seq_write_perf(test, sz);
-}
-
-/*
- * Consecutive trim performance by transfer size.
- */
-static int mmc_test_profile_seq_trim_perf(struct mmc_test_card *test)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long sz;
- unsigned int dev_addr, i, cnt;
- struct timespec ts1, ts2;
- int ret;
-
- if (!mmc_can_trim(test->card))
- return RESULT_UNSUP_CARD;
-
- if (!mmc_can_erase(test->card))
- return RESULT_UNSUP_HOST;
-
- for (sz = 512; sz <= t->max_sz; sz <<= 1) {
- ret = mmc_test_area_erase(test);
- if (ret)
- return ret;
- ret = mmc_test_area_fill(test);
- if (ret)
- return ret;
- cnt = t->max_sz / sz;
- dev_addr = t->dev_addr;
- getnstimeofday(&ts1);
- for (i = 0; i < cnt; i++) {
- ret = mmc_erase(test->card, dev_addr, sz >> 9,
- MMC_TRIM_ARG);
- if (ret)
- return ret;
- dev_addr += (sz >> 9);
- }
- getnstimeofday(&ts2);
- mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
- }
- return 0;
-}
-
-static unsigned int rnd_next = 1;
-
-static unsigned int mmc_test_rnd_num(unsigned int rnd_cnt)
-{
- uint64_t r;
-
- rnd_next = rnd_next * 1103515245 + 12345;
- r = (rnd_next >> 16) & 0x7fff;
- return (r * rnd_cnt) >> 15;
-}
-
-static int mmc_test_rnd_perf(struct mmc_test_card *test, int write, int print,
- unsigned long sz)
-{
- unsigned int dev_addr, cnt, rnd_addr, range1, range2, last_ea = 0, ea;
- unsigned int ssz;
- struct timespec ts1, ts2, ts;
- int ret;
-
- ssz = sz >> 9;
-
- rnd_addr = mmc_test_capacity(test->card) / 4;
- range1 = rnd_addr / test->card->pref_erase;
- range2 = range1 / ssz;
-
- getnstimeofday(&ts1);
- for (cnt = 0; cnt < UINT_MAX; cnt++) {
- getnstimeofday(&ts2);
- ts = timespec_sub(ts2, ts1);
- if (ts.tv_sec >= 10)
- break;
- ea = mmc_test_rnd_num(range1);
- if (ea == last_ea)
- ea -= 1;
- last_ea = ea;
- dev_addr = rnd_addr + test->card->pref_erase * ea +
- ssz * mmc_test_rnd_num(range2);
- ret = mmc_test_area_io(test, sz, dev_addr, write, 0, 0);
- if (ret)
- return ret;
- }
- if (print)
- mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
- return 0;
-}
-
-static int mmc_test_random_perf(struct mmc_test_card *test, int write)
-{
- struct mmc_test_area *t = &test->area;
- unsigned int next;
- unsigned long sz;
- int ret;
-
- for (sz = 512; sz < t->max_tfr; sz <<= 1) {
- /*
- * When writing, try to get more consistent results by running
- * the test twice with exactly the same I/O but outputting the
- * results only for the 2nd run.
- */
- if (write) {
- next = rnd_next;
- ret = mmc_test_rnd_perf(test, write, 0, sz);
- if (ret)
- return ret;
- rnd_next = next;
- }
- ret = mmc_test_rnd_perf(test, write, 1, sz);
- if (ret)
- return ret;
- }
- sz = t->max_tfr;
- if (write) {
- next = rnd_next;
- ret = mmc_test_rnd_perf(test, write, 0, sz);
- if (ret)
- return ret;
- rnd_next = next;
- }
- return mmc_test_rnd_perf(test, write, 1, sz);
-}
-
-/*
- * Random read performance by transfer size.
- */
-static int mmc_test_random_read_perf(struct mmc_test_card *test)
-{
- return mmc_test_random_perf(test, 0);
-}
-
-/*
- * Random write performance by transfer size.
- */
-static int mmc_test_random_write_perf(struct mmc_test_card *test)
-{
- return mmc_test_random_perf(test, 1);
-}
-
-static int mmc_test_seq_perf(struct mmc_test_card *test, int write,
- unsigned int tot_sz, int max_scatter)
-{
- struct mmc_test_area *t = &test->area;
- unsigned int dev_addr, i, cnt, sz, ssz;
- struct timespec ts1, ts2;
- int ret;
-
- sz = t->max_tfr;
-
- /*
- * In the case of a maximally scattered transfer, the maximum transfer
- * size is further limited by using PAGE_SIZE segments.
- */
- if (max_scatter) {
- unsigned long max_tfr;
-
- if (t->max_seg_sz >= PAGE_SIZE)
- max_tfr = t->max_segs * PAGE_SIZE;
- else
- max_tfr = t->max_segs * t->max_seg_sz;
- if (sz > max_tfr)
- sz = max_tfr;
- }
-
- ssz = sz >> 9;
- dev_addr = mmc_test_capacity(test->card) / 4;
- if (tot_sz > dev_addr << 9)
- tot_sz = dev_addr << 9;
- cnt = tot_sz / sz;
- dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
-
- getnstimeofday(&ts1);
- for (i = 0; i < cnt; i++) {
- ret = mmc_test_area_io(test, sz, dev_addr, write,
- max_scatter, 0);
- if (ret)
- return ret;
- dev_addr += ssz;
- }
- getnstimeofday(&ts2);
-
- mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
-
- return 0;
-}
-
-static int mmc_test_large_seq_perf(struct mmc_test_card *test, int write)
-{
- int ret, i;
-
- for (i = 0; i < 10; i++) {
- ret = mmc_test_seq_perf(test, write, 10 * 1024 * 1024, 1);
- if (ret)
- return ret;
- }
- for (i = 0; i < 5; i++) {
- ret = mmc_test_seq_perf(test, write, 100 * 1024 * 1024, 1);
- if (ret)
- return ret;
- }
- for (i = 0; i < 3; i++) {
- ret = mmc_test_seq_perf(test, write, 1000 * 1024 * 1024, 1);
- if (ret)
- return ret;
- }
-
- return ret;
-}
-
-/*
- * Large sequential read performance.
- */
-static int mmc_test_large_seq_read_perf(struct mmc_test_card *test)
-{
- return mmc_test_large_seq_perf(test, 0);
-}
-
-/*
- * Large sequential write performance.
- */
-static int mmc_test_large_seq_write_perf(struct mmc_test_card *test)
-{
- return mmc_test_large_seq_perf(test, 1);
-}
-
-static int mmc_test_rw_multiple(struct mmc_test_card *test,
- struct mmc_test_multiple_rw *tdata,
- unsigned int reqsize, unsigned int size,
- int min_sg_len)
-{
- unsigned int dev_addr;
- struct mmc_test_area *t = &test->area;
- int ret = 0;
-
- /* Set up test area */
- if (size > mmc_test_capacity(test->card) / 2 * 512)
- size = mmc_test_capacity(test->card) / 2 * 512;
- if (reqsize > t->max_tfr)
- reqsize = t->max_tfr;
- dev_addr = mmc_test_capacity(test->card) / 4;
- if ((dev_addr & 0xffff0000))
- dev_addr &= 0xffff0000; /* Round to 64MiB boundary */
- else
- dev_addr &= 0xfffff800; /* Round to 1MiB boundary */
- if (!dev_addr)
- goto err;
-
- if (reqsize > size)
- return 0;
-
- /* prepare test area */
- if (mmc_can_erase(test->card) &&
- tdata->prepare & MMC_TEST_PREP_ERASE) {
- ret = mmc_erase(test->card, dev_addr,
- size / 512, MMC_SECURE_ERASE_ARG);
- if (ret)
- ret = mmc_erase(test->card, dev_addr,
- size / 512, MMC_ERASE_ARG);
- if (ret)
- goto err;
- }
-
- /* Run test */
- ret = mmc_test_area_io_seq(test, reqsize, dev_addr,
- tdata->do_write, 0, 1, size / reqsize,
- tdata->do_nonblock_req, min_sg_len);
- if (ret)
- goto err;
-
- return ret;
- err:
- pr_info("[%s] error\n", __func__);
- return ret;
-}
-
-static int mmc_test_rw_multiple_size(struct mmc_test_card *test,
- struct mmc_test_multiple_rw *rw)
-{
- int ret = 0;
- int i;
- void *pre_req = test->card->host->ops->pre_req;
- void *post_req = test->card->host->ops->post_req;
-
- if (rw->do_nonblock_req &&
- ((!pre_req && post_req) || (pre_req && !post_req))) {
- pr_info("error: only one of pre/post is defined\n");
- return -EINVAL;
- }
-
- for (i = 0 ; i < rw->len && ret == 0; i++) {
- ret = mmc_test_rw_multiple(test, rw, rw->bs[i], rw->size, 0);
- if (ret)
- break;
- }
- return ret;
-}
-
-static int mmc_test_rw_multiple_sg_len(struct mmc_test_card *test,
- struct mmc_test_multiple_rw *rw)
-{
- int ret = 0;
- int i;
-
- for (i = 0 ; i < rw->len && ret == 0; i++) {
- ret = mmc_test_rw_multiple(test, rw, 512*1024, rw->size,
- rw->sg_len[i]);
- if (ret)
- break;
- }
- return ret;
-}
-
-/*
- * Multiple blocking write 4k to 4 MB chunks
- */
-static int mmc_test_profile_mult_write_blocking_perf(struct mmc_test_card *test)
-{
- unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
- 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
- struct mmc_test_multiple_rw test_data = {
- .bs = bs,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(bs),
- .do_write = true,
- .do_nonblock_req = false,
- .prepare = MMC_TEST_PREP_ERASE,
- };
-
- return mmc_test_rw_multiple_size(test, &test_data);
-};
-
-/*
- * Multiple non-blocking write 4k to 4 MB chunks
- */
-static int mmc_test_profile_mult_write_nonblock_perf(struct mmc_test_card *test)
-{
- unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
- 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
- struct mmc_test_multiple_rw test_data = {
- .bs = bs,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(bs),
- .do_write = true,
- .do_nonblock_req = true,
- .prepare = MMC_TEST_PREP_ERASE,
- };
-
- return mmc_test_rw_multiple_size(test, &test_data);
-}
-
-/*
- * Multiple blocking read 4k to 4 MB chunks
- */
-static int mmc_test_profile_mult_read_blocking_perf(struct mmc_test_card *test)
-{
- unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
- 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
- struct mmc_test_multiple_rw test_data = {
- .bs = bs,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(bs),
- .do_write = false,
- .do_nonblock_req = false,
- .prepare = MMC_TEST_PREP_NONE,
- };
-
- return mmc_test_rw_multiple_size(test, &test_data);
-}
-
-/*
- * Multiple non-blocking read 4k to 4 MB chunks
- */
-static int mmc_test_profile_mult_read_nonblock_perf(struct mmc_test_card *test)
-{
- unsigned int bs[] = {1 << 12, 1 << 13, 1 << 14, 1 << 15, 1 << 16,
- 1 << 17, 1 << 18, 1 << 19, 1 << 20, 1 << 22};
- struct mmc_test_multiple_rw test_data = {
- .bs = bs,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(bs),
- .do_write = false,
- .do_nonblock_req = true,
- .prepare = MMC_TEST_PREP_NONE,
- };
-
- return mmc_test_rw_multiple_size(test, &test_data);
-}
-
-/*
- * Multiple blocking write 1 to 512 sg elements
- */
-static int mmc_test_profile_sglen_wr_blocking_perf(struct mmc_test_card *test)
-{
- unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
- 1 << 7, 1 << 8, 1 << 9};
- struct mmc_test_multiple_rw test_data = {
- .sg_len = sg_len,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(sg_len),
- .do_write = true,
- .do_nonblock_req = false,
- .prepare = MMC_TEST_PREP_ERASE,
- };
-
- return mmc_test_rw_multiple_sg_len(test, &test_data);
-};
-
-/*
- * Multiple non-blocking write 1 to 512 sg elements
- */
-static int mmc_test_profile_sglen_wr_nonblock_perf(struct mmc_test_card *test)
-{
- unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
- 1 << 7, 1 << 8, 1 << 9};
- struct mmc_test_multiple_rw test_data = {
- .sg_len = sg_len,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(sg_len),
- .do_write = true,
- .do_nonblock_req = true,
- .prepare = MMC_TEST_PREP_ERASE,
- };
-
- return mmc_test_rw_multiple_sg_len(test, &test_data);
-}
-
-/*
- * Multiple blocking read 1 to 512 sg elements
- */
-static int mmc_test_profile_sglen_r_blocking_perf(struct mmc_test_card *test)
-{
- unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
- 1 << 7, 1 << 8, 1 << 9};
- struct mmc_test_multiple_rw test_data = {
- .sg_len = sg_len,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(sg_len),
- .do_write = false,
- .do_nonblock_req = false,
- .prepare = MMC_TEST_PREP_NONE,
- };
-
- return mmc_test_rw_multiple_sg_len(test, &test_data);
-}
-
-/*
- * Multiple non-blocking read 1 to 512 sg elements
- */
-static int mmc_test_profile_sglen_r_nonblock_perf(struct mmc_test_card *test)
-{
- unsigned int sg_len[] = {1, 1 << 3, 1 << 4, 1 << 5, 1 << 6,
- 1 << 7, 1 << 8, 1 << 9};
- struct mmc_test_multiple_rw test_data = {
- .sg_len = sg_len,
- .size = TEST_AREA_MAX_SIZE,
- .len = ARRAY_SIZE(sg_len),
- .do_write = false,
- .do_nonblock_req = true,
- .prepare = MMC_TEST_PREP_NONE,
- };
-
- return mmc_test_rw_multiple_sg_len(test, &test_data);
-}
-
-/*
- * eMMC hardware reset.
- */
-static int mmc_test_reset(struct mmc_test_card *test)
-{
- struct mmc_card *card = test->card;
- struct mmc_host *host = card->host;
- int err;
-
- err = mmc_hw_reset(host);
- if (!err)
- return RESULT_OK;
- else if (err == -EOPNOTSUPP)
- return RESULT_UNSUP_HOST;
-
- return RESULT_FAIL;
-}
-
-struct mmc_test_req {
- struct mmc_request mrq;
- struct mmc_command sbc;
- struct mmc_command cmd;
- struct mmc_command stop;
- struct mmc_command status;
- struct mmc_data data;
-};
-
-static struct mmc_test_req *mmc_test_req_alloc(void)
-{
- struct mmc_test_req *rq = kzalloc(sizeof(*rq), GFP_KERNEL);
-
- if (rq) {
- rq->mrq.cmd = &rq->cmd;
- rq->mrq.data = &rq->data;
- rq->mrq.stop = &rq->stop;
- }
-
- return rq;
-}
-
-static int mmc_test_send_status(struct mmc_test_card *test,
- struct mmc_command *cmd)
-{
- memset(cmd, 0, sizeof(*cmd));
-
- cmd->opcode = MMC_SEND_STATUS;
- if (!mmc_host_is_spi(test->card->host))
- cmd->arg = test->card->rca << 16;
- cmd->flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
-
- return mmc_wait_for_cmd(test->card->host, cmd, 0);
-}
-
-static int mmc_test_ongoing_transfer(struct mmc_test_card *test,
- unsigned int dev_addr, int use_sbc,
- int repeat_cmd, int write, int use_areq)
-{
- struct mmc_test_req *rq = mmc_test_req_alloc();
- struct mmc_host *host = test->card->host;
- struct mmc_test_area *t = &test->area;
- struct mmc_test_async_req test_areq = { .test = test };
- struct mmc_request *mrq;
- unsigned long timeout;
- bool expired = false;
- enum mmc_blk_status blkstat = MMC_BLK_SUCCESS;
- int ret = 0, cmd_ret;
- u32 status = 0;
- int count = 0;
-
- if (!rq)
- return -ENOMEM;
-
- mrq = &rq->mrq;
- if (use_sbc)
- mrq->sbc = &rq->sbc;
- mrq->cap_cmd_during_tfr = true;
-
- test_areq.areq.mrq = mrq;
- test_areq.areq.err_check = mmc_test_check_result_async;
-
- mmc_test_prepare_mrq(test, mrq, t->sg, t->sg_len, dev_addr, t->blocks,
- 512, write);
-
- if (use_sbc && t->blocks > 1 && !mrq->sbc) {
- ret = mmc_host_cmd23(host) ?
- RESULT_UNSUP_CARD :
- RESULT_UNSUP_HOST;
- goto out_free;
- }
-
- /* Start ongoing data request */
- if (use_areq) {
- mmc_start_req(host, &test_areq.areq, &blkstat);
- if (blkstat != MMC_BLK_SUCCESS) {
- ret = RESULT_FAIL;
- goto out_free;
- }
- } else {
- mmc_wait_for_req(host, mrq);
- }
-
- timeout = jiffies + msecs_to_jiffies(3000);
- do {
- count += 1;
-
- /* Send status command while data transfer in progress */
- cmd_ret = mmc_test_send_status(test, &rq->status);
- if (cmd_ret)
- break;
-
- status = rq->status.resp[0];
- if (status & R1_ERROR) {
- cmd_ret = -EIO;
- break;
- }
-
- if (mmc_is_req_done(host, mrq))
- break;
-
- expired = time_after(jiffies, timeout);
- if (expired) {
- pr_info("%s: timeout waiting for Tran state status %#x\n",
- mmc_hostname(host), status);
- cmd_ret = -ETIMEDOUT;
- break;
- }
- } while (repeat_cmd && R1_CURRENT_STATE(status) != R1_STATE_TRAN);
-
- /* Wait for data request to complete */
- if (use_areq) {
- mmc_start_req(host, NULL, &blkstat);
- if (blkstat != MMC_BLK_SUCCESS)
- ret = RESULT_FAIL;
- } else {
- mmc_wait_for_req_done(test->card->host, mrq);
- }
-
- /*
- * For cap_cmd_during_tfr request, upper layer must send stop if
- * required.
- */
- if (mrq->data->stop && (mrq->data->error || !mrq->sbc)) {
- if (ret)
- mmc_wait_for_cmd(host, mrq->data->stop, 0);
- else
- ret = mmc_wait_for_cmd(host, mrq->data->stop, 0);
- }
-
- if (ret)
- goto out_free;
-
- if (cmd_ret) {
- pr_info("%s: Send Status failed: status %#x, error %d\n",
- mmc_hostname(test->card->host), status, cmd_ret);
- }
-
- ret = mmc_test_check_result(test, mrq);
- if (ret)
- goto out_free;
-
- ret = mmc_test_wait_busy(test);
- if (ret)
- goto out_free;
-
- if (repeat_cmd && (t->blocks + 1) << 9 > t->max_tfr)
- pr_info("%s: %d commands completed during transfer of %u blocks\n",
- mmc_hostname(test->card->host), count, t->blocks);
-
- if (cmd_ret)
- ret = cmd_ret;
-out_free:
- kfree(rq);
-
- return ret;
-}
-
-static int __mmc_test_cmds_during_tfr(struct mmc_test_card *test,
- unsigned long sz, int use_sbc, int write,
- int use_areq)
-{
- struct mmc_test_area *t = &test->area;
- int ret;
-
- if (!(test->card->host->caps & MMC_CAP_CMD_DURING_TFR))
- return RESULT_UNSUP_HOST;
-
- ret = mmc_test_area_map(test, sz, 0, 0);
- if (ret)
- return ret;
-
- ret = mmc_test_ongoing_transfer(test, t->dev_addr, use_sbc, 0, write,
- use_areq);
- if (ret)
- return ret;
-
- return mmc_test_ongoing_transfer(test, t->dev_addr, use_sbc, 1, write,
- use_areq);
-}
-
-static int mmc_test_cmds_during_tfr(struct mmc_test_card *test, int use_sbc,
- int write, int use_areq)
-{
- struct mmc_test_area *t = &test->area;
- unsigned long sz;
- int ret;
-
- for (sz = 512; sz <= t->max_tfr; sz += 512) {
- ret = __mmc_test_cmds_during_tfr(test, sz, use_sbc, write,
- use_areq);
- if (ret)
- return ret;
- }
- return 0;
-}
-
-/*
- * Commands during read - no Set Block Count (CMD23).
- */
-static int mmc_test_cmds_during_read(struct mmc_test_card *test)
-{
- return mmc_test_cmds_during_tfr(test, 0, 0, 0);
-}
-
-/*
- * Commands during write - no Set Block Count (CMD23).
- */
-static int mmc_test_cmds_during_write(struct mmc_test_card *test)
-{
- return mmc_test_cmds_during_tfr(test, 0, 1, 0);
-}
-
-/*
- * Commands during read - use Set Block Count (CMD23).
- */
-static int mmc_test_cmds_during_read_cmd23(struct mmc_test_card *test)
-{
- return mmc_test_cmds_during_tfr(test, 1, 0, 0);
-}
-
-/*
- * Commands during write - use Set Block Count (CMD23).
- */
-static int mmc_test_cmds_during_write_cmd23(struct mmc_test_card *test)
-{
- return mmc_test_cmds_during_tfr(test, 1, 1, 0);
-}
-
-/*
- * Commands during non-blocking read - use Set Block Count (CMD23).
- */
-static int mmc_test_cmds_during_read_cmd23_nonblock(struct mmc_test_card *test)
-{
- return mmc_test_cmds_during_tfr(test, 1, 0, 1);
-}
-
-/*
- * Commands during non-blocking write - use Set Block Count (CMD23).
- */
-static int mmc_test_cmds_during_write_cmd23_nonblock(struct mmc_test_card *test)
-{
- return mmc_test_cmds_during_tfr(test, 1, 1, 1);
-}
-
-static const struct mmc_test_case mmc_test_cases[] = {
- {
- .name = "Basic write (no data verification)",
- .run = mmc_test_basic_write,
- },
-
- {
- .name = "Basic read (no data verification)",
- .run = mmc_test_basic_read,
- },
-
- {
- .name = "Basic write (with data verification)",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_verify_write,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Basic read (with data verification)",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_verify_read,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Multi-block write",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_multi_write,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Multi-block read",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_multi_read,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Power of two block writes",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_pow2_write,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Power of two block reads",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_pow2_read,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Weird sized block writes",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_weird_write,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Weird sized block reads",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_weird_read,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Badly aligned write",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_align_write,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Badly aligned read",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_align_read,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Badly aligned multi-block write",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_align_multi_write,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Badly aligned multi-block read",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_align_multi_read,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Correct xfer_size at write (start failure)",
- .run = mmc_test_xfersize_write,
- },
-
- {
- .name = "Correct xfer_size at read (start failure)",
- .run = mmc_test_xfersize_read,
- },
-
- {
- .name = "Correct xfer_size at write (midway failure)",
- .run = mmc_test_multi_xfersize_write,
- },
-
- {
- .name = "Correct xfer_size at read (midway failure)",
- .run = mmc_test_multi_xfersize_read,
- },
-
-#ifdef CONFIG_HIGHMEM
-
- {
- .name = "Highmem write",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_write_high,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Highmem read",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_read_high,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Multi-block highmem write",
- .prepare = mmc_test_prepare_write,
- .run = mmc_test_multi_write_high,
- .cleanup = mmc_test_cleanup,
- },
-
- {
- .name = "Multi-block highmem read",
- .prepare = mmc_test_prepare_read,
- .run = mmc_test_multi_read_high,
- .cleanup = mmc_test_cleanup,
- },
-
-#else
-
- {
- .name = "Highmem write",
- .run = mmc_test_no_highmem,
- },
-
- {
- .name = "Highmem read",
- .run = mmc_test_no_highmem,
- },
-
- {
- .name = "Multi-block highmem write",
- .run = mmc_test_no_highmem,
- },
-
- {
- .name = "Multi-block highmem read",
- .run = mmc_test_no_highmem,
- },
-
-#endif /* CONFIG_HIGHMEM */
-
- {
- .name = "Best-case read performance",
- .prepare = mmc_test_area_prepare_fill,
- .run = mmc_test_best_read_performance,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Best-case write performance",
- .prepare = mmc_test_area_prepare_erase,
- .run = mmc_test_best_write_performance,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Best-case read performance into scattered pages",
- .prepare = mmc_test_area_prepare_fill,
- .run = mmc_test_best_read_perf_max_scatter,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Best-case write performance from scattered pages",
- .prepare = mmc_test_area_prepare_erase,
- .run = mmc_test_best_write_perf_max_scatter,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Single read performance by transfer size",
- .prepare = mmc_test_area_prepare_fill,
- .run = mmc_test_profile_read_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Single write performance by transfer size",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_write_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Single trim performance by transfer size",
- .prepare = mmc_test_area_prepare_fill,
- .run = mmc_test_profile_trim_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Consecutive read performance by transfer size",
- .prepare = mmc_test_area_prepare_fill,
- .run = mmc_test_profile_seq_read_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Consecutive write performance by transfer size",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_seq_write_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Consecutive trim performance by transfer size",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_seq_trim_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Random read performance by transfer size",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_random_read_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Random write performance by transfer size",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_random_write_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Large sequential read into scattered pages",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_large_seq_read_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Large sequential write from scattered pages",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_large_seq_write_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Write performance with blocking req 4k to 4MB",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_mult_write_blocking_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Write performance with non-blocking req 4k to 4MB",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_mult_write_nonblock_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Read performance with blocking req 4k to 4MB",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_mult_read_blocking_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Read performance with non-blocking req 4k to 4MB",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_mult_read_nonblock_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Write performance blocking req 1 to 512 sg elems",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_sglen_wr_blocking_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Write performance non-blocking req 1 to 512 sg elems",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_sglen_wr_nonblock_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Read performance blocking req 1 to 512 sg elems",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_sglen_r_blocking_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Read performance non-blocking req 1 to 512 sg elems",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_profile_sglen_r_nonblock_perf,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Reset test",
- .run = mmc_test_reset,
- },
-
- {
- .name = "Commands during read - no Set Block Count (CMD23)",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_cmds_during_read,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Commands during write - no Set Block Count (CMD23)",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_cmds_during_write,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Commands during read - use Set Block Count (CMD23)",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_cmds_during_read_cmd23,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Commands during write - use Set Block Count (CMD23)",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_cmds_during_write_cmd23,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Commands during non-blocking read - use Set Block Count (CMD23)",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_cmds_during_read_cmd23_nonblock,
- .cleanup = mmc_test_area_cleanup,
- },
-
- {
- .name = "Commands during non-blocking write - use Set Block Count (CMD23)",
- .prepare = mmc_test_area_prepare,
- .run = mmc_test_cmds_during_write_cmd23_nonblock,
- .cleanup = mmc_test_area_cleanup,
- },
-};
-
-static DEFINE_MUTEX(mmc_test_lock);
-
-static LIST_HEAD(mmc_test_result);
-
-static void mmc_test_run(struct mmc_test_card *test, int testcase)
-{
- int i, ret;
-
- pr_info("%s: Starting tests of card %s...\n",
- mmc_hostname(test->card->host), mmc_card_id(test->card));
-
- mmc_claim_host(test->card->host);
-
- for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {
- struct mmc_test_general_result *gr;
-
- if (testcase && ((i + 1) != testcase))
- continue;
-
- pr_info("%s: Test case %d. %s...\n",
- mmc_hostname(test->card->host), i + 1,
- mmc_test_cases[i].name);
-
- if (mmc_test_cases[i].prepare) {
- ret = mmc_test_cases[i].prepare(test);
- if (ret) {
- pr_info("%s: Result: Prepare "
- "stage failed! (%d)\n",
- mmc_hostname(test->card->host),
- ret);
- continue;
- }
- }
-
- gr = kzalloc(sizeof(struct mmc_test_general_result),
- GFP_KERNEL);
- if (gr) {
- INIT_LIST_HEAD(&gr->tr_lst);
-
- /* Assign data what we know already */
- gr->card = test->card;
- gr->testcase = i;
-
- /* Append container to global one */
- list_add_tail(&gr->link, &mmc_test_result);
-
- /*
- * Save the pointer to created container in our private
- * structure.
- */
- test->gr = gr;
- }
-
- ret = mmc_test_cases[i].run(test);
- switch (ret) {
- case RESULT_OK:
- pr_info("%s: Result: OK\n",
- mmc_hostname(test->card->host));
- break;
- case RESULT_FAIL:
- pr_info("%s: Result: FAILED\n",
- mmc_hostname(test->card->host));
- break;
- case RESULT_UNSUP_HOST:
- pr_info("%s: Result: UNSUPPORTED "
- "(by host)\n",
- mmc_hostname(test->card->host));
- break;
- case RESULT_UNSUP_CARD:
- pr_info("%s: Result: UNSUPPORTED "
- "(by card)\n",
- mmc_hostname(test->card->host));
- break;
- default:
- pr_info("%s: Result: ERROR (%d)\n",
- mmc_hostname(test->card->host), ret);
- }
-
- /* Save the result */
- if (gr)
- gr->result = ret;
-
- if (mmc_test_cases[i].cleanup) {
- ret = mmc_test_cases[i].cleanup(test);
- if (ret) {
- pr_info("%s: Warning: Cleanup "
- "stage failed! (%d)\n",
- mmc_hostname(test->card->host),
- ret);
- }
- }
- }
-
- mmc_release_host(test->card->host);
-
- pr_info("%s: Tests completed.\n",
- mmc_hostname(test->card->host));
-}
-
-static void mmc_test_free_result(struct mmc_card *card)
-{
- struct mmc_test_general_result *gr, *grs;
-
- mutex_lock(&mmc_test_lock);
-
- list_for_each_entry_safe(gr, grs, &mmc_test_result, link) {
- struct mmc_test_transfer_result *tr, *trs;
-
- if (card && gr->card != card)
- continue;
-
- list_for_each_entry_safe(tr, trs, &gr->tr_lst, link) {
- list_del(&tr->link);
- kfree(tr);
- }
-
- list_del(&gr->link);
- kfree(gr);
- }
-
- mutex_unlock(&mmc_test_lock);
-}
-
-static LIST_HEAD(mmc_test_file_test);
-
-static int mtf_test_show(struct seq_file *sf, void *data)
-{
- struct mmc_card *card = (struct mmc_card *)sf->private;
- struct mmc_test_general_result *gr;
-
- mutex_lock(&mmc_test_lock);
-
- list_for_each_entry(gr, &mmc_test_result, link) {
- struct mmc_test_transfer_result *tr;
-
- if (gr->card != card)
- continue;
-
- seq_printf(sf, "Test %d: %d\n", gr->testcase + 1, gr->result);
-
- list_for_each_entry(tr, &gr->tr_lst, link) {
- seq_printf(sf, "%u %d %lu.%09lu %u %u.%02u\n",
- tr->count, tr->sectors,
- (unsigned long)tr->ts.tv_sec,
- (unsigned long)tr->ts.tv_nsec,
- tr->rate, tr->iops / 100, tr->iops % 100);
- }
- }
-
- mutex_unlock(&mmc_test_lock);
-
- return 0;
-}
-
-static int mtf_test_open(struct inode *inode, struct file *file)
-{
- return single_open(file, mtf_test_show, inode->i_private);
-}
-
-static ssize_t mtf_test_write(struct file *file, const char __user *buf,
- size_t count, loff_t *pos)
-{
- struct seq_file *sf = (struct seq_file *)file->private_data;
- struct mmc_card *card = (struct mmc_card *)sf->private;
- struct mmc_test_card *test;
- long testcase;
- int ret;
-
- ret = kstrtol_from_user(buf, count, 10, &testcase);
- if (ret)
- return ret;
-
- test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);
- if (!test)
- return -ENOMEM;
-
- /*
- * Remove all test cases associated with given card. Thus we have only
- * actual data of the last run.
- */
- mmc_test_free_result(card);
-
- test->card = card;
-
- test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
-#ifdef CONFIG_HIGHMEM
- test->highmem = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM, BUFFER_ORDER);
-#endif
-
-#ifdef CONFIG_HIGHMEM
- if (test->buffer && test->highmem) {
-#else
- if (test->buffer) {
-#endif
- mutex_lock(&mmc_test_lock);
- mmc_test_run(test, testcase);
- mutex_unlock(&mmc_test_lock);
- }
-
-#ifdef CONFIG_HIGHMEM
- __free_pages(test->highmem, BUFFER_ORDER);
-#endif
- kfree(test->buffer);
- kfree(test);
-
- return count;
-}
-
-static const struct file_operations mmc_test_fops_test = {
- .open = mtf_test_open,
- .read = seq_read,
- .write = mtf_test_write,
- .llseek = seq_lseek,
- .release = single_release,
-};
-
-static int mtf_testlist_show(struct seq_file *sf, void *data)
-{
- int i;
-
- mutex_lock(&mmc_test_lock);
-
- seq_printf(sf, "0:\tRun all tests\n");
- for (i = 0; i < ARRAY_SIZE(mmc_test_cases); i++)
- seq_printf(sf, "%d:\t%s\n", i+1, mmc_test_cases[i].name);
-
- mutex_unlock(&mmc_test_lock);
-
- return 0;
-}
-
-static int mtf_testlist_open(struct inode *inode, struct file *file)
-{
- return single_open(file, mtf_testlist_show, inode->i_private);
-}
-
-static const struct file_operations mmc_test_fops_testlist = {
- .open = mtf_testlist_open,
- .read = seq_read,
- .llseek = seq_lseek,
- .release = single_release,
-};
-
-static void mmc_test_free_dbgfs_file(struct mmc_card *card)
-{
- struct mmc_test_dbgfs_file *df, *dfs;
-
- mutex_lock(&mmc_test_lock);
-
- list_for_each_entry_safe(df, dfs, &mmc_test_file_test, link) {
- if (card && df->card != card)
- continue;
- debugfs_remove(df->file);
- list_del(&df->link);
- kfree(df);
- }
-
- mutex_unlock(&mmc_test_lock);
-}
-
-static int __mmc_test_register_dbgfs_file(struct mmc_card *card,
- const char *name, umode_t mode, const struct file_operations *fops)
-{
- struct dentry *file = NULL;
- struct mmc_test_dbgfs_file *df;
-
- if (card->debugfs_root)
- file = debugfs_create_file(name, mode, card->debugfs_root,
- card, fops);
-
- if (IS_ERR_OR_NULL(file)) {
- dev_err(&card->dev,
- "Can't create %s. Perhaps debugfs is disabled.\n",
- name);
- return -ENODEV;
- }
-
- df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL);
- if (!df) {
- debugfs_remove(file);
- dev_err(&card->dev,
- "Can't allocate memory for internal usage.\n");
- return -ENOMEM;
- }
-
- df->card = card;
- df->file = file;
-
- list_add(&df->link, &mmc_test_file_test);
- return 0;
-}
-
-static int mmc_test_register_dbgfs_file(struct mmc_card *card)
-{
- int ret;
-
- mutex_lock(&mmc_test_lock);
-
- ret = __mmc_test_register_dbgfs_file(card, "test", S_IWUSR | S_IRUGO,
- &mmc_test_fops_test);
- if (ret)
- goto err;
-
- ret = __mmc_test_register_dbgfs_file(card, "testlist", S_IRUGO,
- &mmc_test_fops_testlist);
- if (ret)
- goto err;
-
-err:
- mutex_unlock(&mmc_test_lock);
-
- return ret;
-}
-
-static int mmc_test_probe(struct mmc_card *card)
-{
- int ret;
-
- if (!mmc_card_mmc(card) && !mmc_card_sd(card))
- return -ENODEV;
-
- ret = mmc_test_register_dbgfs_file(card);
- if (ret)
- return ret;
-
- dev_info(&card->dev, "Card claimed for testing.\n");
-
- return 0;
-}
-
-static void mmc_test_remove(struct mmc_card *card)
-{
- mmc_test_free_result(card);
- mmc_test_free_dbgfs_file(card);
-}
-
-static void mmc_test_shutdown(struct mmc_card *card)
-{
-}
-
-static struct mmc_driver mmc_driver = {
- .drv = {
- .name = "mmc_test",
- },
- .probe = mmc_test_probe,
- .remove = mmc_test_remove,
- .shutdown = mmc_test_shutdown,
-};
-
-static int __init mmc_test_init(void)
-{
- return mmc_register_driver(&mmc_driver);
-}
-
-static void __exit mmc_test_exit(void)
-{
- /* Clear stalled data if card is still plugged */
- mmc_test_free_result(NULL);
- mmc_test_free_dbgfs_file(NULL);
-
- mmc_unregister_driver(&mmc_driver);
-}
-
-module_init(mmc_test_init);
-module_exit(mmc_test_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Multimedia Card (MMC) host test driver");
-MODULE_AUTHOR("Pierre Ossman");
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
deleted file mode 100644
index cf29809f69e4..000000000000
--- a/drivers/mmc/card/queue.c
+++ /dev/null
@@ -1,491 +0,0 @@
-/*
- * linux/drivers/mmc/card/queue.c
- *
- * Copyright (C) 2003 Russell King, All Rights Reserved.
- * Copyright 2006-2007 Pierre Ossman
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/blkdev.h>
-#include <linux/freezer.h>
-#include <linux/kthread.h>
-#include <linux/scatterlist.h>
-#include <linux/dma-mapping.h>
-
-#include <linux/mmc/card.h>
-#include <linux/mmc/host.h>
-
-#include "queue.h"
-#include "block.h"
-
-#define MMC_QUEUE_BOUNCESZ 65536
-
-/*
- * Prepare a MMC request. This just filters out odd stuff.
- */
-static int mmc_prep_request(struct request_queue *q, struct request *req)
-{
- struct mmc_queue *mq = q->queuedata;
-
- /*
- * We only like normal block requests and discards.
- */
- if (req->cmd_type != REQ_TYPE_FS && req_op(req) != REQ_OP_DISCARD &&
- req_op(req) != REQ_OP_SECURE_ERASE) {
- blk_dump_rq_flags(req, "MMC bad request");
- return BLKPREP_KILL;
- }
-
- if (mq && (mmc_card_removed(mq->card) || mmc_access_rpmb(mq)))
- return BLKPREP_KILL;
-
- req->cmd_flags |= REQ_DONTPREP;
-
- return BLKPREP_OK;
-}
-
-static int mmc_queue_thread(void *d)
-{
- struct mmc_queue *mq = d;
- struct request_queue *q = mq->queue;
- struct mmc_context_info *cntx = &mq->card->host->context_info;
-
- current->flags |= PF_MEMALLOC;
-
- down(&mq->thread_sem);
- do {
- struct request *req = NULL;
-
- spin_lock_irq(q->queue_lock);
- set_current_state(TASK_INTERRUPTIBLE);
- req = blk_fetch_request(q);
- mq->asleep = false;
- cntx->is_waiting_last_req = false;
- cntx->is_new_req = false;
- if (!req) {
- /*
- * Dispatch queue is empty so set flags for
- * mmc_request_fn() to wake us up.
- */
- if (mq->mqrq_prev->req)
- cntx->is_waiting_last_req = true;
- else
- mq->asleep = true;
- }
- mq->mqrq_cur->req = req;
- spin_unlock_irq(q->queue_lock);
-
- if (req || mq->mqrq_prev->req) {
- bool req_is_special = mmc_req_is_special(req);
-
- set_current_state(TASK_RUNNING);
- mmc_blk_issue_rq(mq, req);
- cond_resched();
- if (mq->flags & MMC_QUEUE_NEW_REQUEST) {
- mq->flags &= ~MMC_QUEUE_NEW_REQUEST;
- continue; /* fetch again */
- }
-
- /*
- * Current request becomes previous request
- * and vice versa.
- * In case of special requests, current request
- * has been finished. Do not assign it to previous
- * request.
- */
- if (req_is_special)
- mq->mqrq_cur->req = NULL;
-
- mq->mqrq_prev->brq.mrq.data = NULL;
- mq->mqrq_prev->req = NULL;
- swap(mq->mqrq_prev, mq->mqrq_cur);
- } else {
- if (kthread_should_stop()) {
- set_current_state(TASK_RUNNING);
- break;
- }
- up(&mq->thread_sem);
- schedule();
- down(&mq->thread_sem);
- }
- } while (1);
- up(&mq->thread_sem);
-
- return 0;
-}
-
-/*
- * Generic MMC request handler. This is called for any queue on a
- * particular host. When the host is not busy, we look for a request
- * on any queue on this host, and attempt to issue it. This may
- * not be the queue we were asked to process.
- */
-static void mmc_request_fn(struct request_queue *q)
-{
- struct mmc_queue *mq = q->queuedata;
- struct request *req;
- struct mmc_context_info *cntx;
-
- if (!mq) {
- while ((req = blk_fetch_request(q)) != NULL) {
- req->cmd_flags |= REQ_QUIET;
- __blk_end_request_all(req, -EIO);
- }
- return;
- }
-
- cntx = &mq->card->host->context_info;
-
- if (cntx->is_waiting_last_req) {
- cntx->is_new_req = true;
- wake_up_interruptible(&cntx->wait);
- }
-
- if (mq->asleep)
- wake_up_process(mq->thread);
-}
-
-static struct scatterlist *mmc_alloc_sg(int sg_len, int *err)
-{
- struct scatterlist *sg;
-
- sg = kmalloc(sizeof(struct scatterlist)*sg_len, GFP_KERNEL);
- if (!sg)
- *err = -ENOMEM;
- else {
- *err = 0;
- sg_init_table(sg, sg_len);
- }
-
- return sg;
-}
-
-static void mmc_queue_setup_discard(struct request_queue *q,
- struct mmc_card *card)
-{
- unsigned max_discard;
-
- max_discard = mmc_calc_max_discard(card);
- if (!max_discard)
- return;
-
- queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
- blk_queue_max_discard_sectors(q, max_discard);
- if (card->erased_byte == 0 && !mmc_can_discard(card))
- q->limits.discard_zeroes_data = 1;
- q->limits.discard_granularity = card->pref_erase << 9;
- /* granularity must not be greater than max. discard */
- if (card->pref_erase > max_discard)
- q->limits.discard_granularity = 0;
- if (mmc_can_secure_erase_trim(card))
- queue_flag_set_unlocked(QUEUE_FLAG_SECERASE, q);
-}
-
-#ifdef CONFIG_MMC_BLOCK_BOUNCE
-static bool mmc_queue_alloc_bounce_bufs(struct mmc_queue *mq,
- unsigned int bouncesz)
-{
- int i;
-
- for (i = 0; i < mq->qdepth; i++) {
- mq->mqrq[i].bounce_buf = kmalloc(bouncesz, GFP_KERNEL);
- if (!mq->mqrq[i].bounce_buf)
- goto out_err;
- }
-
- return true;
-
-out_err:
- while (--i >= 0) {
- kfree(mq->mqrq[i].bounce_buf);
- mq->mqrq[i].bounce_buf = NULL;
- }
- pr_warn("%s: unable to allocate bounce buffers\n",
- mmc_card_name(mq->card));
- return false;
-}
-
-static int mmc_queue_alloc_bounce_sgs(struct mmc_queue *mq,
- unsigned int bouncesz)
-{
- int i, ret;
-
- for (i = 0; i < mq->qdepth; i++) {
- mq->mqrq[i].sg = mmc_alloc_sg(1, &ret);
- if (ret)
- return ret;
-
- mq->mqrq[i].bounce_sg = mmc_alloc_sg(bouncesz / 512, &ret);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-#endif
-
-static int mmc_queue_alloc_sgs(struct mmc_queue *mq, int max_segs)
-{
- int i, ret;
-
- for (i = 0; i < mq->qdepth; i++) {
- mq->mqrq[i].sg = mmc_alloc_sg(max_segs, &ret);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static void mmc_queue_req_free_bufs(struct mmc_queue_req *mqrq)
-{
- kfree(mqrq->bounce_sg);
- mqrq->bounce_sg = NULL;
-
- kfree(mqrq->sg);
- mqrq->sg = NULL;
-
- kfree(mqrq->bounce_buf);
- mqrq->bounce_buf = NULL;
-}
-
-static void mmc_queue_reqs_free_bufs(struct mmc_queue *mq)
-{
- int i;
-
- for (i = 0; i < mq->qdepth; i++)
- mmc_queue_req_free_bufs(&mq->mqrq[i]);
-}
-
-/**
- * mmc_init_queue - initialise a queue structure.
- * @mq: mmc queue
- * @card: mmc card to attach this queue
- * @lock: queue lock
- * @subname: partition subname
- *
- * Initialise a MMC card request queue.
- */
-int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
- spinlock_t *lock, const char *subname)
-{
- struct mmc_host *host = card->host;
- u64 limit = BLK_BOUNCE_HIGH;
- bool bounce = false;
- int ret = -ENOMEM;
-
- if (mmc_dev(host)->dma_mask && *mmc_dev(host)->dma_mask)
- limit = (u64)dma_max_pfn(mmc_dev(host)) << PAGE_SHIFT;
-
- mq->card = card;
- mq->queue = blk_init_queue(mmc_request_fn, lock);
- if (!mq->queue)
- return -ENOMEM;
-
- mq->qdepth = 2;
- mq->mqrq = kcalloc(mq->qdepth, sizeof(struct mmc_queue_req),
- GFP_KERNEL);
- if (!mq->mqrq)
- goto blk_cleanup;
- mq->mqrq_cur = &mq->mqrq[0];
- mq->mqrq_prev = &mq->mqrq[1];
- mq->queue->queuedata = mq;
-
- blk_queue_prep_rq(mq->queue, mmc_prep_request);
- queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
- queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, mq->queue);
- if (mmc_can_erase(card))
- mmc_queue_setup_discard(mq->queue, card);
-
-#ifdef CONFIG_MMC_BLOCK_BOUNCE
- if (host->max_segs == 1) {
- unsigned int bouncesz;
-
- bouncesz = MMC_QUEUE_BOUNCESZ;
-
- if (bouncesz > host->max_req_size)
- bouncesz = host->max_req_size;
- if (bouncesz > host->max_seg_size)
- bouncesz = host->max_seg_size;
- if (bouncesz > (host->max_blk_count * 512))
- bouncesz = host->max_blk_count * 512;
-
- if (bouncesz > 512 &&
- mmc_queue_alloc_bounce_bufs(mq, bouncesz)) {
- blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
- blk_queue_max_hw_sectors(mq->queue, bouncesz / 512);
- blk_queue_max_segments(mq->queue, bouncesz / 512);
- blk_queue_max_segment_size(mq->queue, bouncesz);
-
- ret = mmc_queue_alloc_bounce_sgs(mq, bouncesz);
- if (ret)
- goto cleanup_queue;
- bounce = true;
- }
- }
-#endif
-
- if (!bounce) {
- blk_queue_bounce_limit(mq->queue, limit);
- blk_queue_max_hw_sectors(mq->queue,
- min(host->max_blk_count, host->max_req_size / 512));
- blk_queue_max_segments(mq->queue, host->max_segs);
- blk_queue_max_segment_size(mq->queue, host->max_seg_size);
-
- ret = mmc_queue_alloc_sgs(mq, host->max_segs);
- if (ret)
- goto cleanup_queue;
- }
-
- sema_init(&mq->thread_sem, 1);
-
- mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd/%d%s",
- host->index, subname ? subname : "");
-
- if (IS_ERR(mq->thread)) {
- ret = PTR_ERR(mq->thread);
- goto cleanup_queue;
- }
-
- return 0;
-
- cleanup_queue:
- mmc_queue_reqs_free_bufs(mq);
- kfree(mq->mqrq);
- mq->mqrq = NULL;
-blk_cleanup:
- blk_cleanup_queue(mq->queue);
- return ret;
-}
-
-void mmc_cleanup_queue(struct mmc_queue *mq)
-{
- struct request_queue *q = mq->queue;
- unsigned long flags;
-
- /* Make sure the queue isn't suspended, as that will deadlock */
- mmc_queue_resume(mq);
-
- /* Then terminate our worker thread */
- kthread_stop(mq->thread);
-
- /* Empty the queue */
- spin_lock_irqsave(q->queue_lock, flags);
- q->queuedata = NULL;
- blk_start_queue(q);
- spin_unlock_irqrestore(q->queue_lock, flags);
-
- mmc_queue_reqs_free_bufs(mq);
- kfree(mq->mqrq);
- mq->mqrq = NULL;
-
- mq->card = NULL;
-}
-EXPORT_SYMBOL(mmc_cleanup_queue);
-
-/**
- * mmc_queue_suspend - suspend a MMC request queue
- * @mq: MMC queue to suspend
- *
- * Stop the block request queue, and wait for our thread to
- * complete any outstanding requests. This ensures that we
- * won't suspend while a request is being processed.
- */
-void mmc_queue_suspend(struct mmc_queue *mq)
-{
- struct request_queue *q = mq->queue;
- unsigned long flags;
-
- if (!(mq->flags & MMC_QUEUE_SUSPENDED)) {
- mq->flags |= MMC_QUEUE_SUSPENDED;
-
- spin_lock_irqsave(q->queue_lock, flags);
- blk_stop_queue(q);
- spin_unlock_irqrestore(q->queue_lock, flags);
-
- down(&mq->thread_sem);
- }
-}
-
-/**
- * mmc_queue_resume - resume a previously suspended MMC request queue
- * @mq: MMC queue to resume
- */
-void mmc_queue_resume(struct mmc_queue *mq)
-{
- struct request_queue *q = mq->queue;
- unsigned long flags;
-
- if (mq->flags & MMC_QUEUE_SUSPENDED) {
- mq->flags &= ~MMC_QUEUE_SUSPENDED;
-
- up(&mq->thread_sem);
-
- spin_lock_irqsave(q->queue_lock, flags);
- blk_start_queue(q);
- spin_unlock_irqrestore(q->queue_lock, flags);
- }
-}
-
-/*
- * Prepare the sg list(s) to be handed of to the host driver
- */
-unsigned int mmc_queue_map_sg(struct mmc_queue *mq, struct mmc_queue_req *mqrq)
-{
- unsigned int sg_len;
- size_t buflen;
- struct scatterlist *sg;
- int i;
-
- if (!mqrq->bounce_buf)
- return blk_rq_map_sg(mq->queue, mqrq->req, mqrq->sg);
-
- sg_len = blk_rq_map_sg(mq->queue, mqrq->req, mqrq->bounce_sg);
-
- mqrq->bounce_sg_len = sg_len;
-
- buflen = 0;
- for_each_sg(mqrq->bounce_sg, sg, sg_len, i)
- buflen += sg->length;
-
- sg_init_one(mqrq->sg, mqrq->bounce_buf, buflen);
-
- return 1;
-}
-
-/*
- * If writing, bounce the data to the buffer before the request
- * is sent to the host driver
- */
-void mmc_queue_bounce_pre(struct mmc_queue_req *mqrq)
-{
- if (!mqrq->bounce_buf)
- return;
-
- if (rq_data_dir(mqrq->req) != WRITE)
- return;
-
- sg_copy_to_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
- mqrq->bounce_buf, mqrq->sg[0].length);
-}
-
-/*
- * If reading, bounce the data from the buffer after the request
- * has been handled by the host driver
- */
-void mmc_queue_bounce_post(struct mmc_queue_req *mqrq)
-{
- if (!mqrq->bounce_buf)
- return;
-
- if (rq_data_dir(mqrq->req) != READ)
- return;
-
- sg_copy_from_buffer(mqrq->bounce_sg, mqrq->bounce_sg_len,
- mqrq->bounce_buf, mqrq->sg[0].length);
-}
diff --git a/drivers/mmc/card/queue.h b/drivers/mmc/card/queue.h
deleted file mode 100644
index dac8c3d010dd..000000000000
--- a/drivers/mmc/card/queue.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef MMC_QUEUE_H
-#define MMC_QUEUE_H
-
-static inline bool mmc_req_is_special(struct request *req)
-{
- return req &&
- (req_op(req) == REQ_OP_FLUSH ||
- req_op(req) == REQ_OP_DISCARD ||
- req_op(req) == REQ_OP_SECURE_ERASE);
-}
-
-struct request;
-struct task_struct;
-struct mmc_blk_data;
-
-struct mmc_blk_request {
- struct mmc_request mrq;
- struct mmc_command sbc;
- struct mmc_command cmd;
- struct mmc_command stop;
- struct mmc_data data;
- int retune_retry_done;
-};
-
-struct mmc_queue_req {
- struct request *req;
- struct mmc_blk_request brq;
- struct scatterlist *sg;
- char *bounce_buf;
- struct scatterlist *bounce_sg;
- unsigned int bounce_sg_len;
- struct mmc_async_req mmc_active;
-};
-
-struct mmc_queue {
- struct mmc_card *card;
- struct task_struct *thread;
- struct semaphore thread_sem;
- unsigned int flags;
-#define MMC_QUEUE_SUSPENDED (1 << 0)
-#define MMC_QUEUE_NEW_REQUEST (1 << 1)
- 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;
-};
-
-extern int mmc_init_queue(struct mmc_queue *, struct mmc_card *, spinlock_t *,
- const char *);
-extern void mmc_cleanup_queue(struct mmc_queue *);
-extern void mmc_queue_suspend(struct mmc_queue *);
-extern void mmc_queue_resume(struct mmc_queue *);
-
-extern unsigned int mmc_queue_map_sg(struct mmc_queue *,
- struct mmc_queue_req *);
-extern void mmc_queue_bounce_pre(struct mmc_queue_req *);
-extern void mmc_queue_bounce_post(struct mmc_queue_req *);
-
-extern int mmc_access_rpmb(struct mmc_queue *);
-
-#endif
diff --git a/drivers/mmc/card/sdio_uart.c b/drivers/mmc/card/sdio_uart.c
deleted file mode 100644
index 491c187744f5..000000000000
--- a/drivers/mmc/card/sdio_uart.c
+++ /dev/null
@@ -1,1200 +0,0 @@
-/*
- * linux/drivers/mmc/card/sdio_uart.c - SDIO UART/GPS driver
- *
- * Based on drivers/serial/8250.c and drivers/serial/serial_core.c
- * by Russell King.
- *
- * Author: Nicolas Pitre
- * Created: June 15, 2007
- * Copyright: MontaVista Software, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- */
-
-/*
- * Note: Although this driver assumes a 16550A-like UART implementation,
- * it is not possible to leverage the common 8250/16550 driver, nor the
- * core UART infrastructure, as they assumes direct access to the hardware
- * registers, often under a spinlock. This is not possible in the SDIO
- * context as SDIO access functions must be able to sleep.
- *
- * Because we need to lock the SDIO host to ensure an exclusive access to
- * the card, we simply rely on that lock to also prevent and serialize
- * concurrent access to the same port.
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/mutex.h>
-#include <linux/seq_file.h>
-#include <linux/serial_reg.h>
-#include <linux/circ_buf.h>
-#include <linux/tty.h>
-#include <linux/tty_flip.h>
-#include <linux/kfifo.h>
-#include <linux/slab.h>
-
-#include <linux/mmc/core.h>
-#include <linux/mmc/card.h>
-#include <linux/mmc/sdio_func.h>
-#include <linux/mmc/sdio_ids.h>
-
-
-#define UART_NR 8 /* Number of UARTs this driver can handle */
-
-
-#define FIFO_SIZE PAGE_SIZE
-#define WAKEUP_CHARS 256
-
-struct uart_icount {
- __u32 cts;
- __u32 dsr;
- __u32 rng;
- __u32 dcd;
- __u32 rx;
- __u32 tx;
- __u32 frame;
- __u32 overrun;
- __u32 parity;
- __u32 brk;
-};
-
-struct sdio_uart_port {
- struct tty_port port;
- unsigned int index;
- struct sdio_func *func;
- struct mutex func_lock;
- struct task_struct *in_sdio_uart_irq;
- unsigned int regs_offset;
- struct kfifo xmit_fifo;
- spinlock_t write_lock;
- struct uart_icount icount;
- unsigned int uartclk;
- unsigned int mctrl;
- unsigned int rx_mctrl;
- unsigned int read_status_mask;
- unsigned int ignore_status_mask;
- unsigned char x_char;
- unsigned char ier;
- unsigned char lcr;
-};
-
-static struct sdio_uart_port *sdio_uart_table[UART_NR];
-static DEFINE_SPINLOCK(sdio_uart_table_lock);
-
-static int sdio_uart_add_port(struct sdio_uart_port *port)
-{
- int index, ret = -EBUSY;
-
- mutex_init(&port->func_lock);
- spin_lock_init(&port->write_lock);
- if (kfifo_alloc(&port->xmit_fifo, FIFO_SIZE, GFP_KERNEL))
- return -ENOMEM;
-
- spin_lock(&sdio_uart_table_lock);
- for (index = 0; index < UART_NR; index++) {
- if (!sdio_uart_table[index]) {
- port->index = index;
- sdio_uart_table[index] = port;
- ret = 0;
- break;
- }
- }
- spin_unlock(&sdio_uart_table_lock);
-
- return ret;
-}
-
-static struct sdio_uart_port *sdio_uart_port_get(unsigned index)
-{
- struct sdio_uart_port *port;
-
- if (index >= UART_NR)
- return NULL;
-
- spin_lock(&sdio_uart_table_lock);
- port = sdio_uart_table[index];
- if (port)
- tty_port_get(&port->port);
- spin_unlock(&sdio_uart_table_lock);
-
- return port;
-}
-
-static void sdio_uart_port_put(struct sdio_uart_port *port)
-{
- tty_port_put(&port->port);
-}
-
-static void sdio_uart_port_remove(struct sdio_uart_port *port)
-{
- struct sdio_func *func;
-
- spin_lock(&sdio_uart_table_lock);
- sdio_uart_table[port->index] = NULL;
- spin_unlock(&sdio_uart_table_lock);
-
- /*
- * We're killing a port that potentially still is in use by
- * the tty layer. Be careful to prevent any further access
- * to the SDIO function and arrange for the tty layer to
- * give up on that port ASAP.
- * Beware: the lock ordering is critical.
- */
- mutex_lock(&port->port.mutex);
- mutex_lock(&port->func_lock);
- func = port->func;
- sdio_claim_host(func);
- port->func = NULL;
- mutex_unlock(&port->func_lock);
- /* tty_hangup is async so is this safe as is ?? */
- tty_port_tty_hangup(&port->port, false);
- mutex_unlock(&port->port.mutex);
- sdio_release_irq(func);
- sdio_disable_func(func);
- sdio_release_host(func);
-
- sdio_uart_port_put(port);
-}
-
-static int sdio_uart_claim_func(struct sdio_uart_port *port)
-{
- mutex_lock(&port->func_lock);
- if (unlikely(!port->func)) {
- mutex_unlock(&port->func_lock);
- return -ENODEV;
- }
- if (likely(port->in_sdio_uart_irq != current))
- sdio_claim_host(port->func);
- mutex_unlock(&port->func_lock);
- return 0;
-}
-
-static inline void sdio_uart_release_func(struct sdio_uart_port *port)
-{
- if (likely(port->in_sdio_uart_irq != current))
- sdio_release_host(port->func);
-}
-
-static inline unsigned int sdio_in(struct sdio_uart_port *port, int offset)
-{
- unsigned char c;
- c = sdio_readb(port->func, port->regs_offset + offset, NULL);
- return c;
-}
-
-static inline void sdio_out(struct sdio_uart_port *port, int offset, int value)
-{
- sdio_writeb(port->func, value, port->regs_offset + offset, NULL);
-}
-
-static unsigned int sdio_uart_get_mctrl(struct sdio_uart_port *port)
-{
- unsigned char status;
- unsigned int ret;
-
- /* FIXME: What stops this losing the delta bits and breaking
- sdio_uart_check_modem_status ? */
- status = sdio_in(port, UART_MSR);
-
- ret = 0;
- if (status & UART_MSR_DCD)
- ret |= TIOCM_CAR;
- if (status & UART_MSR_RI)
- ret |= TIOCM_RNG;
- if (status & UART_MSR_DSR)
- ret |= TIOCM_DSR;
- if (status & UART_MSR_CTS)
- ret |= TIOCM_CTS;
- return ret;
-}
-
-static void sdio_uart_write_mctrl(struct sdio_uart_port *port,
- unsigned int mctrl)
-{
- unsigned char mcr = 0;
-
- if (mctrl & TIOCM_RTS)
- mcr |= UART_MCR_RTS;
- if (mctrl & TIOCM_DTR)
- mcr |= UART_MCR_DTR;
- if (mctrl & TIOCM_OUT1)
- mcr |= UART_MCR_OUT1;
- if (mctrl & TIOCM_OUT2)
- mcr |= UART_MCR_OUT2;
- if (mctrl & TIOCM_LOOP)
- mcr |= UART_MCR_LOOP;
-
- sdio_out(port, UART_MCR, mcr);
-}
-
-static inline void sdio_uart_update_mctrl(struct sdio_uart_port *port,
- unsigned int set, unsigned int clear)
-{
- unsigned int old;
-
- old = port->mctrl;
- port->mctrl = (old & ~clear) | set;
- if (old != port->mctrl)
- sdio_uart_write_mctrl(port, port->mctrl);
-}
-
-#define sdio_uart_set_mctrl(port, x) sdio_uart_update_mctrl(port, x, 0)
-#define sdio_uart_clear_mctrl(port, x) sdio_uart_update_mctrl(port, 0, x)
-
-static void sdio_uart_change_speed(struct sdio_uart_port *port,
- struct ktermios *termios,
- struct ktermios *old)
-{
- unsigned char cval, fcr = 0;
- unsigned int baud, quot;
-
- switch (termios->c_cflag & CSIZE) {
- case CS5:
- cval = UART_LCR_WLEN5;
- break;
- case CS6:
- cval = UART_LCR_WLEN6;
- break;
- case CS7:
- cval = UART_LCR_WLEN7;
- break;
- default:
- case CS8:
- cval = UART_LCR_WLEN8;
- break;
- }
-
- if (termios->c_cflag & CSTOPB)
- cval |= UART_LCR_STOP;
- if (termios->c_cflag & PARENB)
- cval |= UART_LCR_PARITY;
- if (!(termios->c_cflag & PARODD))
- cval |= UART_LCR_EPAR;
-
- for (;;) {
- baud = tty_termios_baud_rate(termios);
- if (baud == 0)
- baud = 9600; /* Special case: B0 rate. */
- if (baud <= port->uartclk)
- break;
- /*
- * Oops, the quotient was zero. Try again with the old
- * baud rate if possible, otherwise default to 9600.
- */
- termios->c_cflag &= ~CBAUD;
- if (old) {
- termios->c_cflag |= old->c_cflag & CBAUD;
- old = NULL;
- } else
- termios->c_cflag |= B9600;
- }
- quot = (2 * port->uartclk + baud) / (2 * baud);
-
- if (baud < 2400)
- fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
- else
- fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10;
-
- port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
- if (termios->c_iflag & INPCK)
- port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
- if (termios->c_iflag & (BRKINT | PARMRK))
- port->read_status_mask |= UART_LSR_BI;
-
- /*
- * Characters to ignore
- */
- port->ignore_status_mask = 0;
- if (termios->c_iflag & IGNPAR)
- port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
- if (termios->c_iflag & IGNBRK) {
- port->ignore_status_mask |= UART_LSR_BI;
- /*
- * If we're ignoring parity and break indicators,
- * ignore overruns too (for real raw support).
- */
- if (termios->c_iflag & IGNPAR)
- port->ignore_status_mask |= UART_LSR_OE;
- }
-
- /*
- * ignore all characters if CREAD is not set
- */
- if ((termios->c_cflag & CREAD) == 0)
- port->ignore_status_mask |= UART_LSR_DR;
-
- /*
- * CTS flow control flag and modem status interrupts
- */
- port->ier &= ~UART_IER_MSI;
- if ((termios->c_cflag & CRTSCTS) || !(termios->c_cflag & CLOCAL))
- port->ier |= UART_IER_MSI;
-
- port->lcr = cval;
-
- sdio_out(port, UART_IER, port->ier);
- sdio_out(port, UART_LCR, cval | UART_LCR_DLAB);
- sdio_out(port, UART_DLL, quot & 0xff);
- sdio_out(port, UART_DLM, quot >> 8);
- sdio_out(port, UART_LCR, cval);
- sdio_out(port, UART_FCR, fcr);
-
- sdio_uart_write_mctrl(port, port->mctrl);
-}
-
-static void sdio_uart_start_tx(struct sdio_uart_port *port)
-{
- if (!(port->ier & UART_IER_THRI)) {
- port->ier |= UART_IER_THRI;
- sdio_out(port, UART_IER, port->ier);
- }
-}
-
-static void sdio_uart_stop_tx(struct sdio_uart_port *port)
-{
- if (port->ier & UART_IER_THRI) {
- port->ier &= ~UART_IER_THRI;
- sdio_out(port, UART_IER, port->ier);
- }
-}
-
-static void sdio_uart_stop_rx(struct sdio_uart_port *port)
-{
- port->ier &= ~UART_IER_RLSI;
- port->read_status_mask &= ~UART_LSR_DR;
- sdio_out(port, UART_IER, port->ier);
-}
-
-static void sdio_uart_receive_chars(struct sdio_uart_port *port,
- unsigned int *status)
-{
- unsigned int ch, flag;
- int max_count = 256;
-
- do {
- ch = sdio_in(port, UART_RX);
- flag = TTY_NORMAL;
- port->icount.rx++;
-
- if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
- UART_LSR_FE | UART_LSR_OE))) {
- /*
- * For statistics only
- */
- if (*status & UART_LSR_BI) {
- *status &= ~(UART_LSR_FE | UART_LSR_PE);
- port->icount.brk++;
- } else if (*status & UART_LSR_PE)
- port->icount.parity++;
- else if (*status & UART_LSR_FE)
- port->icount.frame++;
- if (*status & UART_LSR_OE)
- port->icount.overrun++;
-
- /*
- * Mask off conditions which should be ignored.
- */
- *status &= port->read_status_mask;
- if (*status & UART_LSR_BI)
- flag = TTY_BREAK;
- else if (*status & UART_LSR_PE)
- flag = TTY_PARITY;
- else if (*status & UART_LSR_FE)
- flag = TTY_FRAME;
- }
-
- if ((*status & port->ignore_status_mask & ~UART_LSR_OE) == 0)
- tty_insert_flip_char(&port->port, ch, flag);
-
- /*
- * Overrun is special. Since it's reported immediately,
- * it doesn't affect the current character.
- */
- if (*status & ~port->ignore_status_mask & UART_LSR_OE)
- tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
-
- *status = sdio_in(port, UART_LSR);
- } while ((*status & UART_LSR_DR) && (max_count-- > 0));
-
- tty_flip_buffer_push(&port->port);
-}
-
-static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
-{
- struct kfifo *xmit = &port->xmit_fifo;
- int count;
- struct tty_struct *tty;
- u8 iobuf[16];
- int len;
-
- if (port->x_char) {
- sdio_out(port, UART_TX, port->x_char);
- port->icount.tx++;
- port->x_char = 0;
- return;
- }
-
- tty = tty_port_tty_get(&port->port);
-
- if (tty == NULL || !kfifo_len(xmit) ||
- tty->stopped || tty->hw_stopped) {
- sdio_uart_stop_tx(port);
- tty_kref_put(tty);
- return;
- }
-
- len = kfifo_out_locked(xmit, iobuf, 16, &port->write_lock);
- for (count = 0; count < len; count++) {
- sdio_out(port, UART_TX, iobuf[count]);
- port->icount.tx++;
- }
-
- len = kfifo_len(xmit);
- if (len < WAKEUP_CHARS) {
- tty_wakeup(tty);
- if (len == 0)
- sdio_uart_stop_tx(port);
- }
- tty_kref_put(tty);
-}
-
-static void sdio_uart_check_modem_status(struct sdio_uart_port *port)
-{
- int status;
- struct tty_struct *tty;
-
- status = sdio_in(port, UART_MSR);
-
- if ((status & UART_MSR_ANY_DELTA) == 0)
- return;
-
- if (status & UART_MSR_TERI)
- port->icount.rng++;
- if (status & UART_MSR_DDSR)
- port->icount.dsr++;
- if (status & UART_MSR_DDCD) {
- port->icount.dcd++;
- /* DCD raise - wake for open */
- if (status & UART_MSR_DCD)
- wake_up_interruptible(&port->port.open_wait);
- else {
- /* DCD drop - hang up if tty attached */
- tty_port_tty_hangup(&port->port, false);
- }
- }
- if (status & UART_MSR_DCTS) {
- port->icount.cts++;
- tty = tty_port_tty_get(&port->port);
- if (tty && C_CRTSCTS(tty)) {
- int cts = (status & UART_MSR_CTS);
- if (tty->hw_stopped) {
- if (cts) {
- tty->hw_stopped = 0;
- sdio_uart_start_tx(port);
- tty_wakeup(tty);
- }
- } else {
- if (!cts) {
- tty->hw_stopped = 1;
- sdio_uart_stop_tx(port);
- }
- }
- }
- tty_kref_put(tty);
- }
-}
-
-/*
- * This handles the interrupt from one port.
- */
-static void sdio_uart_irq(struct sdio_func *func)
-{
- struct sdio_uart_port *port = sdio_get_drvdata(func);
- unsigned int iir, lsr;
-
- /*
- * In a few places sdio_uart_irq() is called directly instead of
- * waiting for the actual interrupt to be raised and the SDIO IRQ
- * thread scheduled in order to reduce latency. However, some
- * interaction with the tty core may end up calling us back
- * (serial echo, flow control, etc.) through those same places
- * causing undesirable effects. Let's stop the recursion here.
- */
- if (unlikely(port->in_sdio_uart_irq == current))
- return;
-
- iir = sdio_in(port, UART_IIR);
- if (iir & UART_IIR_NO_INT)
- return;
-
- port->in_sdio_uart_irq = current;
- lsr = sdio_in(port, UART_LSR);
- if (lsr & UART_LSR_DR)
- sdio_uart_receive_chars(port, &lsr);
- sdio_uart_check_modem_status(port);
- if (lsr & UART_LSR_THRE)
- sdio_uart_transmit_chars(port);
- port->in_sdio_uart_irq = NULL;
-}
-
-static int uart_carrier_raised(struct tty_port *tport)
-{
- struct sdio_uart_port *port =
- container_of(tport, struct sdio_uart_port, port);
- unsigned int ret = sdio_uart_claim_func(port);
- if (ret) /* Missing hardware shouldn't block for carrier */
- return 1;
- ret = sdio_uart_get_mctrl(port);
- sdio_uart_release_func(port);
- if (ret & TIOCM_CAR)
- return 1;
- return 0;
-}
-
-/**
- * uart_dtr_rts - port helper to set uart signals
- * @tport: tty port to be updated
- * @onoff: set to turn on DTR/RTS
- *
- * Called by the tty port helpers when the modem signals need to be
- * adjusted during an open, close and hangup.
- */
-
-static void uart_dtr_rts(struct tty_port *tport, int onoff)
-{
- struct sdio_uart_port *port =
- container_of(tport, struct sdio_uart_port, port);
- int ret = sdio_uart_claim_func(port);
- if (ret)
- return;
- if (onoff == 0)
- sdio_uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
- else
- sdio_uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
- sdio_uart_release_func(port);
-}
-
-/**
- * sdio_uart_activate - start up hardware
- * @tport: tty port to activate
- * @tty: tty bound to this port
- *
- * Activate a tty port. The port locking guarantees us this will be
- * run exactly once per set of opens, and if successful will see the
- * shutdown method run exactly once to match. Start up and shutdown are
- * protected from each other by the internal locking and will not run
- * at the same time even during a hangup event.
- *
- * If we successfully start up the port we take an extra kref as we
- * will keep it around until shutdown when the kref is dropped.
- */
-
-static int sdio_uart_activate(struct tty_port *tport, struct tty_struct *tty)
-{
- struct sdio_uart_port *port =
- container_of(tport, struct sdio_uart_port, port);
- int ret;
-
- /*
- * Set the TTY IO error marker - we will only clear this
- * once we have successfully opened the port.
- */
- set_bit(TTY_IO_ERROR, &tty->flags);
-
- kfifo_reset(&port->xmit_fifo);
-
- ret = sdio_uart_claim_func(port);
- if (ret)
- return ret;
- ret = sdio_enable_func(port->func);
- if (ret)
- goto err1;
- ret = sdio_claim_irq(port->func, sdio_uart_irq);
- if (ret)
- goto err2;
-
- /*
- * Clear the FIFO buffers and disable them.
- * (they will be reenabled in sdio_change_speed())
- */
- sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
- sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO |
- UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
- sdio_out(port, UART_FCR, 0);
-
- /*
- * Clear the interrupt registers.
- */
- (void) sdio_in(port, UART_LSR);
- (void) sdio_in(port, UART_RX);
- (void) sdio_in(port, UART_IIR);
- (void) sdio_in(port, UART_MSR);
-
- /*
- * Now, initialize the UART
- */
- sdio_out(port, UART_LCR, UART_LCR_WLEN8);
-
- port->ier = UART_IER_RLSI|UART_IER_RDI|UART_IER_RTOIE|UART_IER_UUE;
- port->mctrl = TIOCM_OUT2;
-
- sdio_uart_change_speed(port, &tty->termios, NULL);
-
- if (C_BAUD(tty))
- sdio_uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
-
- if (C_CRTSCTS(tty))
- if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS))
- tty->hw_stopped = 1;
-
- clear_bit(TTY_IO_ERROR, &tty->flags);
-
- /* Kick the IRQ handler once while we're still holding the host lock */
- sdio_uart_irq(port->func);
-
- sdio_uart_release_func(port);
- return 0;
-
-err2:
- sdio_disable_func(port->func);
-err1:
- sdio_uart_release_func(port);
- return ret;
-}
-
-/**
- * sdio_uart_shutdown - stop hardware
- * @tport: tty port to shut down
- *
- * Deactivate a tty port. The port locking guarantees us this will be
- * run only if a successful matching activate already ran. The two are
- * protected from each other by the internal locking and will not run
- * at the same time even during a hangup event.
- */
-
-static void sdio_uart_shutdown(struct tty_port *tport)
-{
- struct sdio_uart_port *port =
- container_of(tport, struct sdio_uart_port, port);
- int ret;
-
- ret = sdio_uart_claim_func(port);
- if (ret)
- return;
-
- sdio_uart_stop_rx(port);
-
- /* Disable interrupts from this port */
- sdio_release_irq(port->func);
- port->ier = 0;
- sdio_out(port, UART_IER, 0);
-
- sdio_uart_clear_mctrl(port, TIOCM_OUT2);
-
- /* Disable break condition and FIFOs. */
- port->lcr &= ~UART_LCR_SBC;
- sdio_out(port, UART_LCR, port->lcr);
- sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO |
- UART_FCR_CLEAR_RCVR |
- UART_FCR_CLEAR_XMIT);
- sdio_out(port, UART_FCR, 0);
-
- sdio_disable_func(port->func);
-
- sdio_uart_release_func(port);
-}
-
-static void sdio_uart_port_destroy(struct tty_port *tport)
-{
- struct sdio_uart_port *port =
- container_of(tport, struct sdio_uart_port, port);
- kfifo_free(&port->xmit_fifo);
- kfree(port);
-}
-
-/**
- * sdio_uart_install - install method
- * @driver: the driver in use (sdio_uart in our case)
- * @tty: the tty being bound
- *
- * Look up and bind the tty and the driver together. Initialize
- * any needed private data (in our case the termios)
- */
-
-static int sdio_uart_install(struct tty_driver *driver, struct tty_struct *tty)
-{
- int idx = tty->index;
- struct sdio_uart_port *port = sdio_uart_port_get(idx);
- int ret = tty_standard_install(driver, tty);
-
- if (ret == 0)
- /* This is the ref sdio_uart_port get provided */
- tty->driver_data = port;
- else
- sdio_uart_port_put(port);
- return ret;
-}
-
-/**
- * sdio_uart_cleanup - called on the last tty kref drop
- * @tty: the tty being destroyed
- *
- * Called asynchronously when the last reference to the tty is dropped.
- * We cannot destroy the tty->driver_data port kref until this point
- */
-
-static void sdio_uart_cleanup(struct tty_struct *tty)
-{
- struct sdio_uart_port *port = tty->driver_data;
- tty->driver_data = NULL; /* Bug trap */
- sdio_uart_port_put(port);
-}
-
-/*
- * Open/close/hangup is now entirely boilerplate
- */
-
-static int sdio_uart_open(struct tty_struct *tty, struct file *filp)
-{
- struct sdio_uart_port *port = tty->driver_data;
- return tty_port_open(&port->port, tty, filp);
-}
-
-static void sdio_uart_close(struct tty_struct *tty, struct file * filp)
-{
- struct sdio_uart_port *port = tty->driver_data;
- tty_port_close(&port->port, tty, filp);
-}
-
-static void sdio_uart_hangup(struct tty_struct *tty)
-{
- struct sdio_uart_port *port = tty->driver_data;
- tty_port_hangup(&port->port);
-}
-
-static int sdio_uart_write(struct tty_struct *tty, const unsigned char *buf,
- int count)
-{
- struct sdio_uart_port *port = tty->driver_data;
- int ret;
-
- if (!port->func)
- return -ENODEV;
-
- ret = kfifo_in_locked(&port->xmit_fifo, buf, count, &port->write_lock);
- if (!(port->ier & UART_IER_THRI)) {
- int err = sdio_uart_claim_func(port);
- if (!err) {
- sdio_uart_start_tx(port);
- sdio_uart_irq(port->func);
- sdio_uart_release_func(port);
- } else
- ret = err;
- }
-
- return ret;
-}
-
-static int sdio_uart_write_room(struct tty_struct *tty)
-{
- struct sdio_uart_port *port = tty->driver_data;
- return FIFO_SIZE - kfifo_len(&port->xmit_fifo);
-}
-
-static int sdio_uart_chars_in_buffer(struct tty_struct *tty)
-{
- struct sdio_uart_port *port = tty->driver_data;
- return kfifo_len(&port->xmit_fifo);
-}
-
-static void sdio_uart_send_xchar(struct tty_struct *tty, char ch)
-{
- struct sdio_uart_port *port = tty->driver_data;
-
- port->x_char = ch;
- if (ch && !(port->ier & UART_IER_THRI)) {
- if (sdio_uart_claim_func(port) != 0)
- return;
- sdio_uart_start_tx(port);
- sdio_uart_irq(port->func);
- sdio_uart_release_func(port);
- }
-}
-
-static void sdio_uart_throttle(struct tty_struct *tty)
-{
- struct sdio_uart_port *port = tty->driver_data;
-
- if (!I_IXOFF(tty) && !C_CRTSCTS(tty))
- return;
-
- if (sdio_uart_claim_func(port) != 0)
- return;
-
- if (I_IXOFF(tty)) {
- port->x_char = STOP_CHAR(tty);
- sdio_uart_start_tx(port);
- }
-
- if (C_CRTSCTS(tty))
- sdio_uart_clear_mctrl(port, TIOCM_RTS);
-
- sdio_uart_irq(port->func);
- sdio_uart_release_func(port);
-}
-
-static void sdio_uart_unthrottle(struct tty_struct *tty)
-{
- struct sdio_uart_port *port = tty->driver_data;
-
- if (!I_IXOFF(tty) && !C_CRTSCTS(tty))
- return;
-
- if (sdio_uart_claim_func(port) != 0)
- return;
-
- if (I_IXOFF(tty)) {
- if (port->x_char) {
- port->x_char = 0;
- } else {
- port->x_char = START_CHAR(tty);
- sdio_uart_start_tx(port);
- }
- }
-
- if (C_CRTSCTS(tty))
- sdio_uart_set_mctrl(port, TIOCM_RTS);
-
- sdio_uart_irq(port->func);
- sdio_uart_release_func(port);
-}
-
-static void sdio_uart_set_termios(struct tty_struct *tty,
- struct ktermios *old_termios)
-{
- struct sdio_uart_port *port = tty->driver_data;
- unsigned int cflag = tty->termios.c_cflag;
-
- if (sdio_uart_claim_func(port) != 0)
- return;
-
- sdio_uart_change_speed(port, &tty->termios, old_termios);
-
- /* Handle transition to B0 status */
- if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
- sdio_uart_clear_mctrl(port, TIOCM_RTS | TIOCM_DTR);
-
- /* Handle transition away from B0 status */
- if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
- unsigned int mask = TIOCM_DTR;
- if (!(cflag & CRTSCTS) || !tty_throttled(tty))
- mask |= TIOCM_RTS;
- sdio_uart_set_mctrl(port, mask);
- }
-
- /* Handle turning off CRTSCTS */
- if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
- tty->hw_stopped = 0;
- sdio_uart_start_tx(port);
- }
-
- /* Handle turning on CRTSCTS */
- if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
- if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS)) {
- tty->hw_stopped = 1;
- sdio_uart_stop_tx(port);
- }
- }
-
- sdio_uart_release_func(port);
-}
-
-static int sdio_uart_break_ctl(struct tty_struct *tty, int break_state)
-{
- struct sdio_uart_port *port = tty->driver_data;
- int result;
-
- result = sdio_uart_claim_func(port);
- if (result != 0)
- return result;
-
- if (break_state == -1)
- port->lcr |= UART_LCR_SBC;
- else
- port->lcr &= ~UART_LCR_SBC;
- sdio_out(port, UART_LCR, port->lcr);
-
- sdio_uart_release_func(port);
- return 0;
-}
-
-static int sdio_uart_tiocmget(struct tty_struct *tty)
-{
- struct sdio_uart_port *port = tty->driver_data;
- int result;
-
- result = sdio_uart_claim_func(port);
- if (!result) {
- result = port->mctrl | sdio_uart_get_mctrl(port);
- sdio_uart_release_func(port);
- }
-
- return result;
-}
-
-static int sdio_uart_tiocmset(struct tty_struct *tty,
- unsigned int set, unsigned int clear)
-{
- struct sdio_uart_port *port = tty->driver_data;
- int result;
-
- result = sdio_uart_claim_func(port);
- if (!result) {
- sdio_uart_update_mctrl(port, set, clear);
- sdio_uart_release_func(port);
- }
-
- return result;
-}
-
-static int sdio_uart_proc_show(struct seq_file *m, void *v)
-{
- int i;
-
- seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n",
- "", "", "");
- for (i = 0; i < UART_NR; i++) {
- struct sdio_uart_port *port = sdio_uart_port_get(i);
- if (port) {
- seq_printf(m, "%d: uart:SDIO", i);
- if (capable(CAP_SYS_ADMIN)) {
- seq_printf(m, " tx:%d rx:%d",
- port->icount.tx, port->icount.rx);
- if (port->icount.frame)
- seq_printf(m, " fe:%d",
- port->icount.frame);
- if (port->icount.parity)
- seq_printf(m, " pe:%d",
- port->icount.parity);
- if (port->icount.brk)
- seq_printf(m, " brk:%d",
- port->icount.brk);
- if (port->icount.overrun)
- seq_printf(m, " oe:%d",
- port->icount.overrun);
- if (port->icount.cts)
- seq_printf(m, " cts:%d",
- port->icount.cts);
- if (port->icount.dsr)
- seq_printf(m, " dsr:%d",
- port->icount.dsr);
- if (port->icount.rng)
- seq_printf(m, " rng:%d",
- port->icount.rng);
- if (port->icount.dcd)
- seq_printf(m, " dcd:%d",
- port->icount.dcd);
- }
- sdio_uart_port_put(port);
- seq_putc(m, '\n');
- }
- }
- return 0;
-}
-
-static int sdio_uart_proc_open(struct inode *inode, struct file *file)
-{
- return single_open(file, sdio_uart_proc_show, NULL);
-}
-
-static const struct file_operations sdio_uart_proc_fops = {
- .owner = THIS_MODULE,
- .open = sdio_uart_proc_open,
- .read = seq_read,
- .llseek = seq_lseek,
- .release = single_release,
-};
-
-static const struct tty_port_operations sdio_uart_port_ops = {
- .dtr_rts = uart_dtr_rts,
- .carrier_raised = uart_carrier_raised,
- .shutdown = sdio_uart_shutdown,
- .activate = sdio_uart_activate,
- .destruct = sdio_uart_port_destroy,
-};
-
-static const struct tty_operations sdio_uart_ops = {
- .open = sdio_uart_open,
- .close = sdio_uart_close,
- .write = sdio_uart_write,
- .write_room = sdio_uart_write_room,
- .chars_in_buffer = sdio_uart_chars_in_buffer,
- .send_xchar = sdio_uart_send_xchar,
- .throttle = sdio_uart_throttle,
- .unthrottle = sdio_uart_unthrottle,
- .set_termios = sdio_uart_set_termios,
- .hangup = sdio_uart_hangup,
- .break_ctl = sdio_uart_break_ctl,
- .tiocmget = sdio_uart_tiocmget,
- .tiocmset = sdio_uart_tiocmset,
- .install = sdio_uart_install,
- .cleanup = sdio_uart_cleanup,
- .proc_fops = &sdio_uart_proc_fops,
-};
-
-static struct tty_driver *sdio_uart_tty_driver;
-
-static int sdio_uart_probe(struct sdio_func *func,
- const struct sdio_device_id *id)
-{
- struct sdio_uart_port *port;
- int ret;
-
- port = kzalloc(sizeof(struct sdio_uart_port), GFP_KERNEL);
- if (!port)
- return -ENOMEM;
-
- if (func->class == SDIO_CLASS_UART) {
- pr_warn("%s: need info on UART class basic setup\n",
- sdio_func_id(func));
- kfree(port);
- return -ENOSYS;
- } else if (func->class == SDIO_CLASS_GPS) {
- /*
- * We need tuple 0x91. It contains SUBTPL_SIOREG
- * and SUBTPL_RCVCAPS.
- */
- struct sdio_func_tuple *tpl;
- for (tpl = func->tuples; tpl; tpl = tpl->next) {
- if (tpl->code != 0x91)
- continue;
- if (tpl->size < 10)
- continue;
- if (tpl->data[1] == 0) /* SUBTPL_SIOREG */
- break;
- }
- if (!tpl) {
- pr_warn("%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
- sdio_func_id(func));
- kfree(port);
- return -EINVAL;
- }
- pr_debug("%s: Register ID = 0x%02x, Exp ID = 0x%02x\n",
- sdio_func_id(func), tpl->data[2], tpl->data[3]);
- port->regs_offset = (tpl->data[4] << 0) |
- (tpl->data[5] << 8) |
- (tpl->data[6] << 16);
- pr_debug("%s: regs offset = 0x%x\n",
- sdio_func_id(func), port->regs_offset);
- port->uartclk = tpl->data[7] * 115200;
- if (port->uartclk == 0)
- port->uartclk = 115200;
- pr_debug("%s: clk %d baudcode %u 4800-div %u\n",
- sdio_func_id(func), port->uartclk,
- tpl->data[7], tpl->data[8] | (tpl->data[9] << 8));
- } else {
- kfree(port);
- return -EINVAL;
- }
-
- port->func = func;
- sdio_set_drvdata(func, port);
- tty_port_init(&port->port);
- port->port.ops = &sdio_uart_port_ops;
-
- ret = sdio_uart_add_port(port);
- if (ret) {
- kfree(port);
- } else {
- struct device *dev;
- dev = tty_port_register_device(&port->port,
- sdio_uart_tty_driver, port->index, &func->dev);
- if (IS_ERR(dev)) {
- sdio_uart_port_remove(port);
- ret = PTR_ERR(dev);
- }
- }
-
- return ret;
-}
-
-static void sdio_uart_remove(struct sdio_func *func)
-{
- struct sdio_uart_port *port = sdio_get_drvdata(func);
-
- tty_unregister_device(sdio_uart_tty_driver, port->index);
- sdio_uart_port_remove(port);
-}
-
-static const struct sdio_device_id sdio_uart_ids[] = {
- { SDIO_DEVICE_CLASS(SDIO_CLASS_UART) },
- { SDIO_DEVICE_CLASS(SDIO_CLASS_GPS) },
- { /* end: all zeroes */ },
-};
-
-MODULE_DEVICE_TABLE(sdio, sdio_uart_ids);
-
-static struct sdio_driver sdio_uart_driver = {
- .probe = sdio_uart_probe,
- .remove = sdio_uart_remove,
- .name = "sdio_uart",
- .id_table = sdio_uart_ids,
-};
-
-static int __init sdio_uart_init(void)
-{
- int ret;
- struct tty_driver *tty_drv;
-
- sdio_uart_tty_driver = tty_drv = alloc_tty_driver(UART_NR);
- if (!tty_drv)
- return -ENOMEM;
-
- tty_drv->driver_name = "sdio_uart";
- tty_drv->name = "ttySDIO";
- tty_drv->major = 0; /* dynamically allocated */
- tty_drv->minor_start = 0;
- tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
- tty_drv->subtype = SERIAL_TYPE_NORMAL;
- tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
- tty_drv->init_termios = tty_std_termios;
- tty_drv->init_termios.c_cflag = B4800 | CS8 | CREAD | HUPCL | CLOCAL;
- tty_drv->init_termios.c_ispeed = 4800;
- tty_drv->init_termios.c_ospeed = 4800;
- tty_set_operations(tty_drv, &sdio_uart_ops);
-
- ret = tty_register_driver(tty_drv);
- if (ret)
- goto err1;
-
- ret = sdio_register_driver(&sdio_uart_driver);
- if (ret)
- goto err2;
-
- return 0;
-
-err2:
- tty_unregister_driver(tty_drv);
-err1:
- put_tty_driver(tty_drv);
- return ret;
-}
-
-static void __exit sdio_uart_exit(void)
-{
- sdio_unregister_driver(&sdio_uart_driver);
- tty_unregister_driver(sdio_uart_tty_driver);
- put_tty_driver(sdio_uart_tty_driver);
-}
-
-module_init(sdio_uart_init);
-module_exit(sdio_uart_exit);
-
-MODULE_AUTHOR("Nicolas Pitre");
-MODULE_LICENSE("GPL");