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
13static 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
21static 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
33static 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
46static 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
60static ssize_t
61status_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, fmt: "%s\n", fw_upload_progress(dev, prog: fwlp->progress));
66}
67DEVICE_ATTR_RO(status);
68
69static ssize_t
70error_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, fmt: "%s:%s\n",
83 fw_upload_progress(dev, prog: fwlp->err_progress),
84 fw_upload_error(dev, err_code: fwlp->err_code));
85
86 mutex_unlock(lock: &fwlp->lock);
87
88 return ret;
89}
90DEVICE_ATTR_RO(error);
91
92static 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(s: buf, res: &cancel) || !cancel)
100 return -EINVAL;
101
102 mutex_lock(&fwlp->lock);
103 if (fwlp->progress == FW_UPLOAD_PROG_IDLE) {
104 mutex_unlock(lock: &fwlp->lock);
105 return -ENODEV;
106 }
107
108 fwlp->ops->cancel(fwlp->fw_upload);
109 mutex_unlock(lock: &fwlp->lock);
110
111 return ret;
112}
113DEVICE_ATTR_WO(cancel);
114
115static 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, fmt: "%u\n", fwlp->remaining_size);
121}
122DEVICE_ATTR_RO(remaining_size);
123
124umode_t
125fw_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
137static 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(lock: &fwlp->lock);
143}
144
145static 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(lock: &fwlp->lock);
152}
153
154static 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(lock: &fwlp->lock);
159}
160
161static 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, new_progress: 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, err_code: ret);
179 goto putdev_exit;
180 }
181
182 fw_upload_update_progress(fwlp, new_progress: 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, err_code: ret);
192 goto done;
193 }
194
195 fwlp->remaining_size -= written;
196 offset += written;
197 }
198
199 fw_upload_update_progress(fwlp, new_progress: FW_UPLOAD_PROG_PROGRAMMING);
200 ret = fwlp->ops->poll_complete(fwl);
201 if (ret != FW_UPLOAD_ERR_NONE)
202 fw_upload_set_error(fwlp, err_code: ret);
203
204done:
205 if (fwlp->ops->cleanup)
206 fwlp->ops->cleanup(fwl);
207
208putdev_exit:
209 put_device(dev: 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_priv: fw_sysfs->fw_priv);
218 fw_state_init(fw_priv: fw_sysfs->fw_priv);
219 mutex_unlock(lock: &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 */
228int 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_priv: 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(lock: &fwlp->lock);
249 return -EBUSY;
250 }
251
252 get_device(dev: 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(wq: system_long_wq, work: &fwlp->work);
265 mutex_unlock(lock: &fwlp->lock);
266
267 return 0;
268}
269
270void 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_priv: fw_sysfs->fw_priv);
275 kfree(objp: fw_upload_priv->fw_upload);
276 kfree(objp: 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 **/
293struct fw_upload *
294firmware_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(error: -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(error: -EINVAL);
313 }
314
315 if (!try_module_get(module))
316 return ERR_PTR(error: -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, fw_name: name, device: parent, opt_flags);
341 if (IS_ERR(ptr: fw_sysfs)) {
342 ret = PTR_ERR(ptr: 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(fw_name: name, fwc: &fw_cache, fw_priv: &fw_priv, NULL, size: 0, offset: 0,
350 opt_flags: 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(dev: fw_dev);
360 if (ret) {
361 dev_err(fw_dev, "%s: device_register failed\n", __func__);
362 put_device(dev: fw_dev);
363 goto exit_module_put;
364 }
365
366 return fw_upload;
367
368free_fw_sysfs:
369 kfree(objp: fw_sysfs);
370
371free_fw_upload_priv:
372 kfree(objp: fw_upload_priv);
373
374free_fw_upload:
375 kfree(objp: fw_upload);
376
377exit_module_put:
378 module_put(module);
379
380 return ERR_PTR(error: ret);
381}
382EXPORT_SYMBOL_GPL(firmware_upload_register);
383
384/**
385 * firmware_upload_unregister() - Unregister firmware upload interface
386 * @fw_upload: pointer to struct fw_upload
387 **/
388void 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(lock: &fw_upload_priv->lock);
397 goto unregister;
398 }
399
400 fw_upload_priv->ops->cancel(fw_upload);
401 mutex_unlock(lock: &fw_upload_priv->lock);
402
403 /* Ensure lower-level device-driver is finished */
404 flush_work(work: &fw_upload_priv->work);
405
406unregister:
407 device_unregister(dev: &fw_sysfs->dev);
408 module_put(module);
409}
410EXPORT_SYMBOL_GPL(firmware_upload_unregister);
411

source code of linux/drivers/base/firmware_loader/sysfs_upload.c