1 // SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only) 2 /* Copyright(c) 2022 Intel Corporation */ 3 #include <linux/device.h> 4 #include <linux/errno.h> 5 #include <linux/pci.h> 6 #include "adf_accel_devices.h" 7 #include "adf_cfg.h" 8 #include "adf_cfg_services.h" 9 #include "adf_common_drv.h" 10 11 #define UNSET_RING_NUM -1 12 13 static const char * const state_operations[] = { 14 [DEV_DOWN] = "down", 15 [DEV_UP] = "up", 16 }; 17 18 static ssize_t state_show(struct device *dev, struct device_attribute *attr, 19 char *buf) 20 { 21 struct adf_accel_dev *accel_dev; 22 char *state; 23 24 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 25 if (!accel_dev) 26 return -EINVAL; 27 28 state = adf_dev_started(accel_dev) ? "up" : "down"; 29 return sysfs_emit(buf, "%s\n", state); 30 } 31 32 static ssize_t state_store(struct device *dev, struct device_attribute *attr, 33 const char *buf, size_t count) 34 { 35 struct adf_accel_dev *accel_dev; 36 u32 accel_id; 37 int ret; 38 39 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 40 if (!accel_dev) 41 return -EINVAL; 42 43 accel_id = accel_dev->accel_id; 44 45 if (adf_devmgr_in_reset(accel_dev) || adf_dev_in_use(accel_dev)) { 46 dev_info(dev, "Device qat_dev%d is busy\n", accel_id); 47 return -EBUSY; 48 } 49 50 ret = sysfs_match_string(state_operations, buf); 51 if (ret < 0) 52 return ret; 53 54 switch (ret) { 55 case DEV_DOWN: 56 dev_info(dev, "Stopping device qat_dev%d\n", accel_id); 57 58 if (!adf_dev_started(accel_dev)) { 59 dev_info(&GET_DEV(accel_dev), "Device qat_dev%d already down\n", 60 accel_id); 61 62 break; 63 } 64 65 ret = adf_dev_down(accel_dev, true); 66 if (ret) 67 return ret; 68 69 break; 70 case DEV_UP: 71 dev_info(dev, "Starting device qat_dev%d\n", accel_id); 72 73 ret = adf_dev_up(accel_dev, true); 74 if (ret == -EALREADY) { 75 break; 76 } else if (ret) { 77 dev_err(dev, "Failed to start device qat_dev%d\n", 78 accel_id); 79 adf_dev_down(accel_dev, true); 80 return ret; 81 } 82 break; 83 default: 84 return -EINVAL; 85 } 86 87 return count; 88 } 89 90 static ssize_t cfg_services_show(struct device *dev, struct device_attribute *attr, 91 char *buf) 92 { 93 char services[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = {0}; 94 struct adf_accel_dev *accel_dev; 95 int ret; 96 97 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 98 if (!accel_dev) 99 return -EINVAL; 100 101 ret = adf_cfg_get_param_value(accel_dev, ADF_GENERAL_SEC, 102 ADF_SERVICES_ENABLED, services); 103 if (ret) 104 return ret; 105 106 return sysfs_emit(buf, "%s\n", services); 107 } 108 109 static int adf_sysfs_update_dev_config(struct adf_accel_dev *accel_dev, 110 const char *services) 111 { 112 return adf_cfg_add_key_value_param(accel_dev, ADF_GENERAL_SEC, 113 ADF_SERVICES_ENABLED, services, 114 ADF_STR); 115 } 116 117 static ssize_t cfg_services_store(struct device *dev, struct device_attribute *attr, 118 const char *buf, size_t count) 119 { 120 struct adf_hw_device_data *hw_data; 121 struct adf_accel_dev *accel_dev; 122 int ret; 123 124 ret = sysfs_match_string(adf_cfg_services, buf); 125 if (ret < 0) 126 return ret; 127 128 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 129 if (!accel_dev) 130 return -EINVAL; 131 132 if (adf_dev_started(accel_dev)) { 133 dev_info(dev, "Device qat_dev%d must be down to reconfigure the service.\n", 134 accel_dev->accel_id); 135 return -EINVAL; 136 } 137 138 ret = adf_sysfs_update_dev_config(accel_dev, adf_cfg_services[ret]); 139 if (ret < 0) 140 return ret; 141 142 hw_data = GET_HW_DATA(accel_dev); 143 144 /* Update capabilities mask after change in configuration. 145 * A call to this function is required as capabilities are, at the 146 * moment, tied to configuration 147 */ 148 hw_data->accel_capabilities_mask = hw_data->get_accel_cap(accel_dev); 149 if (!hw_data->accel_capabilities_mask) 150 return -EINVAL; 151 152 return count; 153 } 154 155 static ssize_t pm_idle_enabled_show(struct device *dev, struct device_attribute *attr, 156 char *buf) 157 { 158 char pm_idle_enabled[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = {}; 159 struct adf_accel_dev *accel_dev; 160 int ret; 161 162 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 163 if (!accel_dev) 164 return -EINVAL; 165 166 ret = adf_cfg_get_param_value(accel_dev, ADF_GENERAL_SEC, 167 ADF_PM_IDLE_SUPPORT, pm_idle_enabled); 168 if (ret) 169 return sysfs_emit(buf, "1\n"); 170 171 return sysfs_emit(buf, "%s\n", pm_idle_enabled); 172 } 173 174 static ssize_t pm_idle_enabled_store(struct device *dev, struct device_attribute *attr, 175 const char *buf, size_t count) 176 { 177 unsigned long pm_idle_enabled_cfg_val; 178 struct adf_accel_dev *accel_dev; 179 bool pm_idle_enabled; 180 int ret; 181 182 ret = kstrtobool(buf, &pm_idle_enabled); 183 if (ret) 184 return ret; 185 186 pm_idle_enabled_cfg_val = pm_idle_enabled; 187 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 188 if (!accel_dev) 189 return -EINVAL; 190 191 if (adf_dev_started(accel_dev)) { 192 dev_info(dev, "Device qat_dev%d must be down to set pm_idle_enabled.\n", 193 accel_dev->accel_id); 194 return -EINVAL; 195 } 196 197 ret = adf_cfg_add_key_value_param(accel_dev, ADF_GENERAL_SEC, 198 ADF_PM_IDLE_SUPPORT, &pm_idle_enabled_cfg_val, 199 ADF_DEC); 200 if (ret) 201 return ret; 202 203 return count; 204 } 205 static DEVICE_ATTR_RW(pm_idle_enabled); 206 207 static DEVICE_ATTR_RW(state); 208 static DEVICE_ATTR_RW(cfg_services); 209 210 static ssize_t rp2srv_show(struct device *dev, struct device_attribute *attr, 211 char *buf) 212 { 213 struct adf_hw_device_data *hw_data; 214 struct adf_accel_dev *accel_dev; 215 enum adf_cfg_service_type svc; 216 217 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 218 hw_data = GET_HW_DATA(accel_dev); 219 220 if (accel_dev->sysfs.ring_num == UNSET_RING_NUM) 221 return -EINVAL; 222 223 down_read(&accel_dev->sysfs.lock); 224 svc = GET_SRV_TYPE(accel_dev, accel_dev->sysfs.ring_num % 225 hw_data->num_banks_per_vf); 226 up_read(&accel_dev->sysfs.lock); 227 228 switch (svc) { 229 case COMP: 230 return sysfs_emit(buf, "%s\n", ADF_CFG_DC); 231 case SYM: 232 return sysfs_emit(buf, "%s\n", ADF_CFG_SYM); 233 case ASYM: 234 return sysfs_emit(buf, "%s\n", ADF_CFG_ASYM); 235 default: 236 break; 237 } 238 return -EINVAL; 239 } 240 241 static ssize_t rp2srv_store(struct device *dev, struct device_attribute *attr, 242 const char *buf, size_t count) 243 { 244 struct adf_accel_dev *accel_dev; 245 int ring, num_rings, ret; 246 247 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 248 if (!accel_dev) 249 return -EINVAL; 250 251 ret = kstrtouint(buf, 10, &ring); 252 if (ret) 253 return ret; 254 255 num_rings = GET_MAX_BANKS(accel_dev); 256 if (ring >= num_rings) { 257 dev_err(&GET_DEV(accel_dev), 258 "Device does not support more than %u ring pairs\n", 259 num_rings); 260 return -EINVAL; 261 } 262 263 down_write(&accel_dev->sysfs.lock); 264 accel_dev->sysfs.ring_num = ring; 265 up_write(&accel_dev->sysfs.lock); 266 267 return count; 268 } 269 static DEVICE_ATTR_RW(rp2srv); 270 271 static ssize_t num_rps_show(struct device *dev, struct device_attribute *attr, 272 char *buf) 273 { 274 struct adf_accel_dev *accel_dev; 275 276 accel_dev = adf_devmgr_pci_to_accel_dev(to_pci_dev(dev)); 277 if (!accel_dev) 278 return -EINVAL; 279 280 return sysfs_emit(buf, "%u\n", GET_MAX_BANKS(accel_dev)); 281 } 282 static DEVICE_ATTR_RO(num_rps); 283 284 static struct attribute *qat_attrs[] = { 285 &dev_attr_state.attr, 286 &dev_attr_cfg_services.attr, 287 &dev_attr_pm_idle_enabled.attr, 288 &dev_attr_rp2srv.attr, 289 &dev_attr_num_rps.attr, 290 NULL, 291 }; 292 293 static struct attribute_group qat_group = { 294 .attrs = qat_attrs, 295 .name = "qat", 296 }; 297 298 int adf_sysfs_init(struct adf_accel_dev *accel_dev) 299 { 300 int ret; 301 302 ret = devm_device_add_group(&GET_DEV(accel_dev), &qat_group); 303 if (ret) { 304 dev_err(&GET_DEV(accel_dev), 305 "Failed to create qat attribute group: %d\n", ret); 306 } 307 308 accel_dev->sysfs.ring_num = UNSET_RING_NUM; 309 310 return ret; 311 } 312 EXPORT_SYMBOL_GPL(adf_sysfs_init); 313