1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <linux/firmware.h> 4 #include <linux/module.h> 5 #include <linux/slab.h> 6 7 #include "sysfs_upload.h" 8 9 /* 10 * Support for user-space to initiate a firmware upload to a device. 11 */ 12 13 static const char * const fw_upload_prog_str[] = { 14 [FW_UPLOAD_PROG_IDLE] = "idle", 15 [FW_UPLOAD_PROG_RECEIVING] = "receiving", 16 [FW_UPLOAD_PROG_PREPARING] = "preparing", 17 [FW_UPLOAD_PROG_TRANSFERRING] = "transferring", 18 [FW_UPLOAD_PROG_PROGRAMMING] = "programming" 19 }; 20 21 static const char * const fw_upload_err_str[] = { 22 [FW_UPLOAD_ERR_NONE] = "none", 23 [FW_UPLOAD_ERR_HW_ERROR] = "hw-error", 24 [FW_UPLOAD_ERR_TIMEOUT] = "timeout", 25 [FW_UPLOAD_ERR_CANCELED] = "user-abort", 26 [FW_UPLOAD_ERR_BUSY] = "device-busy", 27 [FW_UPLOAD_ERR_INVALID_SIZE] = "invalid-file-size", 28 [FW_UPLOAD_ERR_RW_ERROR] = "read-write-error", 29 [FW_UPLOAD_ERR_WEAROUT] = "flash-wearout", 30 [FW_UPLOAD_ERR_FW_INVALID] = "firmware-invalid", 31 }; 32 33 static const char *fw_upload_progress(struct device *dev, 34 enum fw_upload_prog prog) 35 { 36 const char *status = "unknown-status"; 37 38 if (prog < FW_UPLOAD_PROG_MAX) 39 status = fw_upload_prog_str[prog]; 40 else 41 dev_err(dev, "Invalid status during secure update: %d\n", prog); 42 43 return status; 44 } 45 46 static const char *fw_upload_error(struct device *dev, 47 enum fw_upload_err err_code) 48 { 49 const char *error = "unknown-error"; 50 51 if (err_code < FW_UPLOAD_ERR_MAX) 52 error = fw_upload_err_str[err_code]; 53 else 54 dev_err(dev, "Invalid error code during secure update: %d\n", 55 err_code); 56 57 return error; 58 } 59 60 static ssize_t 61 status_show(struct device *dev, struct device_attribute *attr, char *buf) 62 { 63 struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv; 64 65 return sysfs_emit(buf, "%s\n", fw_upload_progress(dev, fwlp->progress)); 66 } 67 DEVICE_ATTR_RO(status); 68 69 static ssize_t 70 error_show(struct device *dev, struct device_attribute *attr, char *buf) 71 { 72 struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv; 73 int ret; 74 75 mutex_lock(&fwlp->lock); 76 77 if (fwlp->progress != FW_UPLOAD_PROG_IDLE) 78 ret = -EBUSY; 79 else if (!fwlp->err_code) 80 ret = 0; 81 else 82 ret = sysfs_emit(buf, "%s:%s\n", 83 fw_upload_progress(dev, fwlp->err_progress), 84 fw_upload_error(dev, fwlp->err_code)); 85 86 mutex_unlock(&fwlp->lock); 87 88 return ret; 89 } 90 DEVICE_ATTR_RO(error); 91 92 static ssize_t cancel_store(struct device *dev, struct device_attribute *attr, 93 const char *buf, size_t count) 94 { 95 struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv; 96 int ret = count; 97 bool cancel; 98 99 if (kstrtobool(buf, &cancel) || !cancel) 100 return -EINVAL; 101 102 mutex_lock(&fwlp->lock); 103 if (fwlp->progress == FW_UPLOAD_PROG_IDLE) { 104 mutex_unlock(&fwlp->lock); 105 return -ENODEV; 106 } 107 108 fwlp->ops->cancel(fwlp->fw_upload); 109 mutex_unlock(&fwlp->lock); 110 111 return ret; 112 } 113 DEVICE_ATTR_WO(cancel); 114 115 static ssize_t remaining_size_show(struct device *dev, 116 struct device_attribute *attr, char *buf) 117 { 118 struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv; 119 120 return sysfs_emit(buf, "%u\n", fwlp->remaining_size); 121 } 122 DEVICE_ATTR_RO(remaining_size); 123 124 umode_t 125 fw_upload_is_visible(struct kobject *kobj, struct attribute *attr, int n) 126 { 127 static struct fw_sysfs *fw_sysfs; 128 129 fw_sysfs = to_fw_sysfs(kobj_to_dev(kobj)); 130 131 if (fw_sysfs->fw_upload_priv || attr == &dev_attr_loading.attr) 132 return attr->mode; 133 134 return 0; 135 } 136 137 static void fw_upload_update_progress(struct fw_upload_priv *fwlp, 138 enum fw_upload_prog new_progress) 139 { 140 mutex_lock(&fwlp->lock); 141 fwlp->progress = new_progress; 142 mutex_unlock(&fwlp->lock); 143 } 144 145 static void fw_upload_set_error(struct fw_upload_priv *fwlp, 146 enum fw_upload_err err_code) 147 { 148 mutex_lock(&fwlp->lock); 149 fwlp->err_progress = fwlp->progress; 150 fwlp->err_code = err_code; 151 mutex_unlock(&fwlp->lock); 152 } 153 154 static void fw_upload_prog_complete(struct fw_upload_priv *fwlp) 155 { 156 mutex_lock(&fwlp->lock); 157 fwlp->progress = FW_UPLOAD_PROG_IDLE; 158 mutex_unlock(&fwlp->lock); 159 } 160 161 static void fw_upload_main(struct work_struct *work) 162 { 163 struct fw_upload_priv *fwlp; 164 struct fw_sysfs *fw_sysfs; 165 u32 written = 0, offset = 0; 166 enum fw_upload_err ret; 167 struct device *fw_dev; 168 struct fw_upload *fwl; 169 170 fwlp = container_of(work, struct fw_upload_priv, work); 171 fwl = fwlp->fw_upload; 172 fw_sysfs = (struct fw_sysfs *)fwl->priv; 173 fw_dev = &fw_sysfs->dev; 174 175 fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PREPARING); 176 ret = fwlp->ops->prepare(fwl, fwlp->data, fwlp->remaining_size); 177 if (ret != FW_UPLOAD_ERR_NONE) { 178 fw_upload_set_error(fwlp, ret); 179 goto putdev_exit; 180 } 181 182 fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_TRANSFERRING); 183 while (fwlp->remaining_size) { 184 ret = fwlp->ops->write(fwl, fwlp->data, offset, 185 fwlp->remaining_size, &written); 186 if (ret != FW_UPLOAD_ERR_NONE || !written) { 187 if (ret == FW_UPLOAD_ERR_NONE) { 188 dev_warn(fw_dev, "write-op wrote zero data\n"); 189 ret = FW_UPLOAD_ERR_RW_ERROR; 190 } 191 fw_upload_set_error(fwlp, ret); 192 goto done; 193 } 194 195 fwlp->remaining_size -= written; 196 offset += written; 197 } 198 199 fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PROGRAMMING); 200 ret = fwlp->ops->poll_complete(fwl); 201 if (ret != FW_UPLOAD_ERR_NONE) 202 fw_upload_set_error(fwlp, ret); 203 204 done: 205 if (fwlp->ops->cleanup) 206 fwlp->ops->cleanup(fwl); 207 208 putdev_exit: 209 put_device(fw_dev->parent); 210 211 /* 212 * Note: fwlp->remaining_size is left unmodified here to provide 213 * additional information on errors. It will be reinitialized when 214 * the next firmeware upload begins. 215 */ 216 mutex_lock(&fw_lock); 217 fw_free_paged_buf(fw_sysfs->fw_priv); 218 fw_state_init(fw_sysfs->fw_priv); 219 mutex_unlock(&fw_lock); 220 fwlp->data = NULL; 221 fw_upload_prog_complete(fwlp); 222 } 223 224 /* 225 * Start a worker thread to upload data to the parent driver. 226 * Must be called with fw_lock held. 227 */ 228 int fw_upload_start(struct fw_sysfs *fw_sysfs) 229 { 230 struct fw_priv *fw_priv = fw_sysfs->fw_priv; 231 struct device *fw_dev = &fw_sysfs->dev; 232 struct fw_upload_priv *fwlp; 233 234 if (!fw_sysfs->fw_upload_priv) 235 return 0; 236 237 if (!fw_priv->size) { 238 fw_free_paged_buf(fw_priv); 239 fw_state_init(fw_sysfs->fw_priv); 240 return 0; 241 } 242 243 fwlp = fw_sysfs->fw_upload_priv; 244 mutex_lock(&fwlp->lock); 245 246 /* Do not interfere with an on-going fw_upload */ 247 if (fwlp->progress != FW_UPLOAD_PROG_IDLE) { 248 mutex_unlock(&fwlp->lock); 249 return -EBUSY; 250 } 251 252 get_device(fw_dev->parent); /* released in fw_upload_main */ 253 254 fwlp->progress = FW_UPLOAD_PROG_RECEIVING; 255 fwlp->err_code = 0; 256 fwlp->remaining_size = fw_priv->size; 257 fwlp->data = fw_priv->data; 258 259 pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n", 260 __func__, fw_priv->fw_name, 261 fw_priv, fw_priv->data, 262 (unsigned int)fw_priv->size); 263 264 queue_work(system_long_wq, &fwlp->work); 265 mutex_unlock(&fwlp->lock); 266 267 return 0; 268 } 269 270 void fw_upload_free(struct fw_sysfs *fw_sysfs) 271 { 272 struct fw_upload_priv *fw_upload_priv = fw_sysfs->fw_upload_priv; 273 274 free_fw_priv(fw_sysfs->fw_priv); 275 kfree(fw_upload_priv->fw_upload); 276 kfree(fw_upload_priv); 277 } 278 279 /** 280 * firmware_upload_register() - register for the firmware upload sysfs API 281 * @module: kernel module of this device 282 * @parent: parent device instantiating firmware upload 283 * @name: firmware name to be associated with this device 284 * @ops: pointer to structure of firmware upload ops 285 * @dd_handle: pointer to parent driver private data 286 * 287 * @name must be unique among all users of firmware upload. The firmware 288 * sysfs files for this device will be found at /sys/class/firmware/@name. 289 * 290 * Return: struct fw_upload pointer or ERR_PTR() 291 * 292 **/ 293 struct fw_upload * 294 firmware_upload_register(struct module *module, struct device *parent, 295 const char *name, const struct fw_upload_ops *ops, 296 void *dd_handle) 297 { 298 u32 opt_flags = FW_OPT_NOCACHE; 299 struct fw_upload *fw_upload; 300 struct fw_upload_priv *fw_upload_priv; 301 struct fw_sysfs *fw_sysfs; 302 struct fw_priv *fw_priv; 303 struct device *fw_dev; 304 int ret; 305 306 if (!name || name[0] == '\0') 307 return ERR_PTR(-EINVAL); 308 309 if (!ops || !ops->cancel || !ops->prepare || 310 !ops->write || !ops->poll_complete) { 311 dev_err(parent, "Attempt to register without all required ops\n"); 312 return ERR_PTR(-EINVAL); 313 } 314 315 if (!try_module_get(module)) 316 return ERR_PTR(-EFAULT); 317 318 fw_upload = kzalloc(sizeof(*fw_upload), GFP_KERNEL); 319 if (!fw_upload) { 320 ret = -ENOMEM; 321 goto exit_module_put; 322 } 323 324 fw_upload_priv = kzalloc(sizeof(*fw_upload_priv), GFP_KERNEL); 325 if (!fw_upload_priv) { 326 ret = -ENOMEM; 327 goto free_fw_upload; 328 } 329 330 fw_upload_priv->fw_upload = fw_upload; 331 fw_upload_priv->ops = ops; 332 mutex_init(&fw_upload_priv->lock); 333 fw_upload_priv->module = module; 334 fw_upload_priv->name = name; 335 fw_upload_priv->err_code = 0; 336 fw_upload_priv->progress = FW_UPLOAD_PROG_IDLE; 337 INIT_WORK(&fw_upload_priv->work, fw_upload_main); 338 fw_upload->dd_handle = dd_handle; 339 340 fw_sysfs = fw_create_instance(NULL, name, parent, opt_flags); 341 if (IS_ERR(fw_sysfs)) { 342 ret = PTR_ERR(fw_sysfs); 343 goto free_fw_upload_priv; 344 } 345 fw_upload->priv = fw_sysfs; 346 fw_sysfs->fw_upload_priv = fw_upload_priv; 347 fw_dev = &fw_sysfs->dev; 348 349 ret = alloc_lookup_fw_priv(name, &fw_cache, &fw_priv, NULL, 0, 0, 350 FW_OPT_NOCACHE); 351 if (ret != 0) { 352 if (ret > 0) 353 ret = -EINVAL; 354 goto free_fw_sysfs; 355 } 356 fw_priv->is_paged_buf = true; 357 fw_sysfs->fw_priv = fw_priv; 358 359 ret = device_add(fw_dev); 360 if (ret) { 361 dev_err(fw_dev, "%s: device_register failed\n", __func__); 362 put_device(fw_dev); 363 goto exit_module_put; 364 } 365 366 return fw_upload; 367 368 free_fw_sysfs: 369 kfree(fw_sysfs); 370 371 free_fw_upload_priv: 372 kfree(fw_upload_priv); 373 374 free_fw_upload: 375 kfree(fw_upload); 376 377 exit_module_put: 378 module_put(module); 379 380 return ERR_PTR(ret); 381 } 382 EXPORT_SYMBOL_GPL(firmware_upload_register); 383 384 /** 385 * firmware_upload_unregister() - Unregister firmware upload interface 386 * @fw_upload: pointer to struct fw_upload 387 **/ 388 void firmware_upload_unregister(struct fw_upload *fw_upload) 389 { 390 struct fw_sysfs *fw_sysfs = fw_upload->priv; 391 struct fw_upload_priv *fw_upload_priv = fw_sysfs->fw_upload_priv; 392 struct module *module = fw_upload_priv->module; 393 394 mutex_lock(&fw_upload_priv->lock); 395 if (fw_upload_priv->progress == FW_UPLOAD_PROG_IDLE) { 396 mutex_unlock(&fw_upload_priv->lock); 397 goto unregister; 398 } 399 400 fw_upload_priv->ops->cancel(fw_upload); 401 mutex_unlock(&fw_upload_priv->lock); 402 403 /* Ensure lower-level device-driver is finished */ 404 flush_work(&fw_upload_priv->work); 405 406 unregister: 407 device_unregister(&fw_sysfs->dev); 408 module_put(module); 409 } 410 EXPORT_SYMBOL_GPL(firmware_upload_unregister); 411