static ssize_t ufsdbg_tag_stats_write(struct file *filp,
const char __user *ubuf, size_t cnt,
loff_t *ppos)
{
struct ufs_hba *hba = filp->f_mapping->host->i_private;
struct ufs_stats *ufs_stats;
int val = 0;
int ret;
unsigned long flags;
ret = kstrtoint_from_user(ubuf, cnt, 0, &val);
if (ret) {
dev_err(hba->dev, "%s: Invalid argument\n", __func__);
return ret;
}
ufs_stats = &hba->ufs_stats;
spin_lock_irqsave(hba->host->host_lock, flags);
if (!val) {
ufs_stats->enabled = false;
pr_debug("%s: Disabling UFS tag statistics", __func__);
} else {
ufs_stats->enabled = true;
pr_debug("%s: Enabling & Resetting UFS tag statistics",
__func__);
memset(ufs_stats->tag_stats, 0,
sizeof(*ufs_stats->tag_stats) * hba->nutrs);
}
spin_unlock_irqrestore(hba->host->host_lock, flags);
return cnt;
}
static ssize_t syswp_proc_write(struct file *file, const char *buf,
size_t count, loff_t *pos)
{
int ret, value;
if ((count <= 0) || (count > 2))
return -EINVAL;
ret = kstrtoint_from_user(buf, count, 10, &value);
if (ret)
return ret;
blk_set_ro_secure_debuggable(!!value);
return count;
}
static ssize_t apb_log_enable_write(struct file *f, const char __user *buf,
size_t count, loff_t *ppos)
{
int enable;
ssize_t retval;
struct es2_ap_dev *es2 = f->f_inode->i_private;
retval = kstrtoint_from_user(buf, count, 10, &enable);
if (retval)
return retval;
if (enable)
usb_log_enable(es2);
else
usb_log_disable(es2);
return count;
}
static ssize_t ufs_test_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos, int test_case)
{
int ret = 0;
int i;
int number;
ret = kstrtoint_from_user(buf, count, 0, &number);
if (ret < 0) {
pr_err("%s: Error while reading test parameter value %d",
__func__, ret);
return ret;
}
if (number <= 0)
number = 1;
pr_info("%s:the test will run for %d iterations.", __func__, number);
memset(&utd->test_info, 0, sizeof(struct test_info));
/* Initializing test */
utd->test_info.data = utd;
utd->test_info.get_test_case_str_fn = ufs_test_get_test_case_str;
utd->test_info.testcase = test_case;
utd->test_info.get_rq_disk_fn = ufs_test_get_rq_disk;
utd->test_info.check_test_result_fn = ufs_test_check_result;
utd->test_stage = DEFAULT;
switch (test_case) {
case UFS_TEST_WRITE_READ_TEST:
utd->test_info.run_test_fn = ufs_test_run_write_read_test;
utd->test_info.check_test_completion_fn =
ufs_write_read_completion;
break;
case UFS_TEST_MULTI_QUERY:
utd->test_info.run_test_fn = ufs_test_run_multi_query_test;
utd->test_info.check_test_result_fn = ufs_test_check_result;
break;
case UFS_TEST_LONG_SEQUENTIAL_READ:
case UFS_TEST_LONG_SEQUENTIAL_WRITE:
utd->test_info.run_test_fn = run_long_seq_test;
utd->test_info.post_test_fn = long_seq_test_calc_throughput;
utd->test_info.check_test_result_fn = ufs_test_check_result;
utd->test_info.check_test_completion_fn =
long_seq_test_check_completion;
break;
case UFS_TEST_LONG_SEQUENTIAL_MIXED:
utd->test_info.timeout_msec = LONG_SEQUENTIAL_MIXED_TIMOUT_MS;
utd->test_info.run_test_fn = run_mixed_long_seq_test;
utd->test_info.post_test_fn = long_seq_test_calc_throughput;
utd->test_info.check_test_result_fn = ufs_test_check_result;
break;
case UFS_TEST_PARALLEL_READ_AND_WRITE:
utd->test_info.run_test_fn =
ufs_test_run_parallel_read_and_write_test;
utd->test_info.check_test_completion_fn =
ufs_test_multi_thread_completion;
break;
case UFS_TEST_LUN_DEPTH:
utd->test_info.run_test_fn = ufs_test_run_lun_depth_test;
break;
default:
pr_err("%s: Unknown test-case: %d", __func__, test_case);
WARN_ON(true);
}
/* Running the test multiple times */
for (i = 0; i < number; ++i) {
pr_info("%s: Cycle # %d / %d", __func__, i+1, number);
pr_info("%s: ====================", __func__);
utd->test_info.test_byte_count = 0;
ret = test_iosched_start_test(&utd->test_info);
if (ret) {
pr_err("%s: Test failed, err=%d.", __func__, ret);
return ret;
}
/* Allow FS requests to be dispatched */
msleep(1000);
}
pr_info("%s: Completed all the ufs test iterations.", __func__);
return count;
}
