1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Greybus Firmware Management Protocol Driver.
4 *
5 * Copyright 2016 Google Inc.
6 * Copyright 2016 Linaro Ltd.
7 */
8
9 #include <linux/cdev.h>
10 #include <linux/completion.h>
11 #include <linux/firmware.h>
12 #include <linux/fs.h>
13 #include <linux/idr.h>
14 #include <linux/ioctl.h>
15 #include <linux/uaccess.h>
16
17 #include "firmware.h"
18 #include "greybus_firmware.h"
19 #include "greybus.h"
20
21 #define FW_MGMT_TIMEOUT_MS 1000
22
23 struct fw_mgmt {
24 struct device *parent;
25 struct gb_connection *connection;
26 struct kref kref;
27 struct list_head node;
28
29 /* Common id-map for interface and backend firmware requests */
30 struct ida id_map;
31 struct mutex mutex;
32 struct completion completion;
33 struct cdev cdev;
34 struct device *class_device;
35 dev_t dev_num;
36 unsigned int timeout_jiffies;
37 bool disabled; /* connection getting disabled */
38
39 /* Interface Firmware specific fields */
40 bool mode_switch_started;
41 bool intf_fw_loaded;
42 u8 intf_fw_request_id;
43 u8 intf_fw_status;
44 u16 intf_fw_major;
45 u16 intf_fw_minor;
46
47 /* Backend Firmware specific fields */
48 u8 backend_fw_request_id;
49 u8 backend_fw_status;
50 };
51
52 /*
53 * Number of minor devices this driver supports.
54 * There will be exactly one required per Interface.
55 */
56 #define NUM_MINORS U8_MAX
57
58 static struct class *fw_mgmt_class;
59 static dev_t fw_mgmt_dev_num;
60 static DEFINE_IDA(fw_mgmt_minors_map);
61 static LIST_HEAD(fw_mgmt_list);
62 static DEFINE_MUTEX(list_mutex);
63
fw_mgmt_kref_release(struct kref * kref)64 static void fw_mgmt_kref_release(struct kref *kref)
65 {
66 struct fw_mgmt *fw_mgmt = container_of(kref, struct fw_mgmt, kref);
67
68 ida_destroy(&fw_mgmt->id_map);
69 kfree(fw_mgmt);
70 }
71
72 /*
73 * All users of fw_mgmt take a reference (from within list_mutex lock), before
74 * they get a pointer to play with. And the structure will be freed only after
75 * the last user has put the reference to it.
76 */
put_fw_mgmt(struct fw_mgmt * fw_mgmt)77 static void put_fw_mgmt(struct fw_mgmt *fw_mgmt)
78 {
79 kref_put(&fw_mgmt->kref, fw_mgmt_kref_release);
80 }
81
82 /* Caller must call put_fw_mgmt() after using struct fw_mgmt */
get_fw_mgmt(struct cdev * cdev)83 static struct fw_mgmt *get_fw_mgmt(struct cdev *cdev)
84 {
85 struct fw_mgmt *fw_mgmt;
86
87 mutex_lock(&list_mutex);
88
89 list_for_each_entry(fw_mgmt, &fw_mgmt_list, node) {
90 if (&fw_mgmt->cdev == cdev) {
91 kref_get(&fw_mgmt->kref);
92 goto unlock;
93 }
94 }
95
96 fw_mgmt = NULL;
97
98 unlock:
99 mutex_unlock(&list_mutex);
100
101 return fw_mgmt;
102 }
103
fw_mgmt_interface_fw_version_operation(struct fw_mgmt * fw_mgmt,struct fw_mgmt_ioc_get_intf_version * fw_info)104 static int fw_mgmt_interface_fw_version_operation(struct fw_mgmt *fw_mgmt,
105 struct fw_mgmt_ioc_get_intf_version *fw_info)
106 {
107 struct gb_connection *connection = fw_mgmt->connection;
108 struct gb_fw_mgmt_interface_fw_version_response response;
109 int ret;
110
111 ret = gb_operation_sync(connection,
112 GB_FW_MGMT_TYPE_INTERFACE_FW_VERSION, NULL, 0,
113 &response, sizeof(response));
114 if (ret) {
115 dev_err(fw_mgmt->parent,
116 "failed to get interface firmware version (%d)\n", ret);
117 return ret;
118 }
119
120 fw_info->major = le16_to_cpu(response.major);
121 fw_info->minor = le16_to_cpu(response.minor);
122
123 strncpy(fw_info->firmware_tag, response.firmware_tag,
124 GB_FIRMWARE_TAG_MAX_SIZE);
125
126 /*
127 * The firmware-tag should be NULL terminated, otherwise throw error but
128 * don't fail.
129 */
130 if (fw_info->firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
131 dev_err(fw_mgmt->parent,
132 "fw-version: firmware-tag is not NULL terminated\n");
133 fw_info->firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] = '\0';
134 }
135
136 return 0;
137 }
138
fw_mgmt_load_and_validate_operation(struct fw_mgmt * fw_mgmt,u8 load_method,const char * tag)139 static int fw_mgmt_load_and_validate_operation(struct fw_mgmt *fw_mgmt,
140 u8 load_method, const char *tag)
141 {
142 struct gb_fw_mgmt_load_and_validate_fw_request request;
143 int ret;
144
145 if (load_method != GB_FW_LOAD_METHOD_UNIPRO &&
146 load_method != GB_FW_LOAD_METHOD_INTERNAL) {
147 dev_err(fw_mgmt->parent,
148 "invalid load-method (%d)\n", load_method);
149 return -EINVAL;
150 }
151
152 request.load_method = load_method;
153 strncpy(request.firmware_tag, tag, GB_FIRMWARE_TAG_MAX_SIZE);
154
155 /*
156 * The firmware-tag should be NULL terminated, otherwise throw error and
157 * fail.
158 */
159 if (request.firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
160 dev_err(fw_mgmt->parent, "load-and-validate: firmware-tag is not NULL terminated\n");
161 return -EINVAL;
162 }
163
164 /* Allocate ids from 1 to 255 (u8-max), 0 is an invalid id */
165 ret = ida_simple_get(&fw_mgmt->id_map, 1, 256, GFP_KERNEL);
166 if (ret < 0) {
167 dev_err(fw_mgmt->parent, "failed to allocate request id (%d)\n",
168 ret);
169 return ret;
170 }
171
172 fw_mgmt->intf_fw_request_id = ret;
173 fw_mgmt->intf_fw_loaded = false;
174 request.request_id = ret;
175
176 ret = gb_operation_sync(fw_mgmt->connection,
177 GB_FW_MGMT_TYPE_LOAD_AND_VALIDATE_FW, &request,
178 sizeof(request), NULL, 0);
179 if (ret) {
180 ida_simple_remove(&fw_mgmt->id_map,
181 fw_mgmt->intf_fw_request_id);
182 fw_mgmt->intf_fw_request_id = 0;
183 dev_err(fw_mgmt->parent,
184 "load and validate firmware request failed (%d)\n",
185 ret);
186 return ret;
187 }
188
189 return 0;
190 }
191
fw_mgmt_interface_fw_loaded_operation(struct gb_operation * op)192 static int fw_mgmt_interface_fw_loaded_operation(struct gb_operation *op)
193 {
194 struct gb_connection *connection = op->connection;
195 struct fw_mgmt *fw_mgmt = gb_connection_get_data(connection);
196 struct gb_fw_mgmt_loaded_fw_request *request;
197
198 /* No pending load and validate request ? */
199 if (!fw_mgmt->intf_fw_request_id) {
200 dev_err(fw_mgmt->parent,
201 "unexpected firmware loaded request received\n");
202 return -ENODEV;
203 }
204
205 if (op->request->payload_size != sizeof(*request)) {
206 dev_err(fw_mgmt->parent, "illegal size of firmware loaded request (%zu != %zu)\n",
207 op->request->payload_size, sizeof(*request));
208 return -EINVAL;
209 }
210
211 request = op->request->payload;
212
213 /* Invalid request-id ? */
214 if (request->request_id != fw_mgmt->intf_fw_request_id) {
215 dev_err(fw_mgmt->parent, "invalid request id for firmware loaded request (%02u != %02u)\n",
216 fw_mgmt->intf_fw_request_id, request->request_id);
217 return -ENODEV;
218 }
219
220 ida_simple_remove(&fw_mgmt->id_map, fw_mgmt->intf_fw_request_id);
221 fw_mgmt->intf_fw_request_id = 0;
222 fw_mgmt->intf_fw_status = request->status;
223 fw_mgmt->intf_fw_major = le16_to_cpu(request->major);
224 fw_mgmt->intf_fw_minor = le16_to_cpu(request->minor);
225
226 if (fw_mgmt->intf_fw_status == GB_FW_LOAD_STATUS_FAILED)
227 dev_err(fw_mgmt->parent,
228 "failed to load interface firmware, status:%02x\n",
229 fw_mgmt->intf_fw_status);
230 else if (fw_mgmt->intf_fw_status == GB_FW_LOAD_STATUS_VALIDATION_FAILED)
231 dev_err(fw_mgmt->parent,
232 "failed to validate interface firmware, status:%02x\n",
233 fw_mgmt->intf_fw_status);
234 else
235 fw_mgmt->intf_fw_loaded = true;
236
237 complete(&fw_mgmt->completion);
238
239 return 0;
240 }
241
fw_mgmt_backend_fw_version_operation(struct fw_mgmt * fw_mgmt,struct fw_mgmt_ioc_get_backend_version * fw_info)242 static int fw_mgmt_backend_fw_version_operation(struct fw_mgmt *fw_mgmt,
243 struct fw_mgmt_ioc_get_backend_version *fw_info)
244 {
245 struct gb_connection *connection = fw_mgmt->connection;
246 struct gb_fw_mgmt_backend_fw_version_request request;
247 struct gb_fw_mgmt_backend_fw_version_response response;
248 int ret;
249
250 strncpy(request.firmware_tag, fw_info->firmware_tag,
251 GB_FIRMWARE_TAG_MAX_SIZE);
252
253 /*
254 * The firmware-tag should be NULL terminated, otherwise throw error and
255 * fail.
256 */
257 if (request.firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
258 dev_err(fw_mgmt->parent, "backend-version: firmware-tag is not NULL terminated\n");
259 return -EINVAL;
260 }
261
262 ret = gb_operation_sync(connection,
263 GB_FW_MGMT_TYPE_BACKEND_FW_VERSION, &request,
264 sizeof(request), &response, sizeof(response));
265 if (ret) {
266 dev_err(fw_mgmt->parent, "failed to get version of %s backend firmware (%d)\n",
267 fw_info->firmware_tag, ret);
268 return ret;
269 }
270
271 fw_info->status = response.status;
272
273 /* Reset version as that should be non-zero only for success case */
274 fw_info->major = 0;
275 fw_info->minor = 0;
276
277 switch (fw_info->status) {
278 case GB_FW_BACKEND_VERSION_STATUS_SUCCESS:
279 fw_info->major = le16_to_cpu(response.major);
280 fw_info->minor = le16_to_cpu(response.minor);
281 break;
282 case GB_FW_BACKEND_VERSION_STATUS_NOT_AVAILABLE:
283 case GB_FW_BACKEND_VERSION_STATUS_RETRY:
284 break;
285 case GB_FW_BACKEND_VERSION_STATUS_NOT_SUPPORTED:
286 dev_err(fw_mgmt->parent,
287 "Firmware with tag %s is not supported by Interface\n",
288 fw_info->firmware_tag);
289 break;
290 default:
291 dev_err(fw_mgmt->parent, "Invalid status received: %u\n",
292 fw_info->status);
293 }
294
295 return 0;
296 }
297
fw_mgmt_backend_fw_update_operation(struct fw_mgmt * fw_mgmt,char * tag)298 static int fw_mgmt_backend_fw_update_operation(struct fw_mgmt *fw_mgmt,
299 char *tag)
300 {
301 struct gb_fw_mgmt_backend_fw_update_request request;
302 int ret;
303
304 strncpy(request.firmware_tag, tag, GB_FIRMWARE_TAG_MAX_SIZE);
305
306 /*
307 * The firmware-tag should be NULL terminated, otherwise throw error and
308 * fail.
309 */
310 if (request.firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
311 dev_err(fw_mgmt->parent, "backend-update: firmware-tag is not NULL terminated\n");
312 return -EINVAL;
313 }
314
315 /* Allocate ids from 1 to 255 (u8-max), 0 is an invalid id */
316 ret = ida_simple_get(&fw_mgmt->id_map, 1, 256, GFP_KERNEL);
317 if (ret < 0) {
318 dev_err(fw_mgmt->parent, "failed to allocate request id (%d)\n",
319 ret);
320 return ret;
321 }
322
323 fw_mgmt->backend_fw_request_id = ret;
324 request.request_id = ret;
325
326 ret = gb_operation_sync(fw_mgmt->connection,
327 GB_FW_MGMT_TYPE_BACKEND_FW_UPDATE, &request,
328 sizeof(request), NULL, 0);
329 if (ret) {
330 ida_simple_remove(&fw_mgmt->id_map,
331 fw_mgmt->backend_fw_request_id);
332 fw_mgmt->backend_fw_request_id = 0;
333 dev_err(fw_mgmt->parent,
334 "backend %s firmware update request failed (%d)\n", tag,
335 ret);
336 return ret;
337 }
338
339 return 0;
340 }
341
fw_mgmt_backend_fw_updated_operation(struct gb_operation * op)342 static int fw_mgmt_backend_fw_updated_operation(struct gb_operation *op)
343 {
344 struct gb_connection *connection = op->connection;
345 struct fw_mgmt *fw_mgmt = gb_connection_get_data(connection);
346 struct gb_fw_mgmt_backend_fw_updated_request *request;
347
348 /* No pending load and validate request ? */
349 if (!fw_mgmt->backend_fw_request_id) {
350 dev_err(fw_mgmt->parent, "unexpected backend firmware updated request received\n");
351 return -ENODEV;
352 }
353
354 if (op->request->payload_size != sizeof(*request)) {
355 dev_err(fw_mgmt->parent, "illegal size of backend firmware updated request (%zu != %zu)\n",
356 op->request->payload_size, sizeof(*request));
357 return -EINVAL;
358 }
359
360 request = op->request->payload;
361
362 /* Invalid request-id ? */
363 if (request->request_id != fw_mgmt->backend_fw_request_id) {
364 dev_err(fw_mgmt->parent, "invalid request id for backend firmware updated request (%02u != %02u)\n",
365 fw_mgmt->backend_fw_request_id, request->request_id);
366 return -ENODEV;
367 }
368
369 ida_simple_remove(&fw_mgmt->id_map, fw_mgmt->backend_fw_request_id);
370 fw_mgmt->backend_fw_request_id = 0;
371 fw_mgmt->backend_fw_status = request->status;
372
373 if ((fw_mgmt->backend_fw_status != GB_FW_BACKEND_FW_STATUS_SUCCESS) &&
374 (fw_mgmt->backend_fw_status != GB_FW_BACKEND_FW_STATUS_RETRY))
375 dev_err(fw_mgmt->parent,
376 "failed to load backend firmware: %02x\n",
377 fw_mgmt->backend_fw_status);
378
379 complete(&fw_mgmt->completion);
380
381 return 0;
382 }
383
384 /* Char device fops */
385
fw_mgmt_open(struct inode * inode,struct file * file)386 static int fw_mgmt_open(struct inode *inode, struct file *file)
387 {
388 struct fw_mgmt *fw_mgmt = get_fw_mgmt(inode->i_cdev);
389
390 /* fw_mgmt structure can't get freed until file descriptor is closed */
391 if (fw_mgmt) {
392 file->private_data = fw_mgmt;
393 return 0;
394 }
395
396 return -ENODEV;
397 }
398
fw_mgmt_release(struct inode * inode,struct file * file)399 static int fw_mgmt_release(struct inode *inode, struct file *file)
400 {
401 struct fw_mgmt *fw_mgmt = file->private_data;
402
403 put_fw_mgmt(fw_mgmt);
404 return 0;
405 }
406
fw_mgmt_ioctl(struct fw_mgmt * fw_mgmt,unsigned int cmd,void __user * buf)407 static int fw_mgmt_ioctl(struct fw_mgmt *fw_mgmt, unsigned int cmd,
408 void __user *buf)
409 {
410 struct fw_mgmt_ioc_get_intf_version intf_fw_info;
411 struct fw_mgmt_ioc_get_backend_version backend_fw_info;
412 struct fw_mgmt_ioc_intf_load_and_validate intf_load;
413 struct fw_mgmt_ioc_backend_fw_update backend_update;
414 unsigned int timeout;
415 int ret;
416
417 /* Reject any operations after mode-switch has started */
418 if (fw_mgmt->mode_switch_started)
419 return -EBUSY;
420
421 switch (cmd) {
422 case FW_MGMT_IOC_GET_INTF_FW:
423 ret = fw_mgmt_interface_fw_version_operation(fw_mgmt,
424 &intf_fw_info);
425 if (ret)
426 return ret;
427
428 if (copy_to_user(buf, &intf_fw_info, sizeof(intf_fw_info)))
429 return -EFAULT;
430
431 return 0;
432 case FW_MGMT_IOC_GET_BACKEND_FW:
433 if (copy_from_user(&backend_fw_info, buf,
434 sizeof(backend_fw_info)))
435 return -EFAULT;
436
437 ret = fw_mgmt_backend_fw_version_operation(fw_mgmt,
438 &backend_fw_info);
439 if (ret)
440 return ret;
441
442 if (copy_to_user(buf, &backend_fw_info,
443 sizeof(backend_fw_info)))
444 return -EFAULT;
445
446 return 0;
447 case FW_MGMT_IOC_INTF_LOAD_AND_VALIDATE:
448 if (copy_from_user(&intf_load, buf, sizeof(intf_load)))
449 return -EFAULT;
450
451 ret = fw_mgmt_load_and_validate_operation(fw_mgmt,
452 intf_load.load_method, intf_load.firmware_tag);
453 if (ret)
454 return ret;
455
456 if (!wait_for_completion_timeout(&fw_mgmt->completion,
457 fw_mgmt->timeout_jiffies)) {
458 dev_err(fw_mgmt->parent, "timed out waiting for firmware load and validation to finish\n");
459 return -ETIMEDOUT;
460 }
461
462 intf_load.status = fw_mgmt->intf_fw_status;
463 intf_load.major = fw_mgmt->intf_fw_major;
464 intf_load.minor = fw_mgmt->intf_fw_minor;
465
466 if (copy_to_user(buf, &intf_load, sizeof(intf_load)))
467 return -EFAULT;
468
469 return 0;
470 case FW_MGMT_IOC_INTF_BACKEND_FW_UPDATE:
471 if (copy_from_user(&backend_update, buf,
472 sizeof(backend_update)))
473 return -EFAULT;
474
475 ret = fw_mgmt_backend_fw_update_operation(fw_mgmt,
476 backend_update.firmware_tag);
477 if (ret)
478 return ret;
479
480 if (!wait_for_completion_timeout(&fw_mgmt->completion,
481 fw_mgmt->timeout_jiffies)) {
482 dev_err(fw_mgmt->parent, "timed out waiting for backend firmware update to finish\n");
483 return -ETIMEDOUT;
484 }
485
486 backend_update.status = fw_mgmt->backend_fw_status;
487
488 if (copy_to_user(buf, &backend_update, sizeof(backend_update)))
489 return -EFAULT;
490
491 return 0;
492 case FW_MGMT_IOC_SET_TIMEOUT_MS:
493 if (get_user(timeout, (unsigned int __user *)buf))
494 return -EFAULT;
495
496 if (!timeout) {
497 dev_err(fw_mgmt->parent, "timeout can't be zero\n");
498 return -EINVAL;
499 }
500
501 fw_mgmt->timeout_jiffies = msecs_to_jiffies(timeout);
502
503 return 0;
504 case FW_MGMT_IOC_MODE_SWITCH:
505 if (!fw_mgmt->intf_fw_loaded) {
506 dev_err(fw_mgmt->parent,
507 "Firmware not loaded for mode-switch\n");
508 return -EPERM;
509 }
510
511 /*
512 * Disallow new ioctls as the fw-core bundle driver is going to
513 * get disconnected soon and the character device will get
514 * removed.
515 */
516 fw_mgmt->mode_switch_started = true;
517
518 ret = gb_interface_request_mode_switch(fw_mgmt->connection->intf);
519 if (ret) {
520 dev_err(fw_mgmt->parent, "Mode-switch failed: %d\n",
521 ret);
522 fw_mgmt->mode_switch_started = false;
523 return ret;
524 }
525
526 return 0;
527 default:
528 return -ENOTTY;
529 }
530 }
531
fw_mgmt_ioctl_unlocked(struct file * file,unsigned int cmd,unsigned long arg)532 static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd,
533 unsigned long arg)
534 {
535 struct fw_mgmt *fw_mgmt = file->private_data;
536 struct gb_bundle *bundle = fw_mgmt->connection->bundle;
537 int ret = -ENODEV;
538
539 /*
540 * Serialize ioctls.
541 *
542 * We don't want the user to do few operations in parallel. For example,
543 * updating Interface firmware in parallel for the same Interface. There
544 * is no need to do things in parallel for speed and we can avoid having
545 * complicated code for now.
546 *
547 * This is also used to protect ->disabled, which is used to check if
548 * the connection is getting disconnected, so that we don't start any
549 * new operations.
550 */
551 mutex_lock(&fw_mgmt->mutex);
552 if (!fw_mgmt->disabled) {
553 ret = gb_pm_runtime_get_sync(bundle);
554 if (!ret) {
555 ret = fw_mgmt_ioctl(fw_mgmt, cmd, (void __user *)arg);
556 gb_pm_runtime_put_autosuspend(bundle);
557 }
558 }
559 mutex_unlock(&fw_mgmt->mutex);
560
561 return ret;
562 }
563
564 static const struct file_operations fw_mgmt_fops = {
565 .owner = THIS_MODULE,
566 .open = fw_mgmt_open,
567 .release = fw_mgmt_release,
568 .unlocked_ioctl = fw_mgmt_ioctl_unlocked,
569 };
570
gb_fw_mgmt_request_handler(struct gb_operation * op)571 int gb_fw_mgmt_request_handler(struct gb_operation *op)
572 {
573 u8 type = op->type;
574
575 switch (type) {
576 case GB_FW_MGMT_TYPE_LOADED_FW:
577 return fw_mgmt_interface_fw_loaded_operation(op);
578 case GB_FW_MGMT_TYPE_BACKEND_FW_UPDATED:
579 return fw_mgmt_backend_fw_updated_operation(op);
580 default:
581 dev_err(&op->connection->bundle->dev,
582 "unsupported request: %u\n", type);
583 return -EINVAL;
584 }
585 }
586
gb_fw_mgmt_connection_init(struct gb_connection * connection)587 int gb_fw_mgmt_connection_init(struct gb_connection *connection)
588 {
589 struct fw_mgmt *fw_mgmt;
590 int ret, minor;
591
592 if (!connection)
593 return 0;
594
595 fw_mgmt = kzalloc(sizeof(*fw_mgmt), GFP_KERNEL);
596 if (!fw_mgmt)
597 return -ENOMEM;
598
599 fw_mgmt->parent = &connection->bundle->dev;
600 fw_mgmt->timeout_jiffies = msecs_to_jiffies(FW_MGMT_TIMEOUT_MS);
601 fw_mgmt->connection = connection;
602
603 gb_connection_set_data(connection, fw_mgmt);
604 init_completion(&fw_mgmt->completion);
605 ida_init(&fw_mgmt->id_map);
606 mutex_init(&fw_mgmt->mutex);
607 kref_init(&fw_mgmt->kref);
608
609 mutex_lock(&list_mutex);
610 list_add(&fw_mgmt->node, &fw_mgmt_list);
611 mutex_unlock(&list_mutex);
612
613 ret = gb_connection_enable(connection);
614 if (ret)
615 goto err_list_del;
616
617 minor = ida_simple_get(&fw_mgmt_minors_map, 0, NUM_MINORS, GFP_KERNEL);
618 if (minor < 0) {
619 ret = minor;
620 goto err_connection_disable;
621 }
622
623 /* Add a char device to allow userspace to interact with fw-mgmt */
624 fw_mgmt->dev_num = MKDEV(MAJOR(fw_mgmt_dev_num), minor);
625 cdev_init(&fw_mgmt->cdev, &fw_mgmt_fops);
626
627 ret = cdev_add(&fw_mgmt->cdev, fw_mgmt->dev_num, 1);
628 if (ret)
629 goto err_remove_ida;
630
631 /* Add a soft link to the previously added char-dev within the bundle */
632 fw_mgmt->class_device = device_create(fw_mgmt_class, fw_mgmt->parent,
633 fw_mgmt->dev_num, NULL,
634 "gb-fw-mgmt-%d", minor);
635 if (IS_ERR(fw_mgmt->class_device)) {
636 ret = PTR_ERR(fw_mgmt->class_device);
637 goto err_del_cdev;
638 }
639
640 return 0;
641
642 err_del_cdev:
643 cdev_del(&fw_mgmt->cdev);
644 err_remove_ida:
645 ida_simple_remove(&fw_mgmt_minors_map, minor);
646 err_connection_disable:
647 gb_connection_disable(connection);
648 err_list_del:
649 mutex_lock(&list_mutex);
650 list_del(&fw_mgmt->node);
651 mutex_unlock(&list_mutex);
652
653 put_fw_mgmt(fw_mgmt);
654
655 return ret;
656 }
657
gb_fw_mgmt_connection_exit(struct gb_connection * connection)658 void gb_fw_mgmt_connection_exit(struct gb_connection *connection)
659 {
660 struct fw_mgmt *fw_mgmt;
661
662 if (!connection)
663 return;
664
665 fw_mgmt = gb_connection_get_data(connection);
666
667 device_destroy(fw_mgmt_class, fw_mgmt->dev_num);
668 cdev_del(&fw_mgmt->cdev);
669 ida_simple_remove(&fw_mgmt_minors_map, MINOR(fw_mgmt->dev_num));
670
671 /*
672 * Disallow any new ioctl operations on the char device and wait for
673 * existing ones to finish.
674 */
675 mutex_lock(&fw_mgmt->mutex);
676 fw_mgmt->disabled = true;
677 mutex_unlock(&fw_mgmt->mutex);
678
679 /* All pending greybus operations should have finished by now */
680 gb_connection_disable(fw_mgmt->connection);
681
682 /* Disallow new users to get access to the fw_mgmt structure */
683 mutex_lock(&list_mutex);
684 list_del(&fw_mgmt->node);
685 mutex_unlock(&list_mutex);
686
687 /*
688 * All current users of fw_mgmt would have taken a reference to it by
689 * now, we can drop our reference and wait the last user will get
690 * fw_mgmt freed.
691 */
692 put_fw_mgmt(fw_mgmt);
693 }
694
fw_mgmt_init(void)695 int fw_mgmt_init(void)
696 {
697 int ret;
698
699 fw_mgmt_class = class_create(THIS_MODULE, "gb_fw_mgmt");
700 if (IS_ERR(fw_mgmt_class))
701 return PTR_ERR(fw_mgmt_class);
702
703 ret = alloc_chrdev_region(&fw_mgmt_dev_num, 0, NUM_MINORS,
704 "gb_fw_mgmt");
705 if (ret)
706 goto err_remove_class;
707
708 return 0;
709
710 err_remove_class:
711 class_destroy(fw_mgmt_class);
712 return ret;
713 }
714
fw_mgmt_exit(void)715 void fw_mgmt_exit(void)
716 {
717 unregister_chrdev_region(fw_mgmt_dev_num, NUM_MINORS);
718 class_destroy(fw_mgmt_class);
719 ida_destroy(&fw_mgmt_minors_map);
720 }
721
