1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Media device |
4 | * |
5 | * Copyright (C) 2010 Nokia Corporation |
6 | * |
7 | * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> |
8 | * Sakari Ailus <sakari.ailus@iki.fi> |
9 | */ |
10 | |
11 | #include <linux/compat.h> |
12 | #include <linux/export.h> |
13 | #include <linux/idr.h> |
14 | #include <linux/ioctl.h> |
15 | #include <linux/media.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/types.h> |
18 | #include <linux/pci.h> |
19 | #include <linux/usb.h> |
20 | #include <linux/version.h> |
21 | |
22 | #include <media/media-device.h> |
23 | #include <media/media-devnode.h> |
24 | #include <media/media-entity.h> |
25 | #include <media/media-request.h> |
26 | |
27 | #ifdef CONFIG_MEDIA_CONTROLLER |
28 | |
29 | /* |
30 | * Legacy defines from linux/media.h. This is the only place we need this |
31 | * so we just define it here. The media.h header doesn't expose it to the |
32 | * kernel to prevent it from being used by drivers, but here (and only here!) |
33 | * we need it to handle the legacy behavior. |
34 | */ |
35 | #define MEDIA_ENT_SUBTYPE_MASK 0x0000ffff |
36 | #define MEDIA_ENT_T_DEVNODE_UNKNOWN (MEDIA_ENT_F_OLD_BASE | \ |
37 | MEDIA_ENT_SUBTYPE_MASK) |
38 | |
39 | /* ----------------------------------------------------------------------------- |
40 | * Userspace API |
41 | */ |
42 | |
43 | static inline void __user *media_get_uptr(__u64 arg) |
44 | { |
45 | return (void __user *)(uintptr_t)arg; |
46 | } |
47 | |
48 | static int media_device_open(struct file *filp) |
49 | { |
50 | return 0; |
51 | } |
52 | |
53 | static int media_device_close(struct file *filp) |
54 | { |
55 | return 0; |
56 | } |
57 | |
58 | static long media_device_get_info(struct media_device *dev, void *arg) |
59 | { |
60 | struct media_device_info *info = arg; |
61 | |
62 | memset(info, 0, sizeof(*info)); |
63 | |
64 | if (dev->driver_name[0]) |
65 | strscpy(p: info->driver, q: dev->driver_name, size: sizeof(info->driver)); |
66 | else |
67 | strscpy(p: info->driver, q: dev->dev->driver->name, |
68 | size: sizeof(info->driver)); |
69 | |
70 | strscpy(p: info->model, q: dev->model, size: sizeof(info->model)); |
71 | strscpy(p: info->serial, q: dev->serial, size: sizeof(info->serial)); |
72 | strscpy(p: info->bus_info, q: dev->bus_info, size: sizeof(info->bus_info)); |
73 | |
74 | info->media_version = LINUX_VERSION_CODE; |
75 | info->driver_version = info->media_version; |
76 | info->hw_revision = dev->hw_revision; |
77 | |
78 | return 0; |
79 | } |
80 | |
81 | static struct media_entity *find_entity(struct media_device *mdev, u32 id) |
82 | { |
83 | struct media_entity *entity; |
84 | int next = id & MEDIA_ENT_ID_FLAG_NEXT; |
85 | |
86 | id &= ~MEDIA_ENT_ID_FLAG_NEXT; |
87 | |
88 | media_device_for_each_entity(entity, mdev) { |
89 | if (((media_entity_id(entity) == id) && !next) || |
90 | ((media_entity_id(entity) > id) && next)) { |
91 | return entity; |
92 | } |
93 | } |
94 | |
95 | return NULL; |
96 | } |
97 | |
98 | static long media_device_enum_entities(struct media_device *mdev, void *arg) |
99 | { |
100 | struct media_entity_desc *entd = arg; |
101 | struct media_entity *ent; |
102 | |
103 | ent = find_entity(mdev, id: entd->id); |
104 | if (ent == NULL) |
105 | return -EINVAL; |
106 | |
107 | memset(entd, 0, sizeof(*entd)); |
108 | |
109 | entd->id = media_entity_id(entity: ent); |
110 | if (ent->name) |
111 | strscpy(p: entd->name, q: ent->name, size: sizeof(entd->name)); |
112 | entd->type = ent->function; |
113 | entd->revision = 0; /* Unused */ |
114 | entd->flags = ent->flags; |
115 | entd->group_id = 0; /* Unused */ |
116 | entd->pads = ent->num_pads; |
117 | entd->links = ent->num_links - ent->num_backlinks; |
118 | |
119 | /* |
120 | * Workaround for a bug at media-ctl <= v1.10 that makes it to |
121 | * do the wrong thing if the entity function doesn't belong to |
122 | * either MEDIA_ENT_F_OLD_BASE or MEDIA_ENT_F_OLD_SUBDEV_BASE |
123 | * Ranges. |
124 | * |
125 | * Non-subdevices are expected to be at the MEDIA_ENT_F_OLD_BASE, |
126 | * or, otherwise, will be silently ignored by media-ctl when |
127 | * printing the graphviz diagram. So, map them into the devnode |
128 | * old range. |
129 | */ |
130 | if (ent->function < MEDIA_ENT_F_OLD_BASE || |
131 | ent->function > MEDIA_ENT_F_TUNER) { |
132 | if (is_media_entity_v4l2_subdev(entity: ent)) |
133 | entd->type = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN; |
134 | else if (ent->function != MEDIA_ENT_F_IO_V4L) |
135 | entd->type = MEDIA_ENT_T_DEVNODE_UNKNOWN; |
136 | } |
137 | |
138 | memcpy(&entd->raw, &ent->info, sizeof(ent->info)); |
139 | |
140 | return 0; |
141 | } |
142 | |
143 | static void media_device_kpad_to_upad(const struct media_pad *kpad, |
144 | struct media_pad_desc *upad) |
145 | { |
146 | upad->entity = media_entity_id(entity: kpad->entity); |
147 | upad->index = kpad->index; |
148 | upad->flags = kpad->flags; |
149 | } |
150 | |
151 | static long media_device_enum_links(struct media_device *mdev, void *arg) |
152 | { |
153 | struct media_links_enum *links = arg; |
154 | struct media_entity *entity; |
155 | |
156 | entity = find_entity(mdev, id: links->entity); |
157 | if (entity == NULL) |
158 | return -EINVAL; |
159 | |
160 | if (links->pads) { |
161 | unsigned int p; |
162 | |
163 | for (p = 0; p < entity->num_pads; p++) { |
164 | struct media_pad_desc pad; |
165 | |
166 | memset(&pad, 0, sizeof(pad)); |
167 | media_device_kpad_to_upad(kpad: &entity->pads[p], upad: &pad); |
168 | if (copy_to_user(to: &links->pads[p], from: &pad, n: sizeof(pad))) |
169 | return -EFAULT; |
170 | } |
171 | } |
172 | |
173 | if (links->links) { |
174 | struct media_link *link; |
175 | struct media_link_desc __user *ulink_desc = links->links; |
176 | |
177 | list_for_each_entry(link, &entity->links, list) { |
178 | struct media_link_desc klink_desc; |
179 | |
180 | /* Ignore backlinks. */ |
181 | if (link->source->entity != entity) |
182 | continue; |
183 | memset(&klink_desc, 0, sizeof(klink_desc)); |
184 | media_device_kpad_to_upad(kpad: link->source, |
185 | upad: &klink_desc.source); |
186 | media_device_kpad_to_upad(kpad: link->sink, |
187 | upad: &klink_desc.sink); |
188 | klink_desc.flags = link->flags; |
189 | if (copy_to_user(to: ulink_desc, from: &klink_desc, |
190 | n: sizeof(*ulink_desc))) |
191 | return -EFAULT; |
192 | ulink_desc++; |
193 | } |
194 | } |
195 | memset(links->reserved, 0, sizeof(links->reserved)); |
196 | |
197 | return 0; |
198 | } |
199 | |
200 | static long media_device_setup_link(struct media_device *mdev, void *arg) |
201 | { |
202 | struct media_link_desc *linkd = arg; |
203 | struct media_link *link = NULL; |
204 | struct media_entity *source; |
205 | struct media_entity *sink; |
206 | |
207 | /* Find the source and sink entities and link. |
208 | */ |
209 | source = find_entity(mdev, id: linkd->source.entity); |
210 | sink = find_entity(mdev, id: linkd->sink.entity); |
211 | |
212 | if (source == NULL || sink == NULL) |
213 | return -EINVAL; |
214 | |
215 | if (linkd->source.index >= source->num_pads || |
216 | linkd->sink.index >= sink->num_pads) |
217 | return -EINVAL; |
218 | |
219 | link = media_entity_find_link(source: &source->pads[linkd->source.index], |
220 | sink: &sink->pads[linkd->sink.index]); |
221 | if (link == NULL) |
222 | return -EINVAL; |
223 | |
224 | memset(linkd->reserved, 0, sizeof(linkd->reserved)); |
225 | |
226 | /* Setup the link on both entities. */ |
227 | return __media_entity_setup_link(link, flags: linkd->flags); |
228 | } |
229 | |
230 | static long media_device_get_topology(struct media_device *mdev, void *arg) |
231 | { |
232 | struct media_v2_topology *topo = arg; |
233 | struct media_entity *entity; |
234 | struct media_interface *intf; |
235 | struct media_pad *pad; |
236 | struct media_link *link; |
237 | struct media_v2_entity kentity, __user *uentity; |
238 | struct media_v2_interface kintf, __user *uintf; |
239 | struct media_v2_pad kpad, __user *upad; |
240 | struct media_v2_link klink, __user *ulink; |
241 | unsigned int i; |
242 | int ret = 0; |
243 | |
244 | topo->topology_version = mdev->topology_version; |
245 | |
246 | /* Get entities and number of entities */ |
247 | i = 0; |
248 | uentity = media_get_uptr(arg: topo->ptr_entities); |
249 | media_device_for_each_entity(entity, mdev) { |
250 | i++; |
251 | if (ret || !uentity) |
252 | continue; |
253 | |
254 | if (i > topo->num_entities) { |
255 | ret = -ENOSPC; |
256 | continue; |
257 | } |
258 | |
259 | /* Copy fields to userspace struct if not error */ |
260 | memset(&kentity, 0, sizeof(kentity)); |
261 | kentity.id = entity->graph_obj.id; |
262 | kentity.function = entity->function; |
263 | kentity.flags = entity->flags; |
264 | strscpy(p: kentity.name, q: entity->name, |
265 | size: sizeof(kentity.name)); |
266 | |
267 | if (copy_to_user(to: uentity, from: &kentity, n: sizeof(kentity))) |
268 | ret = -EFAULT; |
269 | uentity++; |
270 | } |
271 | topo->num_entities = i; |
272 | topo->reserved1 = 0; |
273 | |
274 | /* Get interfaces and number of interfaces */ |
275 | i = 0; |
276 | uintf = media_get_uptr(arg: topo->ptr_interfaces); |
277 | media_device_for_each_intf(intf, mdev) { |
278 | i++; |
279 | if (ret || !uintf) |
280 | continue; |
281 | |
282 | if (i > topo->num_interfaces) { |
283 | ret = -ENOSPC; |
284 | continue; |
285 | } |
286 | |
287 | memset(&kintf, 0, sizeof(kintf)); |
288 | |
289 | /* Copy intf fields to userspace struct */ |
290 | kintf.id = intf->graph_obj.id; |
291 | kintf.intf_type = intf->type; |
292 | kintf.flags = intf->flags; |
293 | |
294 | if (media_type(gobj: &intf->graph_obj) == MEDIA_GRAPH_INTF_DEVNODE) { |
295 | struct media_intf_devnode *devnode; |
296 | |
297 | devnode = intf_to_devnode(intf); |
298 | |
299 | kintf.devnode.major = devnode->major; |
300 | kintf.devnode.minor = devnode->minor; |
301 | } |
302 | |
303 | if (copy_to_user(to: uintf, from: &kintf, n: sizeof(kintf))) |
304 | ret = -EFAULT; |
305 | uintf++; |
306 | } |
307 | topo->num_interfaces = i; |
308 | topo->reserved2 = 0; |
309 | |
310 | /* Get pads and number of pads */ |
311 | i = 0; |
312 | upad = media_get_uptr(arg: topo->ptr_pads); |
313 | media_device_for_each_pad(pad, mdev) { |
314 | i++; |
315 | if (ret || !upad) |
316 | continue; |
317 | |
318 | if (i > topo->num_pads) { |
319 | ret = -ENOSPC; |
320 | continue; |
321 | } |
322 | |
323 | memset(&kpad, 0, sizeof(kpad)); |
324 | |
325 | /* Copy pad fields to userspace struct */ |
326 | kpad.id = pad->graph_obj.id; |
327 | kpad.entity_id = pad->entity->graph_obj.id; |
328 | kpad.flags = pad->flags; |
329 | kpad.index = pad->index; |
330 | |
331 | if (copy_to_user(to: upad, from: &kpad, n: sizeof(kpad))) |
332 | ret = -EFAULT; |
333 | upad++; |
334 | } |
335 | topo->num_pads = i; |
336 | topo->reserved3 = 0; |
337 | |
338 | /* Get links and number of links */ |
339 | i = 0; |
340 | ulink = media_get_uptr(arg: topo->ptr_links); |
341 | media_device_for_each_link(link, mdev) { |
342 | if (link->is_backlink) |
343 | continue; |
344 | |
345 | i++; |
346 | |
347 | if (ret || !ulink) |
348 | continue; |
349 | |
350 | if (i > topo->num_links) { |
351 | ret = -ENOSPC; |
352 | continue; |
353 | } |
354 | |
355 | memset(&klink, 0, sizeof(klink)); |
356 | |
357 | /* Copy link fields to userspace struct */ |
358 | klink.id = link->graph_obj.id; |
359 | klink.source_id = link->gobj0->id; |
360 | klink.sink_id = link->gobj1->id; |
361 | klink.flags = link->flags; |
362 | |
363 | if (copy_to_user(to: ulink, from: &klink, n: sizeof(klink))) |
364 | ret = -EFAULT; |
365 | ulink++; |
366 | } |
367 | topo->num_links = i; |
368 | topo->reserved4 = 0; |
369 | |
370 | return ret; |
371 | } |
372 | |
373 | static long media_device_request_alloc(struct media_device *mdev, void *arg) |
374 | { |
375 | #ifdef CONFIG_MEDIA_CONTROLLER_REQUEST_API |
376 | int *alloc_fd = arg; |
377 | |
378 | if (!mdev->ops || !mdev->ops->req_validate || !mdev->ops->req_queue) |
379 | return -ENOTTY; |
380 | |
381 | return media_request_alloc(mdev, alloc_fd); |
382 | #else |
383 | return -ENOTTY; |
384 | #endif |
385 | } |
386 | |
387 | static long copy_arg_from_user(void *karg, void __user *uarg, unsigned int cmd) |
388 | { |
389 | if ((_IOC_DIR(cmd) & _IOC_WRITE) && |
390 | copy_from_user(to: karg, from: uarg, _IOC_SIZE(cmd))) |
391 | return -EFAULT; |
392 | |
393 | return 0; |
394 | } |
395 | |
396 | static long copy_arg_to_user(void __user *uarg, void *karg, unsigned int cmd) |
397 | { |
398 | if ((_IOC_DIR(cmd) & _IOC_READ) && |
399 | copy_to_user(to: uarg, from: karg, _IOC_SIZE(cmd))) |
400 | return -EFAULT; |
401 | |
402 | return 0; |
403 | } |
404 | |
405 | /* Do acquire the graph mutex */ |
406 | #define MEDIA_IOC_FL_GRAPH_MUTEX BIT(0) |
407 | |
408 | #define MEDIA_IOC_ARG(__cmd, func, fl, from_user, to_user) \ |
409 | [_IOC_NR(MEDIA_IOC_##__cmd)] = { \ |
410 | .cmd = MEDIA_IOC_##__cmd, \ |
411 | .fn = func, \ |
412 | .flags = fl, \ |
413 | .arg_from_user = from_user, \ |
414 | .arg_to_user = to_user, \ |
415 | } |
416 | |
417 | #define MEDIA_IOC(__cmd, func, fl) \ |
418 | MEDIA_IOC_ARG(__cmd, func, fl, copy_arg_from_user, copy_arg_to_user) |
419 | |
420 | /* the table is indexed by _IOC_NR(cmd) */ |
421 | struct media_ioctl_info { |
422 | unsigned int cmd; |
423 | unsigned short flags; |
424 | long (*fn)(struct media_device *dev, void *arg); |
425 | long (*arg_from_user)(void *karg, void __user *uarg, unsigned int cmd); |
426 | long (*arg_to_user)(void __user *uarg, void *karg, unsigned int cmd); |
427 | }; |
428 | |
429 | static const struct media_ioctl_info ioctl_info[] = { |
430 | MEDIA_IOC(DEVICE_INFO, media_device_get_info, MEDIA_IOC_FL_GRAPH_MUTEX), |
431 | MEDIA_IOC(ENUM_ENTITIES, media_device_enum_entities, MEDIA_IOC_FL_GRAPH_MUTEX), |
432 | MEDIA_IOC(ENUM_LINKS, media_device_enum_links, MEDIA_IOC_FL_GRAPH_MUTEX), |
433 | MEDIA_IOC(SETUP_LINK, media_device_setup_link, MEDIA_IOC_FL_GRAPH_MUTEX), |
434 | MEDIA_IOC(G_TOPOLOGY, media_device_get_topology, MEDIA_IOC_FL_GRAPH_MUTEX), |
435 | MEDIA_IOC(REQUEST_ALLOC, media_device_request_alloc, 0), |
436 | }; |
437 | |
438 | static long media_device_ioctl(struct file *filp, unsigned int cmd, |
439 | unsigned long __arg) |
440 | { |
441 | struct media_devnode *devnode = media_devnode_data(filp); |
442 | struct media_device *dev = devnode->media_dev; |
443 | const struct media_ioctl_info *info; |
444 | void __user *arg = (void __user *)__arg; |
445 | char __karg[256], *karg = __karg; |
446 | long ret; |
447 | |
448 | if (_IOC_NR(cmd) >= ARRAY_SIZE(ioctl_info) |
449 | || ioctl_info[_IOC_NR(cmd)].cmd != cmd) |
450 | return -ENOIOCTLCMD; |
451 | |
452 | info = &ioctl_info[_IOC_NR(cmd)]; |
453 | |
454 | if (_IOC_SIZE(info->cmd) > sizeof(__karg)) { |
455 | karg = kmalloc(_IOC_SIZE(info->cmd), GFP_KERNEL); |
456 | if (!karg) |
457 | return -ENOMEM; |
458 | } |
459 | |
460 | if (info->arg_from_user) { |
461 | ret = info->arg_from_user(karg, arg, cmd); |
462 | if (ret) |
463 | goto out_free; |
464 | } |
465 | |
466 | if (info->flags & MEDIA_IOC_FL_GRAPH_MUTEX) |
467 | mutex_lock(&dev->graph_mutex); |
468 | |
469 | ret = info->fn(dev, karg); |
470 | |
471 | if (info->flags & MEDIA_IOC_FL_GRAPH_MUTEX) |
472 | mutex_unlock(lock: &dev->graph_mutex); |
473 | |
474 | if (!ret && info->arg_to_user) |
475 | ret = info->arg_to_user(arg, karg, cmd); |
476 | |
477 | out_free: |
478 | if (karg != __karg) |
479 | kfree(objp: karg); |
480 | |
481 | return ret; |
482 | } |
483 | |
484 | #ifdef CONFIG_COMPAT |
485 | |
486 | struct media_links_enum32 { |
487 | __u32 entity; |
488 | compat_uptr_t pads; /* struct media_pad_desc * */ |
489 | compat_uptr_t links; /* struct media_link_desc * */ |
490 | __u32 reserved[4]; |
491 | }; |
492 | |
493 | static long media_device_enum_links32(struct media_device *mdev, |
494 | struct media_links_enum32 __user *ulinks) |
495 | { |
496 | struct media_links_enum links; |
497 | compat_uptr_t pads_ptr, links_ptr; |
498 | int ret; |
499 | |
500 | memset(&links, 0, sizeof(links)); |
501 | |
502 | if (get_user(links.entity, &ulinks->entity) |
503 | || get_user(pads_ptr, &ulinks->pads) |
504 | || get_user(links_ptr, &ulinks->links)) |
505 | return -EFAULT; |
506 | |
507 | links.pads = compat_ptr(uptr: pads_ptr); |
508 | links.links = compat_ptr(uptr: links_ptr); |
509 | |
510 | ret = media_device_enum_links(mdev, arg: &links); |
511 | if (ret) |
512 | return ret; |
513 | |
514 | if (copy_to_user(to: ulinks->reserved, from: links.reserved, |
515 | n: sizeof(ulinks->reserved))) |
516 | return -EFAULT; |
517 | return 0; |
518 | } |
519 | |
520 | #define MEDIA_IOC_ENUM_LINKS32 _IOWR('|', 0x02, struct media_links_enum32) |
521 | |
522 | static long media_device_compat_ioctl(struct file *filp, unsigned int cmd, |
523 | unsigned long arg) |
524 | { |
525 | struct media_devnode *devnode = media_devnode_data(filp); |
526 | struct media_device *dev = devnode->media_dev; |
527 | long ret; |
528 | |
529 | switch (cmd) { |
530 | case MEDIA_IOC_ENUM_LINKS32: |
531 | mutex_lock(&dev->graph_mutex); |
532 | ret = media_device_enum_links32(mdev: dev, |
533 | ulinks: (struct media_links_enum32 __user *)arg); |
534 | mutex_unlock(lock: &dev->graph_mutex); |
535 | break; |
536 | |
537 | default: |
538 | return media_device_ioctl(filp, cmd, arg: arg); |
539 | } |
540 | |
541 | return ret; |
542 | } |
543 | #endif /* CONFIG_COMPAT */ |
544 | |
545 | static const struct media_file_operations media_device_fops = { |
546 | .owner = THIS_MODULE, |
547 | .open = media_device_open, |
548 | .ioctl = media_device_ioctl, |
549 | #ifdef CONFIG_COMPAT |
550 | .compat_ioctl = media_device_compat_ioctl, |
551 | #endif /* CONFIG_COMPAT */ |
552 | .release = media_device_close, |
553 | }; |
554 | |
555 | /* ----------------------------------------------------------------------------- |
556 | * sysfs |
557 | */ |
558 | |
559 | static ssize_t model_show(struct device *cd, |
560 | struct device_attribute *attr, char *buf) |
561 | { |
562 | struct media_devnode *devnode = to_media_devnode(cd); |
563 | struct media_device *mdev = devnode->media_dev; |
564 | |
565 | return sprintf(buf, fmt: "%.*s\n" , (int)sizeof(mdev->model), mdev->model); |
566 | } |
567 | |
568 | static DEVICE_ATTR_RO(model); |
569 | |
570 | /* ----------------------------------------------------------------------------- |
571 | * Registration/unregistration |
572 | */ |
573 | |
574 | static void media_device_release(struct media_devnode *devnode) |
575 | { |
576 | dev_dbg(devnode->parent, "Media device released\n" ); |
577 | } |
578 | |
579 | static void __media_device_unregister_entity(struct media_entity *entity) |
580 | { |
581 | struct media_device *mdev = entity->graph_obj.mdev; |
582 | struct media_link *link, *tmp; |
583 | struct media_interface *intf; |
584 | struct media_pad *iter; |
585 | |
586 | ida_free(&mdev->entity_internal_idx, id: entity->internal_idx); |
587 | |
588 | /* Remove all interface links pointing to this entity */ |
589 | list_for_each_entry(intf, &mdev->interfaces, graph_obj.list) { |
590 | list_for_each_entry_safe(link, tmp, &intf->links, list) { |
591 | if (link->entity == entity) |
592 | __media_remove_intf_link(link); |
593 | } |
594 | } |
595 | |
596 | /* Remove all data links that belong to this entity */ |
597 | __media_entity_remove_links(entity); |
598 | |
599 | /* Remove all pads that belong to this entity */ |
600 | media_entity_for_each_pad(entity, iter) |
601 | media_gobj_destroy(gobj: &iter->graph_obj); |
602 | |
603 | /* Remove the entity */ |
604 | media_gobj_destroy(gobj: &entity->graph_obj); |
605 | |
606 | /* invoke entity_notify callbacks to handle entity removal?? */ |
607 | } |
608 | |
609 | int __must_check media_device_register_entity(struct media_device *mdev, |
610 | struct media_entity *entity) |
611 | { |
612 | struct media_entity_notify *notify, *next; |
613 | struct media_pad *iter; |
614 | int ret; |
615 | |
616 | if (entity->function == MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN || |
617 | entity->function == MEDIA_ENT_F_UNKNOWN) |
618 | dev_warn(mdev->dev, |
619 | "Entity type for entity %s was not initialized!\n" , |
620 | entity->name); |
621 | |
622 | /* Warn if we apparently re-register an entity */ |
623 | WARN_ON(entity->graph_obj.mdev != NULL); |
624 | entity->graph_obj.mdev = mdev; |
625 | INIT_LIST_HEAD(list: &entity->links); |
626 | entity->num_links = 0; |
627 | entity->num_backlinks = 0; |
628 | |
629 | ret = ida_alloc_min(ida: &mdev->entity_internal_idx, min: 1, GFP_KERNEL); |
630 | if (ret < 0) |
631 | return ret; |
632 | entity->internal_idx = ret; |
633 | |
634 | mutex_lock(&mdev->graph_mutex); |
635 | mdev->entity_internal_idx_max = |
636 | max(mdev->entity_internal_idx_max, entity->internal_idx); |
637 | |
638 | /* Initialize media_gobj embedded at the entity */ |
639 | media_gobj_create(mdev, type: MEDIA_GRAPH_ENTITY, gobj: &entity->graph_obj); |
640 | |
641 | /* Initialize objects at the pads */ |
642 | media_entity_for_each_pad(entity, iter) |
643 | media_gobj_create(mdev, type: MEDIA_GRAPH_PAD, gobj: &iter->graph_obj); |
644 | |
645 | /* invoke entity_notify callbacks */ |
646 | list_for_each_entry_safe(notify, next, &mdev->entity_notify, list) |
647 | notify->notify(entity, notify->notify_data); |
648 | |
649 | if (mdev->entity_internal_idx_max |
650 | >= mdev->pm_count_walk.ent_enum.idx_max) { |
651 | struct media_graph new = { .top = 0 }; |
652 | |
653 | /* |
654 | * Initialise the new graph walk before cleaning up |
655 | * the old one in order not to spoil the graph walk |
656 | * object of the media device if graph walk init fails. |
657 | */ |
658 | ret = media_graph_walk_init(graph: &new, mdev); |
659 | if (ret) { |
660 | __media_device_unregister_entity(entity); |
661 | mutex_unlock(lock: &mdev->graph_mutex); |
662 | return ret; |
663 | } |
664 | media_graph_walk_cleanup(graph: &mdev->pm_count_walk); |
665 | mdev->pm_count_walk = new; |
666 | } |
667 | mutex_unlock(lock: &mdev->graph_mutex); |
668 | |
669 | return 0; |
670 | } |
671 | EXPORT_SYMBOL_GPL(media_device_register_entity); |
672 | |
673 | void media_device_unregister_entity(struct media_entity *entity) |
674 | { |
675 | struct media_device *mdev = entity->graph_obj.mdev; |
676 | |
677 | if (mdev == NULL) |
678 | return; |
679 | |
680 | mutex_lock(&mdev->graph_mutex); |
681 | __media_device_unregister_entity(entity); |
682 | mutex_unlock(lock: &mdev->graph_mutex); |
683 | } |
684 | EXPORT_SYMBOL_GPL(media_device_unregister_entity); |
685 | |
686 | void media_device_init(struct media_device *mdev) |
687 | { |
688 | INIT_LIST_HEAD(list: &mdev->entities); |
689 | INIT_LIST_HEAD(list: &mdev->interfaces); |
690 | INIT_LIST_HEAD(list: &mdev->pads); |
691 | INIT_LIST_HEAD(list: &mdev->links); |
692 | INIT_LIST_HEAD(list: &mdev->entity_notify); |
693 | |
694 | mutex_init(&mdev->req_queue_mutex); |
695 | mutex_init(&mdev->graph_mutex); |
696 | ida_init(ida: &mdev->entity_internal_idx); |
697 | |
698 | atomic_set(v: &mdev->request_id, i: 0); |
699 | |
700 | if (!*mdev->bus_info) |
701 | media_set_bus_info(bus_info: mdev->bus_info, bus_info_size: sizeof(mdev->bus_info), |
702 | dev: mdev->dev); |
703 | |
704 | dev_dbg(mdev->dev, "Media device initialized\n" ); |
705 | } |
706 | EXPORT_SYMBOL_GPL(media_device_init); |
707 | |
708 | void media_device_cleanup(struct media_device *mdev) |
709 | { |
710 | ida_destroy(ida: &mdev->entity_internal_idx); |
711 | mdev->entity_internal_idx_max = 0; |
712 | media_graph_walk_cleanup(graph: &mdev->pm_count_walk); |
713 | mutex_destroy(lock: &mdev->graph_mutex); |
714 | mutex_destroy(lock: &mdev->req_queue_mutex); |
715 | } |
716 | EXPORT_SYMBOL_GPL(media_device_cleanup); |
717 | |
718 | int __must_check __media_device_register(struct media_device *mdev, |
719 | struct module *owner) |
720 | { |
721 | struct media_devnode *devnode; |
722 | int ret; |
723 | |
724 | devnode = kzalloc(size: sizeof(*devnode), GFP_KERNEL); |
725 | if (!devnode) |
726 | return -ENOMEM; |
727 | |
728 | /* Register the device node. */ |
729 | mdev->devnode = devnode; |
730 | devnode->fops = &media_device_fops; |
731 | devnode->parent = mdev->dev; |
732 | devnode->release = media_device_release; |
733 | |
734 | /* Set version 0 to indicate user-space that the graph is static */ |
735 | mdev->topology_version = 0; |
736 | |
737 | ret = media_devnode_register(mdev, devnode, owner); |
738 | if (ret < 0) { |
739 | /* devnode free is handled in media_devnode_*() */ |
740 | mdev->devnode = NULL; |
741 | return ret; |
742 | } |
743 | |
744 | ret = device_create_file(device: &devnode->dev, entry: &dev_attr_model); |
745 | if (ret < 0) { |
746 | /* devnode free is handled in media_devnode_*() */ |
747 | mdev->devnode = NULL; |
748 | media_devnode_unregister_prepare(devnode); |
749 | media_devnode_unregister(devnode); |
750 | return ret; |
751 | } |
752 | |
753 | dev_dbg(mdev->dev, "Media device registered\n" ); |
754 | |
755 | return 0; |
756 | } |
757 | EXPORT_SYMBOL_GPL(__media_device_register); |
758 | |
759 | void media_device_register_entity_notify(struct media_device *mdev, |
760 | struct media_entity_notify *nptr) |
761 | { |
762 | mutex_lock(&mdev->graph_mutex); |
763 | list_add_tail(new: &nptr->list, head: &mdev->entity_notify); |
764 | mutex_unlock(lock: &mdev->graph_mutex); |
765 | } |
766 | EXPORT_SYMBOL_GPL(media_device_register_entity_notify); |
767 | |
768 | /* |
769 | * Note: Should be called with mdev->lock held. |
770 | */ |
771 | static void __media_device_unregister_entity_notify(struct media_device *mdev, |
772 | struct media_entity_notify *nptr) |
773 | { |
774 | list_del(entry: &nptr->list); |
775 | } |
776 | |
777 | void media_device_unregister_entity_notify(struct media_device *mdev, |
778 | struct media_entity_notify *nptr) |
779 | { |
780 | mutex_lock(&mdev->graph_mutex); |
781 | __media_device_unregister_entity_notify(mdev, nptr); |
782 | mutex_unlock(lock: &mdev->graph_mutex); |
783 | } |
784 | EXPORT_SYMBOL_GPL(media_device_unregister_entity_notify); |
785 | |
786 | void media_device_unregister(struct media_device *mdev) |
787 | { |
788 | struct media_entity *entity; |
789 | struct media_entity *next; |
790 | struct media_interface *intf, *tmp_intf; |
791 | struct media_entity_notify *notify, *nextp; |
792 | |
793 | if (mdev == NULL) |
794 | return; |
795 | |
796 | mutex_lock(&mdev->graph_mutex); |
797 | |
798 | /* Check if mdev was ever registered at all */ |
799 | if (!media_devnode_is_registered(devnode: mdev->devnode)) { |
800 | mutex_unlock(lock: &mdev->graph_mutex); |
801 | return; |
802 | } |
803 | |
804 | /* Clear the devnode register bit to avoid races with media dev open */ |
805 | media_devnode_unregister_prepare(devnode: mdev->devnode); |
806 | |
807 | /* Remove all entities from the media device */ |
808 | list_for_each_entry_safe(entity, next, &mdev->entities, graph_obj.list) |
809 | __media_device_unregister_entity(entity); |
810 | |
811 | /* Remove all entity_notify callbacks from the media device */ |
812 | list_for_each_entry_safe(notify, nextp, &mdev->entity_notify, list) |
813 | __media_device_unregister_entity_notify(mdev, nptr: notify); |
814 | |
815 | /* Remove all interfaces from the media device */ |
816 | list_for_each_entry_safe(intf, tmp_intf, &mdev->interfaces, |
817 | graph_obj.list) { |
818 | /* |
819 | * Unlink the interface, but don't free it here; the |
820 | * module which created it is responsible for freeing |
821 | * it |
822 | */ |
823 | __media_remove_intf_links(intf); |
824 | media_gobj_destroy(gobj: &intf->graph_obj); |
825 | } |
826 | |
827 | mutex_unlock(lock: &mdev->graph_mutex); |
828 | |
829 | dev_dbg(mdev->dev, "Media device unregistered\n" ); |
830 | |
831 | device_remove_file(dev: &mdev->devnode->dev, attr: &dev_attr_model); |
832 | media_devnode_unregister(devnode: mdev->devnode); |
833 | /* devnode free is handled in media_devnode_*() */ |
834 | mdev->devnode = NULL; |
835 | } |
836 | EXPORT_SYMBOL_GPL(media_device_unregister); |
837 | |
838 | #if IS_ENABLED(CONFIG_PCI) |
839 | void media_device_pci_init(struct media_device *mdev, |
840 | struct pci_dev *pci_dev, |
841 | const char *name) |
842 | { |
843 | mdev->dev = &pci_dev->dev; |
844 | |
845 | if (name) |
846 | strscpy(p: mdev->model, q: name, size: sizeof(mdev->model)); |
847 | else |
848 | strscpy(p: mdev->model, q: pci_name(pdev: pci_dev), size: sizeof(mdev->model)); |
849 | |
850 | sprintf(buf: mdev->bus_info, fmt: "PCI:%s" , pci_name(pdev: pci_dev)); |
851 | |
852 | mdev->hw_revision = (pci_dev->subsystem_vendor << 16) |
853 | | pci_dev->subsystem_device; |
854 | |
855 | media_device_init(mdev); |
856 | } |
857 | EXPORT_SYMBOL_GPL(media_device_pci_init); |
858 | #endif |
859 | |
860 | #if IS_ENABLED(CONFIG_USB) |
861 | void __media_device_usb_init(struct media_device *mdev, |
862 | struct usb_device *udev, |
863 | const char *board_name, |
864 | const char *driver_name) |
865 | { |
866 | mdev->dev = &udev->dev; |
867 | |
868 | if (driver_name) |
869 | strscpy(p: mdev->driver_name, q: driver_name, |
870 | size: sizeof(mdev->driver_name)); |
871 | |
872 | if (board_name) |
873 | strscpy(p: mdev->model, q: board_name, size: sizeof(mdev->model)); |
874 | else if (udev->product) |
875 | strscpy(p: mdev->model, q: udev->product, size: sizeof(mdev->model)); |
876 | else |
877 | strscpy(p: mdev->model, q: "unknown model" , size: sizeof(mdev->model)); |
878 | if (udev->serial) |
879 | strscpy(p: mdev->serial, q: udev->serial, size: sizeof(mdev->serial)); |
880 | usb_make_path(dev: udev, buf: mdev->bus_info, size: sizeof(mdev->bus_info)); |
881 | mdev->hw_revision = le16_to_cpu(udev->descriptor.bcdDevice); |
882 | |
883 | media_device_init(mdev); |
884 | } |
885 | EXPORT_SYMBOL_GPL(__media_device_usb_init); |
886 | #endif |
887 | |
888 | |
889 | #endif /* CONFIG_MEDIA_CONTROLLER */ |
890 | |