base/firmware_loader/sysfs_upload.c

0001 // SPDX-License-Identifier: GPL-2.0
0002
0003 #include <linux/firmware.h>
0004 #include <linux/module.h>
0005 #include <linux/slab.h>
0006
0007 #include "sysfs_upload.h"
0008
0009 /*
0010  * Support for user-space to initiate a firmware upload to a device.
0011  */
0012
0013 static const char * const fw_upload_prog_str[] = {
0014     [FW_UPLOAD_PROG_IDLE]         = "idle",
0015     [FW_UPLOAD_PROG_RECEIVING]    = "receiving",
0016     [FW_UPLOAD_PROG_PREPARING]    = "preparing",
0017     [FW_UPLOAD_PROG_TRANSFERRING] = "transferring",
0018     [FW_UPLOAD_PROG_PROGRAMMING]  = "programming"
0019 };
0020
0021 static const char * const fw_upload_err_str[] = {
0022     [FW_UPLOAD_ERR_NONE]         = "none",
0023     [FW_UPLOAD_ERR_HW_ERROR]     = "hw-error",
0024     [FW_UPLOAD_ERR_TIMEOUT]      = "timeout",
0025     [FW_UPLOAD_ERR_CANCELED]     = "user-abort",
0026     [FW_UPLOAD_ERR_BUSY]         = "device-busy",
0027     [FW_UPLOAD_ERR_INVALID_SIZE] = "invalid-file-size",
0028     [FW_UPLOAD_ERR_RW_ERROR]     = "read-write-error",
0029     [FW_UPLOAD_ERR_WEAROUT]      = "flash-wearout",
0030 };
0031
0032 static const char *fw_upload_progress(struct device *dev,
0033                       enum fw_upload_prog prog)
0034 {
0035     const char *status = "unknown-status";
0036
0037     if (prog < FW_UPLOAD_PROG_MAX)
0038         status = fw_upload_prog_str[prog];
0039     else
0040         dev_err(dev, "Invalid status during secure update: %d\n", prog);
0041
0042     return status;
0043 }
0044
0045 static const char *fw_upload_error(struct device *dev,
0046                    enum fw_upload_err err_code)
0047 {
0048     const char *error = "unknown-error";
0049
0050     if (err_code < FW_UPLOAD_ERR_MAX)
0051         error = fw_upload_err_str[err_code];
0052     else
0053         dev_err(dev, "Invalid error code during secure update: %d\n",
0054             err_code);
0055
0056     return error;
0057 }
0058
0059 static ssize_t
0060 status_show(struct device *dev, struct device_attribute *attr, char *buf)
0061 {
0062     struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv;
0063
0064     return sysfs_emit(buf, "%s\n", fw_upload_progress(dev, fwlp->progress));
0065 }
0066 DEVICE_ATTR_RO(status);
0067
0068 static ssize_t
0069 error_show(struct device *dev, struct device_attribute *attr, char *buf)
0070 {
0071     struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv;
0072     int ret;
0073
0074     mutex_lock(&fwlp->lock);
0075
0076     if (fwlp->progress != FW_UPLOAD_PROG_IDLE)
0077         ret = -EBUSY;
0078     else if (!fwlp->err_code)
0079         ret = 0;
0080     else
0081         ret = sysfs_emit(buf, "%s:%s\n",
0082                  fw_upload_progress(dev, fwlp->err_progress),
0083                  fw_upload_error(dev, fwlp->err_code));
0084
0085     mutex_unlock(&fwlp->lock);
0086
0087     return ret;
0088 }
0089 DEVICE_ATTR_RO(error);
0090
0091 static ssize_t cancel_store(struct device *dev, struct device_attribute *attr,
0092                 const char *buf, size_t count)
0093 {
0094     struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv;
0095     int ret = count;
0096     bool cancel;
0097
0098     if (kstrtobool(buf, &cancel) || !cancel)
0099         return -EINVAL;
0100
0101     mutex_lock(&fwlp->lock);
0102     if (fwlp->progress == FW_UPLOAD_PROG_IDLE)
0103         ret = -ENODEV;
0104
0105     fwlp->ops->cancel(fwlp->fw_upload);
0106     mutex_unlock(&fwlp->lock);
0107
0108     return ret;
0109 }
0110 DEVICE_ATTR_WO(cancel);
0111
0112 static ssize_t remaining_size_show(struct device *dev,
0113                    struct device_attribute *attr, char *buf)
0114 {
0115     struct fw_upload_priv *fwlp = to_fw_sysfs(dev)->fw_upload_priv;
0116
0117     return sysfs_emit(buf, "%u\n", fwlp->remaining_size);
0118 }
0119 DEVICE_ATTR_RO(remaining_size);
0120
0121 umode_t
0122 fw_upload_is_visible(struct kobject *kobj, struct attribute *attr, int n)
0123 {
0124     static struct fw_sysfs *fw_sysfs;
0125
0126     fw_sysfs = to_fw_sysfs(kobj_to_dev(kobj));
0127
0128     if (fw_sysfs->fw_upload_priv || attr == &dev_attr_loading.attr)
0129         return attr->mode;
0130
0131     return 0;
0132 }
0133
0134 static void fw_upload_update_progress(struct fw_upload_priv *fwlp,
0135                       enum fw_upload_prog new_progress)
0136 {
0137     mutex_lock(&fwlp->lock);
0138     fwlp->progress = new_progress;
0139     mutex_unlock(&fwlp->lock);
0140 }
0141
0142 static void fw_upload_set_error(struct fw_upload_priv *fwlp,
0143                 enum fw_upload_err err_code)
0144 {
0145     mutex_lock(&fwlp->lock);
0146     fwlp->err_progress = fwlp->progress;
0147     fwlp->err_code = err_code;
0148     mutex_unlock(&fwlp->lock);
0149 }
0150
0151 static void fw_upload_prog_complete(struct fw_upload_priv *fwlp)
0152 {
0153     mutex_lock(&fwlp->lock);
0154     fwlp->progress = FW_UPLOAD_PROG_IDLE;
0155     mutex_unlock(&fwlp->lock);
0156 }
0157
0158 static void fw_upload_main(struct work_struct *work)
0159 {
0160     struct fw_upload_priv *fwlp;
0161     struct fw_sysfs *fw_sysfs;
0162     u32 written = 0, offset = 0;
0163     enum fw_upload_err ret;
0164     struct device *fw_dev;
0165     struct fw_upload *fwl;
0166
0167     fwlp = container_of(work, struct fw_upload_priv, work);
0168     fwl = fwlp->fw_upload;
0169     fw_sysfs = (struct fw_sysfs *)fwl->priv;
0170     fw_dev = &fw_sysfs->dev;
0171
0172     fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PREPARING);
0173     ret = fwlp->ops->prepare(fwl, fwlp->data, fwlp->remaining_size);
0174     if (ret != FW_UPLOAD_ERR_NONE) {
0175         fw_upload_set_error(fwlp, ret);
0176         goto putdev_exit;
0177     }
0178
0179     fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_TRANSFERRING);
0180     while (fwlp->remaining_size) {
0181         ret = fwlp->ops->write(fwl, fwlp->data, offset,
0182                     fwlp->remaining_size, &written);
0183         if (ret != FW_UPLOAD_ERR_NONE || !written) {
0184             if (ret == FW_UPLOAD_ERR_NONE) {
0185                 dev_warn(fw_dev, "write-op wrote zero data\n");
0186                 ret = FW_UPLOAD_ERR_RW_ERROR;
0187             }
0188             fw_upload_set_error(fwlp, ret);
0189             goto done;
0190         }
0191
0192         fwlp->remaining_size -= written;
0193         offset += written;
0194     }
0195
0196     fw_upload_update_progress(fwlp, FW_UPLOAD_PROG_PROGRAMMING);
0197     ret = fwlp->ops->poll_complete(fwl);
0198     if (ret != FW_UPLOAD_ERR_NONE)
0199         fw_upload_set_error(fwlp, ret);
0200
0201 done:
0202     if (fwlp->ops->cleanup)
0203         fwlp->ops->cleanup(fwl);
0204
0205 putdev_exit:
0206     put_device(fw_dev->parent);
0207
0208     /*
0209      * Note: fwlp->remaining_size is left unmodified here to provide
0210      * additional information on errors. It will be reinitialized when
0211      * the next firmeware upload begins.
0212      */
0213     mutex_lock(&fw_lock);
0214     fw_free_paged_buf(fw_sysfs->fw_priv);
0215     fw_state_init(fw_sysfs->fw_priv);
0216     mutex_unlock(&fw_lock);
0217     fwlp->data = NULL;
0218     fw_upload_prog_complete(fwlp);
0219 }
0220
0221 /*
0222  * Start a worker thread to upload data to the parent driver.
0223  * Must be called with fw_lock held.
0224  */
0225 int fw_upload_start(struct fw_sysfs *fw_sysfs)
0226 {
0227     struct fw_priv *fw_priv = fw_sysfs->fw_priv;
0228     struct device *fw_dev = &fw_sysfs->dev;
0229     struct fw_upload_priv *fwlp;
0230
0231     if (!fw_sysfs->fw_upload_priv)
0232         return 0;
0233
0234     if (!fw_priv->size) {
0235         fw_free_paged_buf(fw_priv);
0236         fw_state_init(fw_sysfs->fw_priv);
0237         return 0;
0238     }
0239
0240     fwlp = fw_sysfs->fw_upload_priv;
0241     mutex_lock(&fwlp->lock);
0242
0243     /* Do not interfere with an on-going fw_upload */
0244     if (fwlp->progress != FW_UPLOAD_PROG_IDLE) {
0245         mutex_unlock(&fwlp->lock);
0246         return -EBUSY;
0247     }
0248
0249     get_device(fw_dev->parent); /* released in fw_upload_main */
0250
0251     fwlp->progress = FW_UPLOAD_PROG_RECEIVING;
0252     fwlp->err_code = 0;
0253     fwlp->remaining_size = fw_priv->size;
0254     fwlp->data = fw_priv->data;
0255
0256     pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n",
0257          __func__, fw_priv->fw_name,
0258          fw_priv, fw_priv->data,
0259          (unsigned int)fw_priv->size);
0260
0261     queue_work(system_long_wq, &fwlp->work);
0262     mutex_unlock(&fwlp->lock);
0263
0264     return 0;
0265 }
0266
0267 void fw_upload_free(struct fw_sysfs *fw_sysfs)
0268 {
0269     struct fw_upload_priv *fw_upload_priv = fw_sysfs->fw_upload_priv;
0270
0271     free_fw_priv(fw_sysfs->fw_priv);
0272     kfree(fw_upload_priv->fw_upload);
0273     kfree(fw_upload_priv);
0274 }
0275
0276 /**
0277  * firmware_upload_register() - register for the firmware upload sysfs API
0278  * @module: kernel module of this device
0279  * @parent: parent device instantiating firmware upload
0280  * @name: firmware name to be associated with this device
0281  * @ops: pointer to structure of firmware upload ops
0282  * @dd_handle: pointer to parent driver private data
0283  *
0284  *  @name must be unique among all users of firmware upload. The firmware
0285  *  sysfs files for this device will be found at /sys/class/firmware/@name.
0286  *
0287  *  Return: struct fw_upload pointer or ERR_PTR()
0288  *
0289  **/
0290 struct fw_upload *
0291 firmware_upload_register(struct module *module, struct device *parent,
0292              const char *name, const struct fw_upload_ops *ops,
0293              void *dd_handle)
0294 {
0295     u32 opt_flags = FW_OPT_NOCACHE;
0296     struct fw_upload *fw_upload;
0297     struct fw_upload_priv *fw_upload_priv;
0298     struct fw_sysfs *fw_sysfs;
0299     struct fw_priv *fw_priv;
0300     struct device *fw_dev;
0301     int ret;
0302
0303     if (!name || name[0] == '\0')
0304         return ERR_PTR(-EINVAL);
0305
0306     if (!ops || !ops->cancel || !ops->prepare ||
0307         !ops->write || !ops->poll_complete) {
0308         dev_err(parent, "Attempt to register without all required ops\n");
0309         return ERR_PTR(-EINVAL);
0310     }
0311
0312     if (!try_module_get(module))
0313         return ERR_PTR(-EFAULT);
0314
0315     fw_upload = kzalloc(sizeof(*fw_upload), GFP_KERNEL);
0316     if (!fw_upload) {
0317         ret = -ENOMEM;
0318         goto exit_module_put;
0319     }
0320
0321     fw_upload_priv = kzalloc(sizeof(*fw_upload_priv), GFP_KERNEL);
0322     if (!fw_upload_priv) {
0323         ret = -ENOMEM;
0324         goto free_fw_upload;
0325     }
0326
0327     fw_upload_priv->fw_upload = fw_upload;
0328     fw_upload_priv->ops = ops;
0329     mutex_init(&fw_upload_priv->lock);
0330     fw_upload_priv->module = module;
0331     fw_upload_priv->name = name;
0332     fw_upload_priv->err_code = 0;
0333     fw_upload_priv->progress = FW_UPLOAD_PROG_IDLE;
0334     INIT_WORK(&fw_upload_priv->work, fw_upload_main);
0335     fw_upload->dd_handle = dd_handle;
0336
0337     fw_sysfs = fw_create_instance(NULL, name, parent, opt_flags);
0338     if (IS_ERR(fw_sysfs)) {
0339         ret = PTR_ERR(fw_sysfs);
0340         goto free_fw_upload_priv;
0341     }
0342     fw_upload->priv = fw_sysfs;
0343     fw_sysfs->fw_upload_priv = fw_upload_priv;
0344     fw_dev = &fw_sysfs->dev;
0345
0346     ret = alloc_lookup_fw_priv(name, &fw_cache, &fw_priv,  NULL, 0, 0,
0347                    FW_OPT_NOCACHE);
0348     if (ret != 0) {
0349         if (ret > 0)
0350             ret = -EINVAL;
0351         goto free_fw_sysfs;
0352     }
0353     fw_priv->is_paged_buf = true;
0354     fw_sysfs->fw_priv = fw_priv;
0355
0356     ret = device_add(fw_dev);
0357     if (ret) {
0358         dev_err(fw_dev, "%s: device_register failed\n", __func__);
0359         put_device(fw_dev);
0360         goto exit_module_put;
0361     }
0362
0363     return fw_upload;
0364
0365 free_fw_sysfs:
0366     kfree(fw_sysfs);
0367
0368 free_fw_upload_priv:
0369     kfree(fw_upload_priv);
0370
0371 free_fw_upload:
0372     kfree(fw_upload);
0373
0374 exit_module_put:
0375     module_put(module);
0376
0377     return ERR_PTR(ret);
0378 }
0379 EXPORT_SYMBOL_GPL(firmware_upload_register);
0380
0381 /**
0382  * firmware_upload_unregister() - Unregister firmware upload interface
0383  * @fw_upload: pointer to struct fw_upload
0384  **/
0385 void firmware_upload_unregister(struct fw_upload *fw_upload)
0386 {
0387     struct fw_sysfs *fw_sysfs = fw_upload->priv;
0388     struct fw_upload_priv *fw_upload_priv = fw_sysfs->fw_upload_priv;
0389     struct module *module = fw_upload_priv->module;
0390
0391     mutex_lock(&fw_upload_priv->lock);
0392     if (fw_upload_priv->progress == FW_UPLOAD_PROG_IDLE) {
0393         mutex_unlock(&fw_upload_priv->lock);
0394         goto unregister;
0395     }
0396
0397     fw_upload_priv->ops->cancel(fw_upload);
0398     mutex_unlock(&fw_upload_priv->lock);
0399
0400     /* Ensure lower-level device-driver is finished */
0401     flush_work(&fw_upload_priv->work);
0402
0403 unregister:
0404     device_unregister(&fw_sysfs->dev);
0405     module_put(module);
0406 }
0407 EXPORT_SYMBOL_GPL(firmware_upload_unregister);