sysfs_upload.c

  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, "%s\n", fw_upload_progress(dev, 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, "%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}
 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(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}
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, "%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(&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(&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(&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, 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
204done:
205	if (fwlp->ops->cleanup)
206		fwlp->ops->cleanup(fwl);
207
208putdev_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 */
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_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
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_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 **/
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(-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
368free_fw_sysfs:
369	kfree(fw_sysfs);
370
371free_fw_upload_priv:
372	kfree(fw_upload_priv);
373
374free_fw_upload:
375	kfree(fw_upload);
376
377exit_module_put:
378	module_put(module);
379
380	return ERR_PTR(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(&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
406unregister:
407	device_unregister(&fw_sysfs->dev);
408	module_put(module);
409}
410EXPORT_SYMBOL_GPL(firmware_upload_unregister);