1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Support for atomisp driver sysfs interface 4 * 5 * Copyright (c) 2014 Intel Corporation. All Rights Reserved. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * 17 */ 18 19 #include <linux/device.h> 20 #include <linux/err.h> 21 #include <linux/kernel.h> 22 23 #include "atomisp_compat.h" 24 #include "atomisp_internal.h" 25 #include "atomisp_ioctl.h" 26 #include "atomisp_drvfs.h" 27 #include "hmm/hmm.h" 28 #include "ia_css_debug.h" 29 30 /* 31 * _iunit_debug: 32 * dbglvl: iunit css driver trace level 33 * dbgopt: iunit debug option: 34 * bit 0: binary list 35 * bit 1: running binary 36 * bit 2: memory statistic 37 */ 38 struct _iunit_debug { 39 struct device_driver *drv; 40 struct atomisp_device *isp; 41 unsigned int dbglvl; 42 unsigned int dbgfun; 43 unsigned int dbgopt; 44 }; 45 46 #define OPTION_BIN_LIST BIT(0) 47 #define OPTION_BIN_RUN BIT(1) 48 #define OPTION_MEM_STAT BIT(2) 49 #define OPTION_VALID (OPTION_BIN_LIST \ 50 | OPTION_BIN_RUN \ 51 | OPTION_MEM_STAT) 52 53 static struct _iunit_debug iunit_debug = { 54 .dbglvl = 0, 55 .dbgopt = OPTION_BIN_LIST, 56 }; 57 58 static inline int iunit_dump_dbgopt(struct atomisp_device *isp, 59 unsigned int opt) 60 { 61 int ret = 0; 62 63 if (opt & OPTION_VALID) { 64 if (opt & OPTION_BIN_LIST) { 65 ret = atomisp_css_dump_blob_infor(isp); 66 if (ret) { 67 dev_err(isp->dev, "%s dump blob infor err[ret:%d]\n", 68 __func__, ret); 69 goto opt_err; 70 } 71 } 72 73 if (opt & OPTION_BIN_RUN) { 74 if (atomisp_streaming_count(isp)) { 75 atomisp_css_dump_sp_raw_copy_linecount(true); 76 atomisp_css_debug_dump_isp_binary(); 77 } else { 78 ret = -EPERM; 79 dev_err(isp->dev, "%s dump running bin err[ret:%d]\n", 80 __func__, ret); 81 goto opt_err; 82 } 83 } 84 85 if (opt & OPTION_MEM_STAT) 86 hmm_show_mem_stat(__func__, __LINE__); 87 } else { 88 ret = -EINVAL; 89 dev_err(isp->dev, "%s dump nothing[ret=%d]\n", __func__, ret); 90 } 91 92 opt_err: 93 return ret; 94 } 95 96 static ssize_t iunit_dbglvl_show(struct device_driver *drv, char *buf) 97 { 98 iunit_debug.dbglvl = dbg_level; 99 return sprintf(buf, "dtrace level:%u\n", iunit_debug.dbglvl); 100 } 101 102 static ssize_t iunit_dbglvl_store(struct device_driver *drv, const char *buf, 103 size_t size) 104 { 105 if (kstrtouint(buf, 10, &iunit_debug.dbglvl) 106 || iunit_debug.dbglvl < 1 107 || iunit_debug.dbglvl > 9) { 108 return -ERANGE; 109 } 110 ia_css_debug_set_dtrace_level(iunit_debug.dbglvl); 111 112 return size; 113 } 114 115 static ssize_t iunit_dbgfun_show(struct device_driver *drv, char *buf) 116 { 117 iunit_debug.dbgfun = atomisp_get_css_dbgfunc(); 118 return sprintf(buf, "dbgfun opt:%u\n", iunit_debug.dbgfun); 119 } 120 121 static ssize_t iunit_dbgfun_store(struct device_driver *drv, const char *buf, 122 size_t size) 123 { 124 unsigned int opt; 125 int ret; 126 127 ret = kstrtouint(buf, 10, &opt); 128 if (ret) 129 return ret; 130 131 ret = atomisp_set_css_dbgfunc(iunit_debug.isp, opt); 132 if (ret) 133 return ret; 134 135 iunit_debug.dbgfun = opt; 136 137 return size; 138 } 139 140 static ssize_t iunit_dbgopt_show(struct device_driver *drv, char *buf) 141 { 142 return sprintf(buf, "option:0x%x\n", iunit_debug.dbgopt); 143 } 144 145 static ssize_t iunit_dbgopt_store(struct device_driver *drv, const char *buf, 146 size_t size) 147 { 148 unsigned int opt; 149 int ret; 150 151 ret = kstrtouint(buf, 10, &opt); 152 if (ret) 153 return ret; 154 155 iunit_debug.dbgopt = opt; 156 ret = iunit_dump_dbgopt(iunit_debug.isp, iunit_debug.dbgopt); 157 if (ret) 158 return ret; 159 160 return size; 161 } 162 163 static const struct driver_attribute iunit_drvfs_attrs[] = { 164 __ATTR(dbglvl, 0644, iunit_dbglvl_show, iunit_dbglvl_store), 165 __ATTR(dbgfun, 0644, iunit_dbgfun_show, iunit_dbgfun_store), 166 __ATTR(dbgopt, 0644, iunit_dbgopt_show, iunit_dbgopt_store), 167 }; 168 169 static int iunit_drvfs_create_files(struct device_driver *drv) 170 { 171 int i, ret = 0; 172 173 for (i = 0; i < ARRAY_SIZE(iunit_drvfs_attrs); i++) 174 ret |= driver_create_file(drv, &iunit_drvfs_attrs[i]); 175 176 return ret; 177 } 178 179 static void iunit_drvfs_remove_files(struct device_driver *drv) 180 { 181 int i; 182 183 for (i = 0; i < ARRAY_SIZE(iunit_drvfs_attrs); i++) 184 driver_remove_file(drv, &iunit_drvfs_attrs[i]); 185 } 186 187 int atomisp_drvfs_init(struct atomisp_device *isp) 188 { 189 struct device_driver *drv = isp->dev->driver; 190 int ret; 191 192 iunit_debug.isp = isp; 193 iunit_debug.drv = drv; 194 195 ret = iunit_drvfs_create_files(iunit_debug.drv); 196 if (ret) { 197 dev_err(isp->dev, "drvfs_create_files error: %d\n", ret); 198 iunit_drvfs_remove_files(iunit_debug.drv); 199 } 200 201 return ret; 202 } 203 204 void atomisp_drvfs_exit(void) 205 { 206 iunit_drvfs_remove_files(iunit_debug.drv); 207 } 208