| /* |
| *Copyright (c) 2014-2015, The Linux Foundation. All rights reserved. |
| * |
| *This program is free software; you can redistribute it and/or modify |
| *it under the terms of the GNU General Public License version 2 and |
| *only version 2 as published by the Free Software Foundation. |
| * |
| *This program is distributed in the hope that it will be useful, |
| *but WITHOUT ANY WARRANTY; without even the implied warranty of |
| *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| *GNU General Public License for more details. |
| */ |
| #include <linux/debugfs.h> |
| #include <linux/device.h> |
| #include <linux/module.h> |
| #include <linux/msm-bus.h> |
| #include <linux/slab.h> |
| #include <linux/uaccess.h> |
| #include "devfreq_spdm.h" |
| #include "governor.h" |
| |
| static int spdm_open(struct inode *inode, struct file *file) |
| { |
| file->private_data = inode->i_private; |
| return 0; |
| } |
| |
| static char buf[PAGE_SIZE]; |
| |
| static ssize_t enable_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i; |
| int next_idx; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| goto err; |
| size = -EINVAL; |
| } |
| |
| if (sscanf(buf, "%u\n", &i) != 1) { |
| size = -EINVAL; |
| goto err; |
| } |
| i = !!i; |
| |
| if (i == spdm_data->enabled) |
| goto out; |
| |
| spdm_data->devfreq->governor->event_handler(spdm_data->devfreq, |
| i ? DEVFREQ_GOV_START : |
| DEVFREQ_GOV_STOP, NULL); |
| |
| if (!i) { |
| next_idx = spdm_data->cur_idx + 1; |
| next_idx = next_idx % 2; |
| |
| for (i = 0; i < spdm_data->pdata->usecase[next_idx].num_paths; |
| i++) |
| spdm_data->pdata->usecase[next_idx].vectors[i].ab = 0; |
| |
| spdm_data->cur_idx = next_idx; |
| msm_bus_scale_client_update_request |
| (spdm_data->bus_scale_client_id, spdm_data->cur_idx); |
| } |
| |
| out: |
| *offset += size; |
| err: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t enable_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int len = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| len = scnprintf(buf, size, "%u\n", spdm_data->enabled); |
| len = simple_read_from_buffer(data, size, offset, buf, len); |
| |
| memset(buf, 0, sizeof(buf)); |
| return len; |
| } |
| |
| static const struct file_operations enable_fops = { |
| .open = spdm_open, |
| .write = enable_write, |
| .read = enable_read, |
| }; |
| |
| static ssize_t pl_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| int i; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| if (sscanf(buf, "%u %u\n", &spdm_data->config_data.pl_freqs[0], |
| &spdm_data->config_data.pl_freqs[1]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_PL; |
| desc.arg[1] = spdm_data->spdm_client; |
| for (i = 0; i < SPDM_PL_COUNT - 1; i++) |
| desc.arg[i+2] = spdm_data->config_data.pl_freqs[i]; |
| ext_status = spdm_ext_call(&desc, SPDM_PL_COUNT + 1); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| |
| } |
| |
| static ssize_t pl_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", spdm_data->config_data.pl_freqs[0], |
| spdm_data->config_data.pl_freqs[1]); |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations pl_fops = { |
| .open = spdm_open, |
| .write = pl_write, |
| .read = pl_read, |
| }; |
| |
| static ssize_t rejrate_low_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| if (sscanf(buf, "%u %u\n", &spdm_data->config_data.reject_rate[0], |
| &spdm_data->config_data.reject_rate[1]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_REJRATE_LOW; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.reject_rate[0]; |
| desc.arg[3] = spdm_data->config_data.reject_rate[1]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t rejrate_low_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.reject_rate[0], |
| spdm_data->config_data.reject_rate[1]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations rrl_fops = { |
| .open = spdm_open, |
| .write = rejrate_low_write, |
| .read = rejrate_low_read, |
| }; |
| |
| static ssize_t rejrate_med_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", &spdm_data->config_data.reject_rate[2], |
| &spdm_data->config_data.reject_rate[3]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_REJRATE_MED; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.reject_rate[2]; |
| desc.arg[3] = spdm_data->config_data.reject_rate[3]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t rejrate_med_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.reject_rate[2], |
| spdm_data->config_data.reject_rate[3]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations rrm_fops = { |
| .open = spdm_open, |
| .write = rejrate_med_write, |
| .read = rejrate_med_read, |
| }; |
| |
| static ssize_t rejrate_high_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", &spdm_data->config_data.reject_rate[4], |
| &spdm_data->config_data.reject_rate[5]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_REJRATE_HIGH; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.reject_rate[4]; |
| desc.arg[3] = spdm_data->config_data.reject_rate[5]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t rejrate_high_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.reject_rate[4], |
| spdm_data->config_data.reject_rate[5]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations rrh_fops = { |
| .open = spdm_open, |
| .write = rejrate_high_write, |
| .read = rejrate_high_read, |
| }; |
| |
| static ssize_t resptime_low_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", &spdm_data->config_data.response_time_us[0], |
| &spdm_data->config_data.response_time_us[1]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_RESPTIME_LOW; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.response_time_us[0]; |
| desc.arg[3] = spdm_data->config_data.response_time_us[1]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t resptime_low_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.response_time_us[0], |
| spdm_data->config_data.response_time_us[1]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations rtl_fops = { |
| .open = spdm_open, |
| .write = resptime_low_write, |
| .read = resptime_low_read, |
| }; |
| |
| static ssize_t resptime_med_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", &spdm_data->config_data.response_time_us[2], |
| &spdm_data->config_data.response_time_us[3]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_RESPTIME_MED; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.response_time_us[2]; |
| desc.arg[3] = spdm_data->config_data.response_time_us[3]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t resptime_med_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.response_time_us[2], |
| spdm_data->config_data.response_time_us[3]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations rtm_fops = { |
| .open = spdm_open, |
| .write = resptime_med_write, |
| .read = resptime_med_read, |
| }; |
| |
| static ssize_t resptime_high_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", &spdm_data->config_data.response_time_us[4], |
| &spdm_data->config_data.response_time_us[5]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_RESPTIME_HIGH; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.response_time_us[4]; |
| desc.arg[3] = spdm_data->config_data.response_time_us[5]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t resptime_high_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.response_time_us[4], |
| spdm_data->config_data.response_time_us[5]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations rth_fops = { |
| .open = spdm_open, |
| .write = resptime_high_write, |
| .read = resptime_high_read, |
| }; |
| |
| static ssize_t cciresptime_low_write(struct file *file, |
| const char __user *data, size_t size, |
| loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", |
| &spdm_data->config_data.cci_response_time_us[0], |
| &spdm_data->config_data.cci_response_time_us[1]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_CCIRESPTIME_LOW; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.cci_response_time_us[0]; |
| desc.arg[3] = spdm_data->config_data.cci_response_time_us[1]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t cciresptime_low_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.cci_response_time_us[0], |
| spdm_data->config_data.cci_response_time_us[1]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations ccil_fops = { |
| .open = spdm_open, |
| .write = cciresptime_low_write, |
| .read = cciresptime_low_read, |
| }; |
| |
| static ssize_t cciresptime_med_write(struct file *file, |
| const char __user *data, size_t size, |
| loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", |
| &spdm_data->config_data.cci_response_time_us[2], |
| &spdm_data->config_data.cci_response_time_us[3]) != 2) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_CCIRESPTIME_MED; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.cci_response_time_us[2]; |
| desc.arg[3] = spdm_data->config_data.cci_response_time_us[3]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t cciresptime_med_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.cci_response_time_us[2], |
| spdm_data->config_data.cci_response_time_us[3]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations ccim_fops = { |
| .open = spdm_open, |
| .write = cciresptime_med_write, |
| .read = cciresptime_med_read, |
| }; |
| |
| static ssize_t cciresptime_high_write(struct file *file, |
| const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u\n", |
| &spdm_data->config_data.cci_response_time_us[4], |
| &spdm_data->config_data.cci_response_time_us[5]) != 2){ |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_CCIRESPTIME_HIGH; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.cci_response_time_us[4]; |
| desc.arg[3] = spdm_data->config_data.cci_response_time_us[5]; |
| ext_status = spdm_ext_call(&desc, 4); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t cciresptime_high_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u\n", |
| spdm_data->config_data.cci_response_time_us[4], |
| spdm_data->config_data.cci_response_time_us[5]); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations ccih_fops = { |
| .open = spdm_open, |
| .write = cciresptime_high_write, |
| .read = cciresptime_high_read, |
| }; |
| |
| static ssize_t cci_max_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u\n", &spdm_data->config_data.max_cci_freq) != 1) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_MAXCCI; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.max_cci_freq; |
| ext_status = spdm_ext_call(&desc, 3); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t cci_max_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u\n", spdm_data->config_data.max_cci_freq); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations ccimax_fops = { |
| .open = spdm_open, |
| .write = cci_max_write, |
| .read = cci_max_read, |
| }; |
| |
| static ssize_t vote_cfg_write(struct file *file, const char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| struct spdm_args desc = { { 0 } }; |
| int ext_status = 0; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| if (copy_from_user(buf, data, size)) { |
| size = -EINVAL; |
| goto out; |
| } |
| if (sscanf(buf, "%u %u %u %u\n", &spdm_data->config_data.upstep, |
| &spdm_data->config_data.downstep, |
| &spdm_data->config_data.max_vote, |
| &spdm_data->config_data.up_step_multp) != 4) { |
| size = -EINVAL; |
| goto out; |
| } |
| |
| desc.arg[0] = SPDM_CMD_CFG_VOTES; |
| desc.arg[1] = spdm_data->spdm_client; |
| desc.arg[2] = spdm_data->config_data.upstep; |
| desc.arg[3] = spdm_data->config_data.downstep; |
| desc.arg[4] = spdm_data->config_data.max_vote; |
| desc.arg[5] = spdm_data->config_data.up_step_multp; |
| ext_status = spdm_ext_call(&desc, 6); |
| if (ext_status) |
| pr_err("External command %u failed with error %u", |
| (int)desc.arg[0], ext_status); |
| *offset += size; |
| out: |
| memset(buf, 0, sizeof(buf)); |
| return size; |
| } |
| |
| static ssize_t vote_cfg_read(struct file *file, char __user *data, |
| size_t size, loff_t *offset) |
| { |
| struct spdm_data *spdm_data = file->private_data; |
| int i = 32; |
| |
| if (size > sizeof(buf)) |
| return -EINVAL; |
| |
| i = scnprintf(buf, size, "%u %u %u %u\n", |
| spdm_data->config_data.upstep, |
| spdm_data->config_data.downstep, |
| spdm_data->config_data.max_vote, |
| spdm_data->config_data.up_step_multp); |
| |
| i = simple_read_from_buffer(data, size, offset, buf, i); |
| memset(buf, 0, sizeof(buf)); |
| return i; |
| } |
| |
| static const struct file_operations vote_fops = { |
| .open = spdm_open, |
| .write = vote_cfg_write, |
| .read = vote_cfg_read, |
| }; |
| |
| void spdm_init_debugfs(struct device *dev) |
| { |
| struct spdm_data *data = 0; |
| |
| data = dev_get_drvdata(dev); |
| data->debugfs_dir = debugfs_create_dir(dev_name(dev), NULL); |
| |
| debugfs_create_file("enable", 0600, data->debugfs_dir, data, |
| &enable_fops); |
| debugfs_create_file("pl_freqs", 0600, data->debugfs_dir, data, |
| &pl_fops); |
| debugfs_create_file("rej_rate_low", 0600, data->debugfs_dir, data, |
| &rrl_fops); |
| debugfs_create_file("rej_rate_med", 0600, data->debugfs_dir, data, |
| &rrm_fops); |
| debugfs_create_file("rej_rate_high", 0600, data->debugfs_dir, data, |
| &rrh_fops); |
| debugfs_create_file("resp_time_low", 0600, data->debugfs_dir, data, |
| &rtl_fops); |
| debugfs_create_file("resp_time_med", 0600, data->debugfs_dir, data, |
| &rtm_fops); |
| debugfs_create_file("resp_time_high", 0600, data->debugfs_dir, data, |
| &rth_fops); |
| debugfs_create_file("cci_resp_time_low", 0600, data->debugfs_dir, data, |
| &ccil_fops); |
| debugfs_create_file("cci_resp_time_med", 0600, data->debugfs_dir, data, |
| &ccim_fops); |
| debugfs_create_file("cci_resp_time_high", 0600, data->debugfs_dir, |
| data, &ccih_fops); |
| debugfs_create_file("cci_max", 0600, data->debugfs_dir, data, |
| &ccimax_fops); |
| debugfs_create_file("vote_cfg", 0600, data->debugfs_dir, data, |
| &vote_fops); |
| } |
| |
| void spdm_remove_debugfs(struct spdm_data *data) |
| { |
| debugfs_remove_recursive(data->debugfs_dir); |
| } |
| |
| MODULE_LICENSE("GPL v2"); |