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/types.h>
29 #include <media/media-device.h>
30 #include <media/media-devnode.h>
31 #include <media/media-entity.h>
33 /* -----------------------------------------------------------------------------
37 static int media_device_open(struct file
*filp
)
42 static int media_device_close(struct file
*filp
)
47 static int media_device_get_info(struct media_device
*dev
,
48 struct media_device_info __user
*__info
)
50 struct media_device_info info
;
52 memset(&info
, 0, sizeof(info
));
54 strlcpy(info
.driver
, dev
->dev
->driver
->name
, sizeof(info
.driver
));
55 strlcpy(info
.model
, dev
->model
, sizeof(info
.model
));
56 strlcpy(info
.serial
, dev
->serial
, sizeof(info
.serial
));
57 strlcpy(info
.bus_info
, dev
->bus_info
, sizeof(info
.bus_info
));
59 info
.media_version
= MEDIA_API_VERSION
;
60 info
.hw_revision
= dev
->hw_revision
;
61 info
.driver_version
= dev
->driver_version
;
63 if (copy_to_user(__info
, &info
, sizeof(*__info
)))
68 static struct media_entity
*find_entity(struct media_device
*mdev
, u32 id
)
70 struct media_entity
*entity
;
71 int next
= id
& MEDIA_ENT_ID_FLAG_NEXT
;
73 id
&= ~MEDIA_ENT_ID_FLAG_NEXT
;
75 spin_lock(&mdev
->lock
);
77 media_device_for_each_entity(entity
, mdev
) {
78 if ((entity
->id
== id
&& !next
) ||
79 (entity
->id
> id
&& next
)) {
80 spin_unlock(&mdev
->lock
);
85 spin_unlock(&mdev
->lock
);
90 static long media_device_enum_entities(struct media_device
*mdev
,
91 struct media_entity_desc __user
*uent
)
93 struct media_entity
*ent
;
94 struct media_entity_desc u_ent
;
96 memset(&u_ent
, 0, sizeof(u_ent
));
97 if (copy_from_user(&u_ent
.id
, &uent
->id
, sizeof(u_ent
.id
)))
100 ent
= find_entity(mdev
, u_ent
.id
);
107 strncpy(u_ent
.name
, ent
->name
, sizeof(u_ent
.name
));
108 u_ent
.name
[sizeof(u_ent
.name
) - 1] = '\0';
110 u_ent
.type
= ent
->type
;
111 u_ent
.revision
= ent
->revision
;
112 u_ent
.flags
= ent
->flags
;
113 u_ent
.group_id
= ent
->group_id
;
114 u_ent
.pads
= ent
->num_pads
;
115 u_ent
.links
= ent
->num_links
- ent
->num_backlinks
;
116 memcpy(&u_ent
.raw
, &ent
->info
, sizeof(ent
->info
));
117 if (copy_to_user(uent
, &u_ent
, sizeof(u_ent
)))
122 static void media_device_kpad_to_upad(const struct media_pad
*kpad
,
123 struct media_pad_desc
*upad
)
125 upad
->entity
= kpad
->entity
->id
;
126 upad
->index
= kpad
->index
;
127 upad
->flags
= kpad
->flags
;
130 static long __media_device_enum_links(struct media_device
*mdev
,
131 struct media_links_enum
*links
)
133 struct media_entity
*entity
;
135 entity
= find_entity(mdev
, links
->entity
);
142 for (p
= 0; p
< entity
->num_pads
; p
++) {
143 struct media_pad_desc pad
;
144 media_device_kpad_to_upad(&entity
->pads
[p
], &pad
);
145 if (copy_to_user(&links
->pads
[p
], &pad
, sizeof(pad
)))
151 struct media_link_desc __user
*ulink
;
154 for (l
= 0, ulink
= links
->links
; l
< entity
->num_links
; l
++) {
155 struct media_link_desc link
;
157 /* Ignore backlinks. */
158 if (entity
->links
[l
].source
->entity
!= entity
)
161 media_device_kpad_to_upad(entity
->links
[l
].source
,
163 media_device_kpad_to_upad(entity
->links
[l
].sink
,
165 link
.flags
= entity
->links
[l
].flags
;
166 if (copy_to_user(ulink
, &link
, sizeof(*ulink
)))
175 static long media_device_enum_links(struct media_device
*mdev
,
176 struct media_links_enum __user
*ulinks
)
178 struct media_links_enum links
;
181 if (copy_from_user(&links
, ulinks
, sizeof(links
)))
184 rval
= __media_device_enum_links(mdev
, &links
);
188 if (copy_to_user(ulinks
, &links
, sizeof(*ulinks
)))
194 static long media_device_setup_link(struct media_device
*mdev
,
195 struct media_link_desc __user
*_ulink
)
197 struct media_link
*link
= NULL
;
198 struct media_link_desc ulink
;
199 struct media_entity
*source
;
200 struct media_entity
*sink
;
203 if (copy_from_user(&ulink
, _ulink
, sizeof(ulink
)))
206 /* Find the source and sink entities and link.
208 source
= find_entity(mdev
, ulink
.source
.entity
);
209 sink
= find_entity(mdev
, ulink
.sink
.entity
);
211 if (source
== NULL
|| sink
== NULL
)
214 if (ulink
.source
.index
>= source
->num_pads
||
215 ulink
.sink
.index
>= sink
->num_pads
)
218 link
= media_entity_find_link(&source
->pads
[ulink
.source
.index
],
219 &sink
->pads
[ulink
.sink
.index
]);
223 /* Setup the link on both entities. */
224 ret
= __media_entity_setup_link(link
, ulink
.flags
);
226 if (copy_to_user(_ulink
, &ulink
, sizeof(ulink
)))
232 static long media_device_ioctl(struct file
*filp
, unsigned int cmd
,
235 struct media_devnode
*devnode
= media_devnode_data(filp
);
236 struct media_device
*dev
= to_media_device(devnode
);
240 case MEDIA_IOC_DEVICE_INFO
:
241 ret
= media_device_get_info(dev
,
242 (struct media_device_info __user
*)arg
);
245 case MEDIA_IOC_ENUM_ENTITIES
:
246 ret
= media_device_enum_entities(dev
,
247 (struct media_entity_desc __user
*)arg
);
250 case MEDIA_IOC_ENUM_LINKS
:
251 mutex_lock(&dev
->graph_mutex
);
252 ret
= media_device_enum_links(dev
,
253 (struct media_links_enum __user
*)arg
);
254 mutex_unlock(&dev
->graph_mutex
);
257 case MEDIA_IOC_SETUP_LINK
:
258 mutex_lock(&dev
->graph_mutex
);
259 ret
= media_device_setup_link(dev
,
260 (struct media_link_desc __user
*)arg
);
261 mutex_unlock(&dev
->graph_mutex
);
273 struct media_links_enum32
{
275 compat_uptr_t pads
; /* struct media_pad_desc * */
276 compat_uptr_t links
; /* struct media_link_desc * */
280 static long media_device_enum_links32(struct media_device
*mdev
,
281 struct media_links_enum32 __user
*ulinks
)
283 struct media_links_enum links
;
284 compat_uptr_t pads_ptr
, links_ptr
;
286 memset(&links
, 0, sizeof(links
));
288 if (get_user(links
.entity
, &ulinks
->entity
)
289 || get_user(pads_ptr
, &ulinks
->pads
)
290 || get_user(links_ptr
, &ulinks
->links
))
293 links
.pads
= compat_ptr(pads_ptr
);
294 links
.links
= compat_ptr(links_ptr
);
296 return __media_device_enum_links(mdev
, &links
);
299 #define MEDIA_IOC_ENUM_LINKS32 _IOWR('|', 0x02, struct media_links_enum32)
301 static long media_device_compat_ioctl(struct file
*filp
, unsigned int cmd
,
304 struct media_devnode
*devnode
= media_devnode_data(filp
);
305 struct media_device
*dev
= to_media_device(devnode
);
309 case MEDIA_IOC_DEVICE_INFO
:
310 case MEDIA_IOC_ENUM_ENTITIES
:
311 case MEDIA_IOC_SETUP_LINK
:
312 return media_device_ioctl(filp
, cmd
, arg
);
314 case MEDIA_IOC_ENUM_LINKS32
:
315 mutex_lock(&dev
->graph_mutex
);
316 ret
= media_device_enum_links32(dev
,
317 (struct media_links_enum32 __user
*)arg
);
318 mutex_unlock(&dev
->graph_mutex
);
327 #endif /* CONFIG_COMPAT */
329 static const struct media_file_operations media_device_fops
= {
330 .owner
= THIS_MODULE
,
331 .open
= media_device_open
,
332 .ioctl
= media_device_ioctl
,
334 .compat_ioctl
= media_device_compat_ioctl
,
335 #endif /* CONFIG_COMPAT */
336 .release
= media_device_close
,
339 /* -----------------------------------------------------------------------------
343 static ssize_t
show_model(struct device
*cd
,
344 struct device_attribute
*attr
, char *buf
)
346 struct media_device
*mdev
= to_media_device(to_media_devnode(cd
));
348 return sprintf(buf
, "%.*s\n", (int)sizeof(mdev
->model
), mdev
->model
);
351 static DEVICE_ATTR(model
, S_IRUGO
, show_model
, NULL
);
353 /* -----------------------------------------------------------------------------
354 * Registration/unregistration
357 static void media_device_release(struct media_devnode
*mdev
)
362 * media_device_register - register a media device
363 * @mdev: The media device
365 * The caller is responsible for initializing the media device before
366 * registration. The following fields must be set:
368 * - dev must point to the parent device
369 * - model must be filled with the device model name
371 int __must_check
media_device_register(struct media_device
*mdev
)
375 if (WARN_ON(mdev
->dev
== NULL
|| mdev
->model
[0] == 0))
379 INIT_LIST_HEAD(&mdev
->entities
);
380 spin_lock_init(&mdev
->lock
);
381 mutex_init(&mdev
->graph_mutex
);
383 /* Register the device node. */
384 mdev
->devnode
.fops
= &media_device_fops
;
385 mdev
->devnode
.parent
= mdev
->dev
;
386 mdev
->devnode
.release
= media_device_release
;
387 ret
= media_devnode_register(&mdev
->devnode
);
391 ret
= device_create_file(&mdev
->devnode
.dev
, &dev_attr_model
);
393 media_devnode_unregister(&mdev
->devnode
);
399 EXPORT_SYMBOL_GPL(media_device_register
);
402 * media_device_unregister - unregister a media device
403 * @mdev: The media device
406 void media_device_unregister(struct media_device
*mdev
)
408 struct media_entity
*entity
;
409 struct media_entity
*next
;
411 list_for_each_entry_safe(entity
, next
, &mdev
->entities
, list
)
412 media_device_unregister_entity(entity
);
414 device_remove_file(&mdev
->devnode
.dev
, &dev_attr_model
);
415 media_devnode_unregister(&mdev
->devnode
);
417 EXPORT_SYMBOL_GPL(media_device_unregister
);
420 * media_device_register_entity - Register an entity with a media device
421 * @mdev: The media device
422 * @entity: The entity
424 int __must_check
media_device_register_entity(struct media_device
*mdev
,
425 struct media_entity
*entity
)
427 /* Warn if we apparently re-register an entity */
428 WARN_ON(entity
->parent
!= NULL
);
429 entity
->parent
= mdev
;
431 spin_lock(&mdev
->lock
);
433 entity
->id
= mdev
->entity_id
++;
435 mdev
->entity_id
= max(entity
->id
+ 1, mdev
->entity_id
);
436 list_add_tail(&entity
->list
, &mdev
->entities
);
437 spin_unlock(&mdev
->lock
);
441 EXPORT_SYMBOL_GPL(media_device_register_entity
);
444 * media_device_unregister_entity - Unregister an entity
445 * @entity: The entity
447 * If the entity has never been registered this function will return
450 void media_device_unregister_entity(struct media_entity
*entity
)
452 struct media_device
*mdev
= entity
->parent
;
457 spin_lock(&mdev
->lock
);
458 list_del(&entity
->list
);
459 spin_unlock(&mdev
->lock
);
460 entity
->parent
= NULL
;
462 EXPORT_SYMBOL_GPL(media_device_unregister_entity
);