/*
* Copyright (c) 2017-2019, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <linux/device.h>
#include <nvgpu/vgpu/vgpu.h>
#include "os/linux/platform_gk20a.h"
#include "os/linux/os_linux.h"
#include "vgpu/ecc_vgpu.h"
static ssize_t vgpu_load_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct gk20a *g = get_gk20a(dev);
struct tegra_vgpu_cmd_msg msg = {0};
struct tegra_vgpu_gpu_load_params *p = &msg.params.gpu_load;
int err;
msg.cmd = TEGRA_VGPU_CMD_GET_GPU_LOAD;
msg.handle = vgpu_get_handle(g);
err = vgpu_comm_sendrecv(&msg, sizeof(msg), sizeof(msg));
if (err)
return err;
return snprintf(buf, PAGE_SIZE, "%u\n", p->load);
}
static DEVICE_ATTR(load, S_IRUGO, vgpu_load_show, NULL);
static ssize_t vgpu_ecc_stat_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct gk20a *g = get_gk20a(dev);
struct tegra_vgpu_cmd_msg msg = {0};
struct tegra_vgpu_ecc_counter_params *p = &msg.params.ecc_counter;
struct dev_ext_attribute *ext_attr = container_of(attr,
struct dev_ext_attribute, attr);
struct vgpu_ecc_stat *ecc_stat = ext_attr->var;
int err;
p->ecc_id = ecc_stat->ecc_id;
msg.cmd = TEGRA_VGPU_CMD_GET_ECC_COUNTER_VALUE;
msg.handle = vgpu_get_handle(g);
err = vgpu_comm_sendrecv(&msg, sizeof(msg), sizeof(msg));
err = err ? err : msg.ret;
if (unlikely(err)) {
nvgpu_err(g, "ecc: cannot get ECC counter value: %d", err);
return err;
}
return snprintf(buf, PAGE_SIZE, "%u\n", p->value);
}
static int vgpu_create_ecc_sysfs(struct device *dev)
{
struct gk20a *g = get_gk20a(dev);
struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
struct vgpu_priv_data *priv = vgpu_get_priv_data(g);
struct vgpu_ecc_stat *stats;
struct dev_ext_attribute *attrs;
int err, i, count;
err = vgpu_ecc_get_info(g);
if (unlikely(err)) {
nvgpu_err(g, "ecc: cannot get ECC info: %d", err);
return err;
}
stats = priv->ecc_stats;
count = priv->ecc_stats_count;
attrs = nvgpu_kzalloc(g, count * sizeof(*attrs));
if (unlikely(!attrs)) {
nvgpu_err(g, "ecc: no memory");
vgpu_ecc_remove_info(g);
return -ENOMEM;
}
for (i = 0; i < count; i++) {
sysfs_attr_init(&attrs[i].attr.attr);
attrs[i].attr.attr.name = stats[i].name;
attrs[i].attr.attr.mode = VERIFY_OCTAL_PERMISSIONS(S_IRUGO);
attrs[i].attr.show = vgpu_ecc_stat_show;
attrs[i].attr.store = NULL;
attrs[i].var = &stats[i];
err = device_create_file(dev, &attrs[i].attr);
if (unlikely(err)) {
nvgpu_warn(g, "ecc: cannot create file \"%s\": %d",
stats[i].name, err);
}
}
l->ecc_attrs = attrs;
return 0;
}
static void vgpu_remove_ecc_sysfs(struct device *dev)
{
struct gk20a *g = get_gk20a(dev);
struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
struct vgpu_priv_data *priv = vgpu_get_priv_data(g);
int i;
if (l->ecc_attrs) {
for (i = 0; i < priv->ecc_stats_count; i++)
device_remove_file(dev, &l->ecc_attrs[i].attr);
nvgpu_kfree(g, l->ecc_attrs);
l->ecc_attrs = NULL;
}
vgpu_ecc_remove_info(g);
}
void vgpu_create_sysfs(struct device *dev)
{
if (device_create_file(dev, &dev_attr_load))
dev_err(dev, "Failed to create vgpu sysfs attributes!\n");
vgpu_create_ecc_sysfs(dev);
}
void vgpu_remove_sysfs(struct device *dev)
{
device_remove_file(dev, &dev_attr_load);
vgpu_remove_ecc_sysfs(dev);
}
