/drivers/media/media-device.c
C | 382 lines | 250 code | 69 blank | 63 comment | 42 complexity | c54ad4ea27df05fe01dc786b63a12140 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
1/* 2 * Media device 3 * 4 * Copyright (C) 2010 Nokia Corporation 5 * 6 * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com> 7 * Sakari Ailus <sakari.ailus@iki.fi> 8 * 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. 12 * 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. 17 * 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 21 */ 22 23#include <linux/types.h> 24#include <linux/ioctl.h> 25#include <linux/media.h> 26 27#include <media/media-device.h> 28#include <media/media-devnode.h> 29#include <media/media-entity.h> 30 31/* ----------------------------------------------------------------------------- 32 * Userspace API 33 */ 34 35static int media_device_open(struct file *filp) 36{ 37 return 0; 38} 39 40static int media_device_close(struct file *filp) 41{ 42 return 0; 43} 44 45static int media_device_get_info(struct media_device *dev, 46 struct media_device_info __user *__info) 47{ 48 struct media_device_info info; 49 50 memset(&info, 0, sizeof(info)); 51 52 strlcpy(info.driver, dev->dev->driver->name, sizeof(info.driver)); 53 strlcpy(info.model, dev->model, sizeof(info.model)); 54 strlcpy(info.serial, dev->serial, sizeof(info.serial)); 55 strlcpy(info.bus_info, dev->bus_info, sizeof(info.bus_info)); 56 57 info.media_version = MEDIA_API_VERSION; 58 info.hw_revision = dev->hw_revision; 59 info.driver_version = dev->driver_version; 60 61 return copy_to_user(__info, &info, sizeof(*__info)); 62} 63 64static struct media_entity *find_entity(struct media_device *mdev, u32 id) 65{ 66 struct media_entity *entity; 67 int next = id & MEDIA_ENT_ID_FLAG_NEXT; 68 69 id &= ~MEDIA_ENT_ID_FLAG_NEXT; 70 71 spin_lock(&mdev->lock); 72 73 media_device_for_each_entity(entity, mdev) { 74 if ((entity->id == id && !next) || 75 (entity->id > id && next)) { 76 spin_unlock(&mdev->lock); 77 return entity; 78 } 79 } 80 81 spin_unlock(&mdev->lock); 82 83 return NULL; 84} 85 86static long media_device_enum_entities(struct media_device *mdev, 87 struct media_entity_desc __user *uent) 88{ 89 struct media_entity *ent; 90 struct media_entity_desc u_ent; 91 92 if (copy_from_user(&u_ent.id, &uent->id, sizeof(u_ent.id))) 93 return -EFAULT; 94 95 ent = find_entity(mdev, u_ent.id); 96 97 if (ent == NULL) 98 return -EINVAL; 99 100 u_ent.id = ent->id; 101 u_ent.name[0] = '\0'; 102 if (ent->name) 103 strlcpy(u_ent.name, ent->name, sizeof(u_ent.name)); 104 u_ent.type = ent->type; 105 u_ent.revision = ent->revision; 106 u_ent.flags = ent->flags; 107 u_ent.group_id = ent->group_id; 108 u_ent.pads = ent->num_pads; 109 u_ent.links = ent->num_links - ent->num_backlinks; 110 u_ent.v4l.major = ent->v4l.major; 111 u_ent.v4l.minor = ent->v4l.minor; 112 if (copy_to_user(uent, &u_ent, sizeof(u_ent))) 113 return -EFAULT; 114 return 0; 115} 116 117static void media_device_kpad_to_upad(const struct media_pad *kpad, 118 struct media_pad_desc *upad) 119{ 120 upad->entity = kpad->entity->id; 121 upad->index = kpad->index; 122 upad->flags = kpad->flags; 123} 124 125static long media_device_enum_links(struct media_device *mdev, 126 struct media_links_enum __user *ulinks) 127{ 128 struct media_entity *entity; 129 struct media_links_enum links; 130 131 if (copy_from_user(&links, ulinks, sizeof(links))) 132 return -EFAULT; 133 134 entity = find_entity(mdev, links.entity); 135 if (entity == NULL) 136 return -EINVAL; 137 138 if (links.pads) { 139 unsigned int p; 140 141 for (p = 0; p < entity->num_pads; p++) { 142 struct media_pad_desc pad; 143 media_device_kpad_to_upad(&entity->pads[p], &pad); 144 if (copy_to_user(&links.pads[p], &pad, sizeof(pad))) 145 return -EFAULT; 146 } 147 } 148 149 if (links.links) { 150 struct media_link_desc __user *ulink; 151 unsigned int l; 152 153 for (l = 0, ulink = links.links; l < entity->num_links; l++) { 154 struct media_link_desc link; 155 156 /* Ignore backlinks. */ 157 if (entity->links[l].source->entity != entity) 158 continue; 159 160 media_device_kpad_to_upad(entity->links[l].source, 161 &link.source); 162 media_device_kpad_to_upad(entity->links[l].sink, 163 &link.sink); 164 link.flags = entity->links[l].flags; 165 if (copy_to_user(ulink, &link, sizeof(*ulink))) 166 return -EFAULT; 167 ulink++; 168 } 169 } 170 if (copy_to_user(ulinks, &links, sizeof(*ulinks))) 171 return -EFAULT; 172 return 0; 173} 174 175static long media_device_setup_link(struct media_device *mdev, 176 struct media_link_desc __user *_ulink) 177{ 178 struct media_link *link = NULL; 179 struct media_link_desc ulink; 180 struct media_entity *source; 181 struct media_entity *sink; 182 int ret; 183 184 if (copy_from_user(&ulink, _ulink, sizeof(ulink))) 185 return -EFAULT; 186 187 /* Find the source and sink entities and link. 188 */ 189 source = find_entity(mdev, ulink.source.entity); 190 sink = find_entity(mdev, ulink.sink.entity); 191 192 if (source == NULL || sink == NULL) 193 return -EINVAL; 194 195 if (ulink.source.index >= source->num_pads || 196 ulink.sink.index >= sink->num_pads) 197 return -EINVAL; 198 199 link = media_entity_find_link(&source->pads[ulink.source.index], 200 &sink->pads[ulink.sink.index]); 201 if (link == NULL) 202 return -EINVAL; 203 204 /* Setup the link on both entities. */ 205 ret = __media_entity_setup_link(link, ulink.flags); 206 207 if (copy_to_user(_ulink, &ulink, sizeof(ulink))) 208 return -EFAULT; 209 210 return ret; 211} 212 213static long media_device_ioctl(struct file *filp, unsigned int cmd, 214 unsigned long arg) 215{ 216 struct media_devnode *devnode = media_devnode_data(filp); 217 struct media_device *dev = to_media_device(devnode); 218 long ret; 219 220 switch (cmd) { 221 case MEDIA_IOC_DEVICE_INFO: 222 ret = media_device_get_info(dev, 223 (struct media_device_info __user *)arg); 224 break; 225 226 case MEDIA_IOC_ENUM_ENTITIES: 227 ret = media_device_enum_entities(dev, 228 (struct media_entity_desc __user *)arg); 229 break; 230 231 case MEDIA_IOC_ENUM_LINKS: 232 mutex_lock(&dev->graph_mutex); 233 ret = media_device_enum_links(dev, 234 (struct media_links_enum __user *)arg); 235 mutex_unlock(&dev->graph_mutex); 236 break; 237 238 case MEDIA_IOC_SETUP_LINK: 239 mutex_lock(&dev->graph_mutex); 240 ret = media_device_setup_link(dev, 241 (struct media_link_desc __user *)arg); 242 mutex_unlock(&dev->graph_mutex); 243 break; 244 245 default: 246 ret = -ENOIOCTLCMD; 247 } 248 249 return ret; 250} 251 252static const struct media_file_operations media_device_fops = { 253 .owner = THIS_MODULE, 254 .open = media_device_open, 255 .ioctl = media_device_ioctl, 256 .release = media_device_close, 257}; 258 259/* ----------------------------------------------------------------------------- 260 * sysfs 261 */ 262 263static ssize_t show_model(struct device *cd, 264 struct device_attribute *attr, char *buf) 265{ 266 struct media_device *mdev = to_media_device(to_media_devnode(cd)); 267 268 return sprintf(buf, "%.*s\n", (int)sizeof(mdev->model), mdev->model); 269} 270 271static DEVICE_ATTR(model, S_IRUGO, show_model, NULL); 272 273/* ----------------------------------------------------------------------------- 274 * Registration/unregistration 275 */ 276 277static void media_device_release(struct media_devnode *mdev) 278{ 279} 280 281/** 282 * media_device_register - register a media device 283 * @mdev: The media device 284 * 285 * The caller is responsible for initializing the media device before 286 * registration. The following fields must be set: 287 * 288 * - dev must point to the parent device 289 * - model must be filled with the device model name 290 */ 291int __must_check media_device_register(struct media_device *mdev) 292{ 293 int ret; 294 295 if (WARN_ON(mdev->dev == NULL || mdev->model[0] == 0)) 296 return -EINVAL; 297 298 mdev->entity_id = 1; 299 INIT_LIST_HEAD(&mdev->entities); 300 spin_lock_init(&mdev->lock); 301 mutex_init(&mdev->graph_mutex); 302 303 /* Register the device node. */ 304 mdev->devnode.fops = &media_device_fops; 305 mdev->devnode.parent = mdev->dev; 306 mdev->devnode.release = media_device_release; 307 ret = media_devnode_register(&mdev->devnode); 308 if (ret < 0) 309 return ret; 310 311 ret = device_create_file(&mdev->devnode.dev, &dev_attr_model); 312 if (ret < 0) { 313 media_devnode_unregister(&mdev->devnode); 314 return ret; 315 } 316 317 return 0; 318} 319EXPORT_SYMBOL_GPL(media_device_register); 320 321/** 322 * media_device_unregister - unregister a media device 323 * @mdev: The media device 324 * 325 */ 326void media_device_unregister(struct media_device *mdev) 327{ 328 struct media_entity *entity; 329 struct media_entity *next; 330 331 list_for_each_entry_safe(entity, next, &mdev->entities, list) 332 media_device_unregister_entity(entity); 333 334 device_remove_file(&mdev->devnode.dev, &dev_attr_model); 335 media_devnode_unregister(&mdev->devnode); 336} 337EXPORT_SYMBOL_GPL(media_device_unregister); 338 339/** 340 * media_device_register_entity - Register an entity with a media device 341 * @mdev: The media device 342 * @entity: The entity 343 */ 344int __must_check media_device_register_entity(struct media_device *mdev, 345 struct media_entity *entity) 346{ 347 /* Warn if we apparently re-register an entity */ 348 WARN_ON(entity->parent != NULL); 349 entity->parent = mdev; 350 351 spin_lock(&mdev->lock); 352 if (entity->id == 0) 353 entity->id = mdev->entity_id++; 354 else 355 mdev->entity_id = max(entity->id + 1, mdev->entity_id); 356 list_add_tail(&entity->list, &mdev->entities); 357 spin_unlock(&mdev->lock); 358 359 return 0; 360} 361EXPORT_SYMBOL_GPL(media_device_register_entity); 362 363/** 364 * media_device_unregister_entity - Unregister an entity 365 * @entity: The entity 366 * 367 * If the entity has never been registered this function will return 368 * immediately. 369 */ 370void media_device_unregister_entity(struct media_entity *entity) 371{ 372 struct media_device *mdev = entity->parent; 373 374 if (mdev == NULL) 375 return; 376 377 spin_lock(&mdev->lock); 378 list_del(&entity->list); 379 spin_unlock(&mdev->lock); 380 entity->parent = NULL; 381} 382EXPORT_SYMBOL_GPL(media_device_unregister_entity);