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