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.
19 /* We need to access legacy defines from linux/media.h */
20 #define __NEED_MEDIA_LEGACY_API
22 #include <linux/compat.h>
23 #include <linux/export.h>
24 #include <linux/idr.h>
25 #include <linux/ioctl.h>
26 #include <linux/media.h>
27 #include <linux/slab.h>
28 #include <linux/types.h>
29 #include <linux/pci.h>
30 #include <linux/usb.h>
32 #include <media/media-device.h>
33 #include <media/media-devnode.h>
34 #include <media/media-entity.h>
36 #ifdef CONFIG_MEDIA_CONTROLLER
38 /* -----------------------------------------------------------------------------
42 static inline void __user
*media_get_uptr(__u64 arg
)
44 return (void __user
*)(uintptr_t)arg
;
47 static int media_device_open(struct file
*filp
)
52 static int media_device_close(struct file
*filp
)
57 static long media_device_get_info(struct media_device
*dev
, void *arg
)
59 struct media_device_info
*info
= arg
;
61 memset(info
, 0, sizeof(*info
));
63 if (dev
->driver_name
[0])
64 strlcpy(info
->driver
, dev
->driver_name
, sizeof(info
->driver
));
66 strlcpy(info
->driver
, dev
->dev
->driver
->name
,
67 sizeof(info
->driver
));
69 strlcpy(info
->model
, dev
->model
, sizeof(info
->model
));
70 strlcpy(info
->serial
, dev
->serial
, sizeof(info
->serial
));
71 strlcpy(info
->bus_info
, dev
->bus_info
, sizeof(info
->bus_info
));
73 info
->media_version
= LINUX_VERSION_CODE
;
74 info
->driver_version
= info
->media_version
;
75 info
->hw_revision
= dev
->hw_revision
;
80 static struct media_entity
*find_entity(struct media_device
*mdev
, u32 id
)
82 struct media_entity
*entity
;
83 int next
= id
& MEDIA_ENT_ID_FLAG_NEXT
;
85 id
&= ~MEDIA_ENT_ID_FLAG_NEXT
;
87 media_device_for_each_entity(entity
, mdev
) {
88 if (((media_entity_id(entity
) == id
) && !next
) ||
89 ((media_entity_id(entity
) > id
) && next
)) {
97 static long media_device_enum_entities(struct media_device
*mdev
, void *arg
)
99 struct media_entity_desc
*entd
= arg
;
100 struct media_entity
*ent
;
102 ent
= find_entity(mdev
, entd
->id
);
106 memset(entd
, 0, sizeof(*entd
));
108 entd
->id
= media_entity_id(ent
);
110 strlcpy(entd
->name
, ent
->name
, sizeof(entd
->name
));
111 entd
->type
= ent
->function
;
112 entd
->revision
= 0; /* Unused */
113 entd
->flags
= ent
->flags
;
114 entd
->group_id
= 0; /* Unused */
115 entd
->pads
= ent
->num_pads
;
116 entd
->links
= ent
->num_links
- ent
->num_backlinks
;
119 * Workaround for a bug at media-ctl <= v1.10 that makes it to
120 * do the wrong thing if the entity function doesn't belong to
121 * either MEDIA_ENT_F_OLD_BASE or MEDIA_ENT_F_OLD_SUBDEV_BASE
124 * Non-subdevices are expected to be at the MEDIA_ENT_F_OLD_BASE,
125 * or, otherwise, will be silently ignored by media-ctl when
126 * printing the graphviz diagram. So, map them into the devnode
129 if (ent
->function
< MEDIA_ENT_F_OLD_BASE
||
130 ent
->function
> MEDIA_ENT_F_TUNER
) {
131 if (is_media_entity_v4l2_subdev(ent
))
132 entd
->type
= MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN
;
133 else if (ent
->function
!= MEDIA_ENT_F_IO_V4L
)
134 entd
->type
= MEDIA_ENT_T_DEVNODE_UNKNOWN
;
137 memcpy(&entd
->raw
, &ent
->info
, sizeof(ent
->info
));
142 static void media_device_kpad_to_upad(const struct media_pad
*kpad
,
143 struct media_pad_desc
*upad
)
145 upad
->entity
= media_entity_id(kpad
->entity
);
146 upad
->index
= kpad
->index
;
147 upad
->flags
= kpad
->flags
;
150 static long media_device_enum_links(struct media_device
*mdev
, void *arg
)
152 struct media_links_enum
*links
= arg
;
153 struct media_entity
*entity
;
155 entity
= find_entity(mdev
, links
->entity
);
162 for (p
= 0; p
< entity
->num_pads
; p
++) {
163 struct media_pad_desc pad
;
165 memset(&pad
, 0, sizeof(pad
));
166 media_device_kpad_to_upad(&entity
->pads
[p
], &pad
);
167 if (copy_to_user(&links
->pads
[p
], &pad
, sizeof(pad
)))
173 struct media_link
*link
;
174 struct media_link_desc __user
*ulink_desc
= links
->links
;
176 list_for_each_entry(link
, &entity
->links
, list
) {
177 struct media_link_desc klink_desc
;
179 /* Ignore backlinks. */
180 if (link
->source
->entity
!= entity
)
182 memset(&klink_desc
, 0, sizeof(klink_desc
));
183 media_device_kpad_to_upad(link
->source
,
185 media_device_kpad_to_upad(link
->sink
,
187 klink_desc
.flags
= link
->flags
;
188 if (copy_to_user(ulink_desc
, &klink_desc
,
189 sizeof(*ulink_desc
)))
198 static long media_device_setup_link(struct media_device
*mdev
, void *arg
)
200 struct media_link_desc
*linkd
= arg
;
201 struct media_link
*link
= NULL
;
202 struct media_entity
*source
;
203 struct media_entity
*sink
;
205 /* Find the source and sink entities and link.
207 source
= find_entity(mdev
, linkd
->source
.entity
);
208 sink
= find_entity(mdev
, linkd
->sink
.entity
);
210 if (source
== NULL
|| sink
== NULL
)
213 if (linkd
->source
.index
>= source
->num_pads
||
214 linkd
->sink
.index
>= sink
->num_pads
)
217 link
= media_entity_find_link(&source
->pads
[linkd
->source
.index
],
218 &sink
->pads
[linkd
->sink
.index
]);
222 /* Setup the link on both entities. */
223 return __media_entity_setup_link(link
, linkd
->flags
);
226 static long media_device_get_topology(struct media_device
*mdev
, void *arg
)
228 struct media_v2_topology
*topo
= arg
;
229 struct media_entity
*entity
;
230 struct media_interface
*intf
;
231 struct media_pad
*pad
;
232 struct media_link
*link
;
233 struct media_v2_entity kentity
, __user
*uentity
;
234 struct media_v2_interface kintf
, __user
*uintf
;
235 struct media_v2_pad kpad
, __user
*upad
;
236 struct media_v2_link klink
, __user
*ulink
;
240 topo
->topology_version
= mdev
->topology_version
;
242 /* Get entities and number of entities */
244 uentity
= media_get_uptr(topo
->ptr_entities
);
245 media_device_for_each_entity(entity
, mdev
) {
250 if (i
> topo
->num_entities
) {
255 /* Copy fields to userspace struct if not error */
256 memset(&kentity
, 0, sizeof(kentity
));
257 kentity
.id
= entity
->graph_obj
.id
;
258 kentity
.function
= entity
->function
;
259 strncpy(kentity
.name
, entity
->name
,
260 sizeof(kentity
.name
));
262 if (copy_to_user(uentity
, &kentity
, sizeof(kentity
)))
266 topo
->num_entities
= i
;
268 /* Get interfaces and number of interfaces */
270 uintf
= media_get_uptr(topo
->ptr_interfaces
);
271 media_device_for_each_intf(intf
, mdev
) {
276 if (i
> topo
->num_interfaces
) {
281 memset(&kintf
, 0, sizeof(kintf
));
283 /* Copy intf fields to userspace struct */
284 kintf
.id
= intf
->graph_obj
.id
;
285 kintf
.intf_type
= intf
->type
;
286 kintf
.flags
= intf
->flags
;
288 if (media_type(&intf
->graph_obj
) == MEDIA_GRAPH_INTF_DEVNODE
) {
289 struct media_intf_devnode
*devnode
;
291 devnode
= intf_to_devnode(intf
);
293 kintf
.devnode
.major
= devnode
->major
;
294 kintf
.devnode
.minor
= devnode
->minor
;
297 if (copy_to_user(uintf
, &kintf
, sizeof(kintf
)))
301 topo
->num_interfaces
= i
;
303 /* Get pads and number of pads */
305 upad
= media_get_uptr(topo
->ptr_pads
);
306 media_device_for_each_pad(pad
, mdev
) {
311 if (i
> topo
->num_pads
) {
316 memset(&kpad
, 0, sizeof(kpad
));
318 /* Copy pad fields to userspace struct */
319 kpad
.id
= pad
->graph_obj
.id
;
320 kpad
.entity_id
= pad
->entity
->graph_obj
.id
;
321 kpad
.flags
= pad
->flags
;
323 if (copy_to_user(upad
, &kpad
, sizeof(kpad
)))
329 /* Get links and number of links */
331 ulink
= media_get_uptr(topo
->ptr_links
);
332 media_device_for_each_link(link
, mdev
) {
333 if (link
->is_backlink
)
341 if (i
> topo
->num_links
) {
346 memset(&klink
, 0, sizeof(klink
));
348 /* Copy link fields to userspace struct */
349 klink
.id
= link
->graph_obj
.id
;
350 klink
.source_id
= link
->gobj0
->id
;
351 klink
.sink_id
= link
->gobj1
->id
;
352 klink
.flags
= link
->flags
;
354 if (copy_to_user(ulink
, &klink
, sizeof(klink
)))
363 static long copy_arg_from_user(void *karg
, void __user
*uarg
, unsigned int cmd
)
365 /* All media IOCTLs are _IOWR() */
366 if (copy_from_user(karg
, uarg
, _IOC_SIZE(cmd
)))
372 static long copy_arg_to_user(void __user
*uarg
, void *karg
, unsigned int cmd
)
374 /* All media IOCTLs are _IOWR() */
375 if (copy_to_user(uarg
, karg
, _IOC_SIZE(cmd
)))
381 /* Do acquire the graph mutex */
382 #define MEDIA_IOC_FL_GRAPH_MUTEX BIT(0)
384 #define MEDIA_IOC_ARG(__cmd, func, fl, from_user, to_user) \
385 [_IOC_NR(MEDIA_IOC_##__cmd)] = { \
386 .cmd = MEDIA_IOC_##__cmd, \
387 .fn = (long (*)(struct media_device *, void *))func, \
389 .arg_from_user = from_user, \
390 .arg_to_user = to_user, \
393 #define MEDIA_IOC(__cmd, func, fl) \
394 MEDIA_IOC_ARG(__cmd, func, fl, copy_arg_from_user, copy_arg_to_user)
396 /* the table is indexed by _IOC_NR(cmd) */
397 struct media_ioctl_info
{
399 unsigned short flags
;
400 long (*fn
)(struct media_device
*dev
, void *arg
);
401 long (*arg_from_user
)(void *karg
, void __user
*uarg
, unsigned int cmd
);
402 long (*arg_to_user
)(void __user
*uarg
, void *karg
, unsigned int cmd
);
405 static const struct media_ioctl_info ioctl_info
[] = {
406 MEDIA_IOC(DEVICE_INFO
, media_device_get_info
, MEDIA_IOC_FL_GRAPH_MUTEX
),
407 MEDIA_IOC(ENUM_ENTITIES
, media_device_enum_entities
, MEDIA_IOC_FL_GRAPH_MUTEX
),
408 MEDIA_IOC(ENUM_LINKS
, media_device_enum_links
, MEDIA_IOC_FL_GRAPH_MUTEX
),
409 MEDIA_IOC(SETUP_LINK
, media_device_setup_link
, MEDIA_IOC_FL_GRAPH_MUTEX
),
410 MEDIA_IOC(G_TOPOLOGY
, media_device_get_topology
, MEDIA_IOC_FL_GRAPH_MUTEX
),
413 static long media_device_ioctl(struct file
*filp
, unsigned int cmd
,
416 struct media_devnode
*devnode
= media_devnode_data(filp
);
417 struct media_device
*dev
= devnode
->media_dev
;
418 const struct media_ioctl_info
*info
;
419 void __user
*arg
= (void __user
*)__arg
;
420 char __karg
[256], *karg
= __karg
;
423 if (_IOC_NR(cmd
) >= ARRAY_SIZE(ioctl_info
)
424 || ioctl_info
[_IOC_NR(cmd
)].cmd
!= cmd
)
427 info
= &ioctl_info
[_IOC_NR(cmd
)];
429 if (_IOC_SIZE(info
->cmd
) > sizeof(__karg
)) {
430 karg
= kmalloc(_IOC_SIZE(info
->cmd
), GFP_KERNEL
);
435 if (info
->arg_from_user
) {
436 ret
= info
->arg_from_user(karg
, arg
, cmd
);
441 if (info
->flags
& MEDIA_IOC_FL_GRAPH_MUTEX
)
442 mutex_lock(&dev
->graph_mutex
);
444 ret
= info
->fn(dev
, karg
);
446 if (info
->flags
& MEDIA_IOC_FL_GRAPH_MUTEX
)
447 mutex_unlock(&dev
->graph_mutex
);
449 if (!ret
&& info
->arg_to_user
)
450 ret
= info
->arg_to_user(arg
, karg
, cmd
);
461 struct media_links_enum32
{
463 compat_uptr_t pads
; /* struct media_pad_desc * */
464 compat_uptr_t links
; /* struct media_link_desc * */
468 static long media_device_enum_links32(struct media_device
*mdev
,
469 struct media_links_enum32 __user
*ulinks
)
471 struct media_links_enum links
;
472 compat_uptr_t pads_ptr
, links_ptr
;
474 memset(&links
, 0, sizeof(links
));
476 if (get_user(links
.entity
, &ulinks
->entity
)
477 || get_user(pads_ptr
, &ulinks
->pads
)
478 || get_user(links_ptr
, &ulinks
->links
))
481 links
.pads
= compat_ptr(pads_ptr
);
482 links
.links
= compat_ptr(links_ptr
);
484 return media_device_enum_links(mdev
, &links
);
487 #define MEDIA_IOC_ENUM_LINKS32 _IOWR('|', 0x02, struct media_links_enum32)
489 static long media_device_compat_ioctl(struct file
*filp
, unsigned int cmd
,
492 struct media_devnode
*devnode
= media_devnode_data(filp
);
493 struct media_device
*dev
= devnode
->media_dev
;
497 case MEDIA_IOC_ENUM_LINKS32
:
498 mutex_lock(&dev
->graph_mutex
);
499 ret
= media_device_enum_links32(dev
,
500 (struct media_links_enum32 __user
*)arg
);
501 mutex_unlock(&dev
->graph_mutex
);
505 return media_device_ioctl(filp
, cmd
, arg
);
510 #endif /* CONFIG_COMPAT */
512 static const struct media_file_operations media_device_fops
= {
513 .owner
= THIS_MODULE
,
514 .open
= media_device_open
,
515 .ioctl
= media_device_ioctl
,
517 .compat_ioctl
= media_device_compat_ioctl
,
518 #endif /* CONFIG_COMPAT */
519 .release
= media_device_close
,
522 /* -----------------------------------------------------------------------------
526 static ssize_t
show_model(struct device
*cd
,
527 struct device_attribute
*attr
, char *buf
)
529 struct media_devnode
*devnode
= to_media_devnode(cd
);
530 struct media_device
*mdev
= devnode
->media_dev
;
532 return sprintf(buf
, "%.*s\n", (int)sizeof(mdev
->model
), mdev
->model
);
535 static DEVICE_ATTR(model
, S_IRUGO
, show_model
, NULL
);
537 /* -----------------------------------------------------------------------------
538 * Registration/unregistration
541 static void media_device_release(struct media_devnode
*devnode
)
543 dev_dbg(devnode
->parent
, "Media device released\n");
547 * media_device_register_entity - Register an entity with a media device
548 * @mdev: The media device
549 * @entity: The entity
551 int __must_check
media_device_register_entity(struct media_device
*mdev
,
552 struct media_entity
*entity
)
554 struct media_entity_notify
*notify
, *next
;
558 if (entity
->function
== MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN
||
559 entity
->function
== MEDIA_ENT_F_UNKNOWN
)
561 "Entity type for entity %s was not initialized!\n",
564 /* Warn if we apparently re-register an entity */
565 WARN_ON(entity
->graph_obj
.mdev
!= NULL
);
566 entity
->graph_obj
.mdev
= mdev
;
567 INIT_LIST_HEAD(&entity
->links
);
568 entity
->num_links
= 0;
569 entity
->num_backlinks
= 0;
571 if (!ida_pre_get(&mdev
->entity_internal_idx
, GFP_KERNEL
))
574 mutex_lock(&mdev
->graph_mutex
);
576 ret
= ida_get_new_above(&mdev
->entity_internal_idx
, 1,
577 &entity
->internal_idx
);
579 mutex_unlock(&mdev
->graph_mutex
);
583 mdev
->entity_internal_idx_max
=
584 max(mdev
->entity_internal_idx_max
, entity
->internal_idx
);
586 /* Initialize media_gobj embedded at the entity */
587 media_gobj_create(mdev
, MEDIA_GRAPH_ENTITY
, &entity
->graph_obj
);
589 /* Initialize objects at the pads */
590 for (i
= 0; i
< entity
->num_pads
; i
++)
591 media_gobj_create(mdev
, MEDIA_GRAPH_PAD
,
592 &entity
->pads
[i
].graph_obj
);
594 /* invoke entity_notify callbacks */
595 list_for_each_entry_safe(notify
, next
, &mdev
->entity_notify
, list
)
596 notify
->notify(entity
, notify
->notify_data
);
598 if (mdev
->entity_internal_idx_max
599 >= mdev
->pm_count_walk
.ent_enum
.idx_max
) {
600 struct media_graph
new = { .top
= 0 };
603 * Initialise the new graph walk before cleaning up
604 * the old one in order not to spoil the graph walk
605 * object of the media device if graph walk init fails.
607 ret
= media_graph_walk_init(&new, mdev
);
609 mutex_unlock(&mdev
->graph_mutex
);
612 media_graph_walk_cleanup(&mdev
->pm_count_walk
);
613 mdev
->pm_count_walk
= new;
615 mutex_unlock(&mdev
->graph_mutex
);
619 EXPORT_SYMBOL_GPL(media_device_register_entity
);
621 static void __media_device_unregister_entity(struct media_entity
*entity
)
623 struct media_device
*mdev
= entity
->graph_obj
.mdev
;
624 struct media_link
*link
, *tmp
;
625 struct media_interface
*intf
;
628 ida_simple_remove(&mdev
->entity_internal_idx
, entity
->internal_idx
);
630 /* Remove all interface links pointing to this entity */
631 list_for_each_entry(intf
, &mdev
->interfaces
, graph_obj
.list
) {
632 list_for_each_entry_safe(link
, tmp
, &intf
->links
, list
) {
633 if (link
->entity
== entity
)
634 __media_remove_intf_link(link
);
638 /* Remove all data links that belong to this entity */
639 __media_entity_remove_links(entity
);
641 /* Remove all pads that belong to this entity */
642 for (i
= 0; i
< entity
->num_pads
; i
++)
643 media_gobj_destroy(&entity
->pads
[i
].graph_obj
);
645 /* Remove the entity */
646 media_gobj_destroy(&entity
->graph_obj
);
648 /* invoke entity_notify callbacks to handle entity removal?? */
650 entity
->graph_obj
.mdev
= NULL
;
653 void media_device_unregister_entity(struct media_entity
*entity
)
655 struct media_device
*mdev
= entity
->graph_obj
.mdev
;
660 mutex_lock(&mdev
->graph_mutex
);
661 __media_device_unregister_entity(entity
);
662 mutex_unlock(&mdev
->graph_mutex
);
664 EXPORT_SYMBOL_GPL(media_device_unregister_entity
);
667 * media_device_init() - initialize a media device
668 * @mdev: The media device
670 * The caller is responsible for initializing the media device before
671 * registration. The following fields must be set:
673 * - dev must point to the parent device
674 * - model must be filled with the device model name
676 void media_device_init(struct media_device
*mdev
)
678 INIT_LIST_HEAD(&mdev
->entities
);
679 INIT_LIST_HEAD(&mdev
->interfaces
);
680 INIT_LIST_HEAD(&mdev
->pads
);
681 INIT_LIST_HEAD(&mdev
->links
);
682 INIT_LIST_HEAD(&mdev
->entity_notify
);
683 mutex_init(&mdev
->graph_mutex
);
684 ida_init(&mdev
->entity_internal_idx
);
686 dev_dbg(mdev
->dev
, "Media device initialized\n");
688 EXPORT_SYMBOL_GPL(media_device_init
);
690 void media_device_cleanup(struct media_device
*mdev
)
692 ida_destroy(&mdev
->entity_internal_idx
);
693 mdev
->entity_internal_idx_max
= 0;
694 media_graph_walk_cleanup(&mdev
->pm_count_walk
);
695 mutex_destroy(&mdev
->graph_mutex
);
697 EXPORT_SYMBOL_GPL(media_device_cleanup
);
699 int __must_check
__media_device_register(struct media_device
*mdev
,
700 struct module
*owner
)
702 struct media_devnode
*devnode
;
705 devnode
= kzalloc(sizeof(*devnode
), GFP_KERNEL
);
709 /* Register the device node. */
710 mdev
->devnode
= devnode
;
711 devnode
->fops
= &media_device_fops
;
712 devnode
->parent
= mdev
->dev
;
713 devnode
->release
= media_device_release
;
715 /* Set version 0 to indicate user-space that the graph is static */
716 mdev
->topology_version
= 0;
718 ret
= media_devnode_register(mdev
, devnode
, owner
);
720 /* devnode free is handled in media_devnode_*() */
721 mdev
->devnode
= NULL
;
725 ret
= device_create_file(&devnode
->dev
, &dev_attr_model
);
727 /* devnode free is handled in media_devnode_*() */
728 mdev
->devnode
= NULL
;
729 media_devnode_unregister_prepare(devnode
);
730 media_devnode_unregister(devnode
);
734 dev_dbg(mdev
->dev
, "Media device registered\n");
738 EXPORT_SYMBOL_GPL(__media_device_register
);
740 int __must_check
media_device_register_entity_notify(struct media_device
*mdev
,
741 struct media_entity_notify
*nptr
)
743 mutex_lock(&mdev
->graph_mutex
);
744 list_add_tail(&nptr
->list
, &mdev
->entity_notify
);
745 mutex_unlock(&mdev
->graph_mutex
);
748 EXPORT_SYMBOL_GPL(media_device_register_entity_notify
);
751 * Note: Should be called with mdev->lock held.
753 static void __media_device_unregister_entity_notify(struct media_device
*mdev
,
754 struct media_entity_notify
*nptr
)
756 list_del(&nptr
->list
);
759 void media_device_unregister_entity_notify(struct media_device
*mdev
,
760 struct media_entity_notify
*nptr
)
762 mutex_lock(&mdev
->graph_mutex
);
763 __media_device_unregister_entity_notify(mdev
, nptr
);
764 mutex_unlock(&mdev
->graph_mutex
);
766 EXPORT_SYMBOL_GPL(media_device_unregister_entity_notify
);
768 void media_device_unregister(struct media_device
*mdev
)
770 struct media_entity
*entity
;
771 struct media_entity
*next
;
772 struct media_interface
*intf
, *tmp_intf
;
773 struct media_entity_notify
*notify
, *nextp
;
778 mutex_lock(&mdev
->graph_mutex
);
780 /* Check if mdev was ever registered at all */
781 if (!media_devnode_is_registered(mdev
->devnode
)) {
782 mutex_unlock(&mdev
->graph_mutex
);
786 /* Clear the devnode register bit to avoid races with media dev open */
787 media_devnode_unregister_prepare(mdev
->devnode
);
789 /* Remove all entities from the media device */
790 list_for_each_entry_safe(entity
, next
, &mdev
->entities
, graph_obj
.list
)
791 __media_device_unregister_entity(entity
);
793 /* Remove all entity_notify callbacks from the media device */
794 list_for_each_entry_safe(notify
, nextp
, &mdev
->entity_notify
, list
)
795 __media_device_unregister_entity_notify(mdev
, notify
);
797 /* Remove all interfaces from the media device */
798 list_for_each_entry_safe(intf
, tmp_intf
, &mdev
->interfaces
,
801 * Unlink the interface, but don't free it here; the
802 * module which created it is responsible for freeing
805 __media_remove_intf_links(intf
);
806 media_gobj_destroy(&intf
->graph_obj
);
809 mutex_unlock(&mdev
->graph_mutex
);
811 dev_dbg(mdev
->dev
, "Media device unregistered\n");
813 device_remove_file(&mdev
->devnode
->dev
, &dev_attr_model
);
814 media_devnode_unregister(mdev
->devnode
);
815 /* devnode free is handled in media_devnode_*() */
816 mdev
->devnode
= NULL
;
818 EXPORT_SYMBOL_GPL(media_device_unregister
);
820 #if IS_ENABLED(CONFIG_PCI)
821 void media_device_pci_init(struct media_device
*mdev
,
822 struct pci_dev
*pci_dev
,
825 mdev
->dev
= &pci_dev
->dev
;
828 strlcpy(mdev
->model
, name
, sizeof(mdev
->model
));
830 strlcpy(mdev
->model
, pci_name(pci_dev
), sizeof(mdev
->model
));
832 sprintf(mdev
->bus_info
, "PCI:%s", pci_name(pci_dev
));
834 mdev
->hw_revision
= (pci_dev
->subsystem_vendor
<< 16)
835 | pci_dev
->subsystem_device
;
837 media_device_init(mdev
);
839 EXPORT_SYMBOL_GPL(media_device_pci_init
);
842 #if IS_ENABLED(CONFIG_USB)
843 void __media_device_usb_init(struct media_device
*mdev
,
844 struct usb_device
*udev
,
845 const char *board_name
,
846 const char *driver_name
)
848 mdev
->dev
= &udev
->dev
;
851 strlcpy(mdev
->driver_name
, driver_name
,
852 sizeof(mdev
->driver_name
));
855 strlcpy(mdev
->model
, board_name
, sizeof(mdev
->model
));
856 else if (udev
->product
)
857 strlcpy(mdev
->model
, udev
->product
, sizeof(mdev
->model
));
859 strlcpy(mdev
->model
, "unknown model", sizeof(mdev
->model
));
861 strlcpy(mdev
->serial
, udev
->serial
, sizeof(mdev
->serial
));
862 usb_make_path(udev
, mdev
->bus_info
, sizeof(mdev
->bus_info
));
863 mdev
->hw_revision
= le16_to_cpu(udev
->descriptor
.bcdDevice
);
865 media_device_init(mdev
);
867 EXPORT_SYMBOL_GPL(__media_device_usb_init
);
871 #endif /* CONFIG_MEDIA_CONTROLLER */