4 * Copyright (C) 2010 Nokia Corporation
6 * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
7 * Sakari Ailus <sakari.ailus@iki.fi>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/compat.h>
24 #include <linux/export.h>
25 #include <linux/ioctl.h>
26 #include <linux/media.h>
27 #include <linux/slab.h>
28 #include <linux/types.h>
30 #include <media/media-device.h>
31 #include <media/media-devnode.h>
32 #include <media/media-entity.h>
34 #ifdef CONFIG_MEDIA_CONTROLLER
36 /* -----------------------------------------------------------------------------
40 static int media_device_open(struct file
*filp
)
45 static int media_device_close(struct file
*filp
)
50 static int media_device_get_info(struct media_device
*dev
,
51 struct media_device_info __user
*__info
)
53 struct media_device_info info
;
55 memset(&info
, 0, sizeof(info
));
57 strlcpy(info
.driver
, dev
->dev
->driver
->name
, sizeof(info
.driver
));
58 strlcpy(info
.model
, dev
->model
, sizeof(info
.model
));
59 strlcpy(info
.serial
, dev
->serial
, sizeof(info
.serial
));
60 strlcpy(info
.bus_info
, dev
->bus_info
, sizeof(info
.bus_info
));
62 info
.media_version
= MEDIA_API_VERSION
;
63 info
.hw_revision
= dev
->hw_revision
;
64 info
.driver_version
= dev
->driver_version
;
66 if (copy_to_user(__info
, &info
, sizeof(*__info
)))
71 static struct media_entity
*find_entity(struct media_device
*mdev
, u32 id
)
73 struct media_entity
*entity
;
74 int next
= id
& MEDIA_ENT_ID_FLAG_NEXT
;
76 id
&= ~MEDIA_ENT_ID_FLAG_NEXT
;
78 spin_lock(&mdev
->lock
);
80 media_device_for_each_entity(entity
, mdev
) {
81 if (((media_entity_id(entity
) == id
) && !next
) ||
82 ((media_entity_id(entity
) > id
) && next
)) {
83 spin_unlock(&mdev
->lock
);
88 spin_unlock(&mdev
->lock
);
93 static long media_device_enum_entities(struct media_device
*mdev
,
94 struct media_entity_desc __user
*uent
)
96 struct media_entity
*ent
;
97 struct media_entity_desc u_ent
;
99 memset(&u_ent
, 0, sizeof(u_ent
));
100 if (copy_from_user(&u_ent
.id
, &uent
->id
, sizeof(u_ent
.id
)))
103 ent
= find_entity(mdev
, u_ent
.id
);
108 u_ent
.id
= media_entity_id(ent
);
110 strlcpy(u_ent
.name
, ent
->name
, sizeof(u_ent
.name
));
111 u_ent
.type
= ent
->function
;
112 u_ent
.revision
= 0; /* Unused */
113 u_ent
.flags
= ent
->flags
;
114 u_ent
.group_id
= 0; /* Unused */
115 u_ent
.pads
= ent
->num_pads
;
116 u_ent
.links
= ent
->num_links
- ent
->num_backlinks
;
117 memcpy(&u_ent
.raw
, &ent
->info
, sizeof(ent
->info
));
118 if (copy_to_user(uent
, &u_ent
, sizeof(u_ent
)))
123 static void media_device_kpad_to_upad(const struct media_pad
*kpad
,
124 struct media_pad_desc
*upad
)
126 upad
->entity
= media_entity_id(kpad
->entity
);
127 upad
->index
= kpad
->index
;
128 upad
->flags
= kpad
->flags
;
131 static long __media_device_enum_links(struct media_device
*mdev
,
132 struct media_links_enum
*links
)
134 struct media_entity
*entity
;
136 entity
= find_entity(mdev
, links
->entity
);
143 for (p
= 0; p
< entity
->num_pads
; p
++) {
144 struct media_pad_desc pad
;
146 memset(&pad
, 0, sizeof(pad
));
147 media_device_kpad_to_upad(&entity
->pads
[p
], &pad
);
148 if (copy_to_user(&links
->pads
[p
], &pad
, sizeof(pad
)))
154 struct media_link
*link
;
155 struct media_link_desc __user
*ulink_desc
= links
->links
;
157 list_for_each_entry(link
, &entity
->links
, list
) {
158 struct media_link_desc klink_desc
;
160 /* Ignore backlinks. */
161 if (link
->source
->entity
!= entity
)
163 memset(&klink_desc
, 0, sizeof(klink_desc
));
164 media_device_kpad_to_upad(link
->source
,
166 media_device_kpad_to_upad(link
->sink
,
168 klink_desc
.flags
= link
->flags
;
169 if (copy_to_user(ulink_desc
, &klink_desc
,
170 sizeof(*ulink_desc
)))
179 static long media_device_enum_links(struct media_device
*mdev
,
180 struct media_links_enum __user
*ulinks
)
182 struct media_links_enum links
;
185 if (copy_from_user(&links
, ulinks
, sizeof(links
)))
188 rval
= __media_device_enum_links(mdev
, &links
);
192 if (copy_to_user(ulinks
, &links
, sizeof(*ulinks
)))
198 static long media_device_setup_link(struct media_device
*mdev
,
199 struct media_link_desc __user
*_ulink
)
201 struct media_link
*link
= NULL
;
202 struct media_link_desc ulink
;
203 struct media_entity
*source
;
204 struct media_entity
*sink
;
207 if (copy_from_user(&ulink
, _ulink
, sizeof(ulink
)))
210 /* Find the source and sink entities and link.
212 source
= find_entity(mdev
, ulink
.source
.entity
);
213 sink
= find_entity(mdev
, ulink
.sink
.entity
);
215 if (source
== NULL
|| sink
== NULL
)
218 if (ulink
.source
.index
>= source
->num_pads
||
219 ulink
.sink
.index
>= sink
->num_pads
)
222 link
= media_entity_find_link(&source
->pads
[ulink
.source
.index
],
223 &sink
->pads
[ulink
.sink
.index
]);
227 /* Setup the link on both entities. */
228 ret
= __media_entity_setup_link(link
, ulink
.flags
);
230 if (copy_to_user(_ulink
, &ulink
, sizeof(ulink
)))
236 static long __media_device_get_topology(struct media_device
*mdev
,
237 struct media_v2_topology
*topo
)
239 struct media_entity
*entity
;
240 struct media_interface
*intf
;
241 struct media_pad
*pad
;
242 struct media_link
*link
;
243 struct media_v2_entity uentity
;
244 struct media_v2_interface uintf
;
245 struct media_v2_pad upad
;
246 struct media_v2_link ulink
;
250 topo
->topology_version
= mdev
->topology_version
;
252 /* Get entities and number of entities */
254 media_device_for_each_entity(entity
, mdev
) {
257 if (ret
|| !topo
->entities
)
260 if (i
> topo
->num_entities
) {
265 /* Copy fields to userspace struct if not error */
266 memset(&uentity
, 0, sizeof(uentity
));
267 uentity
.id
= entity
->graph_obj
.id
;
268 uentity
.function
= entity
->function
;
269 strncpy(uentity
.name
, entity
->name
,
270 sizeof(uentity
.name
));
272 if (copy_to_user(&topo
->entities
[i
- 1], &uentity
, sizeof(uentity
)))
275 topo
->num_entities
= i
;
277 /* Get interfaces and number of interfaces */
279 media_device_for_each_intf(intf
, mdev
) {
282 if (ret
|| !topo
->interfaces
)
285 if (i
> topo
->num_interfaces
) {
290 memset(&uintf
, 0, sizeof(uintf
));
292 /* Copy intf fields to userspace struct */
293 uintf
.id
= intf
->graph_obj
.id
;
294 uintf
.intf_type
= intf
->type
;
295 uintf
.flags
= intf
->flags
;
297 if (media_type(&intf
->graph_obj
) == MEDIA_GRAPH_INTF_DEVNODE
) {
298 struct media_intf_devnode
*devnode
;
300 devnode
= intf_to_devnode(intf
);
302 uintf
.devnode
.major
= devnode
->major
;
303 uintf
.devnode
.minor
= devnode
->minor
;
306 if (copy_to_user(&topo
->interfaces
[i
- 1], &uintf
, sizeof(uintf
)))
309 topo
->num_interfaces
= i
;
311 /* Get pads and number of pads */
313 media_device_for_each_pad(pad
, mdev
) {
316 if (ret
|| !topo
->pads
)
319 if (i
> topo
->num_pads
) {
324 memset(&upad
, 0, sizeof(upad
));
326 /* Copy pad fields to userspace struct */
327 upad
.id
= pad
->graph_obj
.id
;
328 upad
.entity_id
= pad
->entity
->graph_obj
.id
;
329 upad
.flags
= pad
->flags
;
331 if (copy_to_user(&topo
->pads
[i
- 1], &upad
, sizeof(upad
)))
336 /* Get links and number of links */
338 media_device_for_each_link(link
, mdev
) {
339 if (link
->is_backlink
)
344 if (ret
|| !topo
->links
)
347 if (i
> topo
->num_links
) {
352 memset(&ulink
, 0, sizeof(ulink
));
354 /* Copy link fields to userspace struct */
355 ulink
.id
= link
->graph_obj
.id
;
356 ulink
.source_id
= link
->gobj0
->id
;
357 ulink
.sink_id
= link
->gobj1
->id
;
358 ulink
.flags
= link
->flags
;
360 if (media_type(link
->gobj0
) != MEDIA_GRAPH_PAD
)
361 ulink
.flags
|= MEDIA_LNK_FL_INTERFACE_LINK
;
363 if (copy_to_user(&topo
->links
[i
- 1], &ulink
, sizeof(ulink
)))
371 static long media_device_get_topology(struct media_device
*mdev
,
372 struct media_v2_topology __user
*utopo
)
374 struct media_v2_topology ktopo
;
377 ret
= copy_from_user(&ktopo
, utopo
, sizeof(ktopo
));
382 ret
= __media_device_get_topology(mdev
, &ktopo
);
386 ret
= copy_to_user(utopo
, &ktopo
, sizeof(*utopo
));
391 static long media_device_ioctl(struct file
*filp
, unsigned int cmd
,
394 struct media_devnode
*devnode
= media_devnode_data(filp
);
395 struct media_device
*dev
= to_media_device(devnode
);
399 case MEDIA_IOC_DEVICE_INFO
:
400 ret
= media_device_get_info(dev
,
401 (struct media_device_info __user
*)arg
);
404 case MEDIA_IOC_ENUM_ENTITIES
:
405 ret
= media_device_enum_entities(dev
,
406 (struct media_entity_desc __user
*)arg
);
409 case MEDIA_IOC_ENUM_LINKS
:
410 mutex_lock(&dev
->graph_mutex
);
411 ret
= media_device_enum_links(dev
,
412 (struct media_links_enum __user
*)arg
);
413 mutex_unlock(&dev
->graph_mutex
);
416 case MEDIA_IOC_SETUP_LINK
:
417 mutex_lock(&dev
->graph_mutex
);
418 ret
= media_device_setup_link(dev
,
419 (struct media_link_desc __user
*)arg
);
420 mutex_unlock(&dev
->graph_mutex
);
423 case MEDIA_IOC_G_TOPOLOGY
:
424 mutex_lock(&dev
->graph_mutex
);
425 ret
= media_device_get_topology(dev
,
426 (struct media_v2_topology __user
*)arg
);
427 mutex_unlock(&dev
->graph_mutex
);
439 struct media_links_enum32
{
441 compat_uptr_t pads
; /* struct media_pad_desc * */
442 compat_uptr_t links
; /* struct media_link_desc * */
446 static long media_device_enum_links32(struct media_device
*mdev
,
447 struct media_links_enum32 __user
*ulinks
)
449 struct media_links_enum links
;
450 compat_uptr_t pads_ptr
, links_ptr
;
452 memset(&links
, 0, sizeof(links
));
454 if (get_user(links
.entity
, &ulinks
->entity
)
455 || get_user(pads_ptr
, &ulinks
->pads
)
456 || get_user(links_ptr
, &ulinks
->links
))
459 links
.pads
= compat_ptr(pads_ptr
);
460 links
.links
= compat_ptr(links_ptr
);
462 return __media_device_enum_links(mdev
, &links
);
465 #define MEDIA_IOC_ENUM_LINKS32 _IOWR('|', 0x02, struct media_links_enum32)
467 static long media_device_compat_ioctl(struct file
*filp
, unsigned int cmd
,
470 struct media_devnode
*devnode
= media_devnode_data(filp
);
471 struct media_device
*dev
= to_media_device(devnode
);
475 case MEDIA_IOC_DEVICE_INFO
:
476 case MEDIA_IOC_ENUM_ENTITIES
:
477 case MEDIA_IOC_SETUP_LINK
:
478 case MEDIA_IOC_G_TOPOLOGY
:
479 return media_device_ioctl(filp
, cmd
, arg
);
481 case MEDIA_IOC_ENUM_LINKS32
:
482 mutex_lock(&dev
->graph_mutex
);
483 ret
= media_device_enum_links32(dev
,
484 (struct media_links_enum32 __user
*)arg
);
485 mutex_unlock(&dev
->graph_mutex
);
494 #endif /* CONFIG_COMPAT */
496 static const struct media_file_operations media_device_fops
= {
497 .owner
= THIS_MODULE
,
498 .open
= media_device_open
,
499 .ioctl
= media_device_ioctl
,
501 .compat_ioctl
= media_device_compat_ioctl
,
502 #endif /* CONFIG_COMPAT */
503 .release
= media_device_close
,
506 /* -----------------------------------------------------------------------------
510 static ssize_t
show_model(struct device
*cd
,
511 struct device_attribute
*attr
, char *buf
)
513 struct media_device
*mdev
= to_media_device(to_media_devnode(cd
));
515 return sprintf(buf
, "%.*s\n", (int)sizeof(mdev
->model
), mdev
->model
);
518 static DEVICE_ATTR(model
, S_IRUGO
, show_model
, NULL
);
520 /* -----------------------------------------------------------------------------
521 * Registration/unregistration
524 static void media_device_release(struct media_devnode
*mdev
)
526 dev_dbg(mdev
->parent
, "Media device released\n");
530 * media_device_register - register a media device
531 * @mdev: The media device
533 * The caller is responsible for initializing the media device before
534 * registration. The following fields must be set:
536 * - dev must point to the parent device
537 * - model must be filled with the device model name
539 int __must_check
__media_device_register(struct media_device
*mdev
,
540 struct module
*owner
)
544 if (WARN_ON(mdev
->dev
== NULL
|| mdev
->model
[0] == 0))
547 INIT_LIST_HEAD(&mdev
->entities
);
548 INIT_LIST_HEAD(&mdev
->interfaces
);
549 INIT_LIST_HEAD(&mdev
->pads
);
550 INIT_LIST_HEAD(&mdev
->links
);
551 spin_lock_init(&mdev
->lock
);
552 mutex_init(&mdev
->graph_mutex
);
554 /* Register the device node. */
555 mdev
->devnode
.fops
= &media_device_fops
;
556 mdev
->devnode
.parent
= mdev
->dev
;
557 mdev
->devnode
.release
= media_device_release
;
558 ret
= media_devnode_register(&mdev
->devnode
, owner
);
562 ret
= device_create_file(&mdev
->devnode
.dev
, &dev_attr_model
);
564 media_devnode_unregister(&mdev
->devnode
);
568 dev_dbg(mdev
->dev
, "Media device registered\n");
572 EXPORT_SYMBOL_GPL(__media_device_register
);
575 * media_device_unregister - unregister a media device
576 * @mdev: The media device
579 void media_device_unregister(struct media_device
*mdev
)
581 struct media_entity
*entity
;
582 struct media_entity
*next
;
583 struct media_interface
*intf
, *tmp_intf
;
585 /* Remove all entities from the media device */
586 list_for_each_entry_safe(entity
, next
, &mdev
->entities
, graph_obj
.list
)
587 media_device_unregister_entity(entity
);
589 /* Remove all interfaces from the media device */
590 spin_lock(&mdev
->lock
);
591 list_for_each_entry_safe(intf
, tmp_intf
, &mdev
->interfaces
,
593 __media_remove_intf_links(intf
);
594 media_gobj_remove(&intf
->graph_obj
);
597 spin_unlock(&mdev
->lock
);
599 device_remove_file(&mdev
->devnode
.dev
, &dev_attr_model
);
600 media_devnode_unregister(&mdev
->devnode
);
602 dev_dbg(mdev
->dev
, "Media device unregistered\n");
604 EXPORT_SYMBOL_GPL(media_device_unregister
);
607 * media_device_register_entity - Register an entity with a media device
608 * @mdev: The media device
609 * @entity: The entity
611 int __must_check
media_device_register_entity(struct media_device
*mdev
,
612 struct media_entity
*entity
)
616 if (entity
->function
== MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN
||
617 entity
->function
== MEDIA_ENT_F_UNKNOWN
)
619 "Entity type for entity %s was not initialized!\n",
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(&entity
->links
);
626 entity
->num_links
= 0;
627 entity
->num_backlinks
= 0;
629 spin_lock(&mdev
->lock
);
630 /* Initialize media_gobj embedded at the entity */
631 media_gobj_init(mdev
, MEDIA_GRAPH_ENTITY
, &entity
->graph_obj
);
633 /* Initialize objects at the pads */
634 for (i
= 0; i
< entity
->num_pads
; i
++)
635 media_gobj_init(mdev
, MEDIA_GRAPH_PAD
,
636 &entity
->pads
[i
].graph_obj
);
638 spin_unlock(&mdev
->lock
);
642 EXPORT_SYMBOL_GPL(media_device_register_entity
);
645 * media_device_unregister_entity - Unregister an entity
646 * @entity: The entity
648 * If the entity has never been registered this function will return
651 void media_device_unregister_entity(struct media_entity
*entity
)
653 struct media_device
*mdev
= entity
->graph_obj
.mdev
;
654 struct media_link
*link
, *tmp
;
655 struct media_interface
*intf
;
661 spin_lock(&mdev
->lock
);
663 /* Remove all interface links pointing to this entity */
664 list_for_each_entry(intf
, &mdev
->interfaces
, graph_obj
.list
) {
665 list_for_each_entry_safe(link
, tmp
, &intf
->links
, list
) {
666 if (link
->entity
== entity
)
667 __media_remove_intf_link(link
);
671 /* Remove all data links that belong to this entity */
672 __media_entity_remove_links(entity
);
674 /* Remove all pads that belong to this entity */
675 for (i
= 0; i
< entity
->num_pads
; i
++)
676 media_gobj_remove(&entity
->pads
[i
].graph_obj
);
678 /* Remove the entity */
679 media_gobj_remove(&entity
->graph_obj
);
681 spin_unlock(&mdev
->lock
);
682 entity
->graph_obj
.mdev
= NULL
;
684 EXPORT_SYMBOL_GPL(media_device_unregister_entity
);
686 static void media_device_release_devres(struct device
*dev
, void *res
)
691 * media_device_get_devres() - get media device as device resource
692 * creates if one doesn't exist
694 struct media_device
*media_device_get_devres(struct device
*dev
)
696 struct media_device
*mdev
;
698 mdev
= devres_find(dev
, media_device_release_devres
, NULL
, NULL
);
702 mdev
= devres_alloc(media_device_release_devres
,
703 sizeof(struct media_device
), GFP_KERNEL
);
706 return devres_get(dev
, mdev
, NULL
, NULL
);
708 EXPORT_SYMBOL_GPL(media_device_get_devres
);
711 * media_device_find_devres() - find media device as device resource
713 struct media_device
*media_device_find_devres(struct device
*dev
)
715 return devres_find(dev
, media_device_release_devres
, NULL
, NULL
);
717 EXPORT_SYMBOL_GPL(media_device_find_devres
);
719 #endif /* CONFIG_MEDIA_CONTROLLER */