]>
Commit | Line | Data |
---|---|---|
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 | #ifndef _MEDIA_DEVICE_H | |
24 | #define _MEDIA_DEVICE_H | |
25 | ||
26 | #include <linux/list.h> | |
27 | #include <linux/mutex.h> | |
28 | #include <linux/spinlock.h> | |
29 | ||
30 | #include <media/media-devnode.h> | |
31 | #include <media/media-entity.h> | |
32 | ||
33 | /** | |
34 | * DOC: Media Controller | |
35 | * | |
36 | * The media controller userspace API is documented in DocBook format in | |
37 | * Documentation/DocBook/media/v4l/media-controller.xml. This document focus | |
38 | * on the kernel-side implementation of the media framework. | |
39 | * | |
40 | * * Abstract media device model: | |
41 | * | |
42 | * Discovering a device internal topology, and configuring it at runtime, is one | |
43 | * of the goals of the media framework. To achieve this, hardware devices are | |
44 | * modelled as an oriented graph of building blocks called entities connected | |
45 | * through pads. | |
46 | * | |
47 | * An entity is a basic media hardware building block. It can correspond to | |
48 | * a large variety of logical blocks such as physical hardware devices | |
49 | * (CMOS sensor for instance), logical hardware devices (a building block | |
50 | * in a System-on-Chip image processing pipeline), DMA channels or physical | |
51 | * connectors. | |
52 | * | |
53 | * A pad is a connection endpoint through which an entity can interact with | |
54 | * other entities. Data (not restricted to video) produced by an entity | |
55 | * flows from the entity's output to one or more entity inputs. Pads should | |
56 | * not be confused with physical pins at chip boundaries. | |
57 | * | |
58 | * A link is a point-to-point oriented connection between two pads, either | |
59 | * on the same entity or on different entities. Data flows from a source | |
60 | * pad to a sink pad. | |
61 | * | |
62 | * | |
63 | * * Media device: | |
64 | * | |
65 | * A media device is represented by a struct &media_device instance, defined in | |
66 | * include/media/media-device.h. Allocation of the structure is handled by the | |
67 | * media device driver, usually by embedding the &media_device instance in a | |
68 | * larger driver-specific structure. | |
69 | * | |
70 | * Drivers register media device instances by calling | |
71 | * __media_device_register() via the macro media_device_register() | |
72 | * and unregistered by calling | |
73 | * media_device_unregister(). | |
74 | * | |
75 | * * Entities, pads and links: | |
76 | * | |
77 | * - Entities | |
78 | * | |
79 | * Entities are represented by a struct &media_entity instance, defined in | |
80 | * include/media/media-entity.h. The structure is usually embedded into a | |
81 | * higher-level structure, such as a v4l2_subdev or video_device instance, | |
82 | * although drivers can allocate entities directly. | |
83 | * | |
84 | * Drivers initialize entity pads by calling | |
85 | * media_entity_pads_init(). | |
86 | * | |
87 | * Drivers register entities with a media device by calling | |
88 | * media_device_register_entity() | |
89 | * and unregistred by calling | |
90 | * media_device_unregister_entity(). | |
91 | * | |
92 | * - Interfaces | |
93 | * | |
94 | * Interfaces are represented by a struct &media_interface instance, defined in | |
95 | * include/media/media-entity.h. Currently, only one type of interface is | |
96 | * defined: a device node. Such interfaces are represented by a struct | |
97 | * &media_intf_devnode. | |
98 | * | |
99 | * Drivers initialize and create device node interfaces by calling | |
100 | * media_devnode_create() | |
101 | * and remove them by calling: | |
102 | * media_devnode_remove(). | |
103 | * | |
104 | * - Pads | |
105 | * | |
106 | * Pads are represented by a struct &media_pad instance, defined in | |
107 | * include/media/media-entity.h. Each entity stores its pads in a pads array | |
108 | * managed by the entity driver. Drivers usually embed the array in a | |
109 | * driver-specific structure. | |
110 | * | |
111 | * Pads are identified by their entity and their 0-based index in the pads | |
112 | * array. | |
113 | * Both information are stored in the &media_pad structure, making the | |
114 | * &media_pad pointer the canonical way to store and pass link references. | |
115 | * | |
116 | * Pads have flags that describe the pad capabilities and state. | |
117 | * | |
118 | * %MEDIA_PAD_FL_SINK indicates that the pad supports sinking data. | |
119 | * %MEDIA_PAD_FL_SOURCE indicates that the pad supports sourcing data. | |
120 | * | |
121 | * NOTE: One and only one of %MEDIA_PAD_FL_SINK and %MEDIA_PAD_FL_SOURCE must | |
122 | * be set for each pad. | |
123 | * | |
124 | * - Links | |
125 | * | |
126 | * Links are represented by a struct &media_link instance, defined in | |
127 | * include/media/media-entity.h. There are two types of links: | |
128 | * | |
129 | * 1. pad to pad links: | |
130 | * | |
131 | * Associate two entities via their PADs. Each entity has a list that points | |
132 | * to all links originating at or targeting any of its pads. | |
133 | * A given link is thus stored twice, once in the source entity and once in | |
134 | * the target entity. | |
135 | * | |
136 | * Drivers create pad to pad links by calling: | |
137 | * media_create_pad_link() and remove with media_entity_remove_links(). | |
138 | * | |
139 | * 2. interface to entity links: | |
140 | * | |
141 | * Associate one interface to a Link. | |
142 | * | |
143 | * Drivers create interface to entity links by calling: | |
144 | * media_create_intf_link() and remove with media_remove_intf_links(). | |
145 | * | |
146 | * NOTE: | |
147 | * | |
148 | * Links can only be created after having both ends already created. | |
149 | * | |
150 | * Links have flags that describe the link capabilities and state. The | |
151 | * valid values are described at media_create_pad_link() and | |
152 | * media_create_intf_link(). | |
153 | * | |
154 | * Graph traversal: | |
155 | * | |
156 | * The media framework provides APIs to iterate over entities in a graph. | |
157 | * | |
158 | * To iterate over all entities belonging to a media device, drivers can use | |
159 | * the media_device_for_each_entity macro, defined in | |
160 | * include/media/media-device.h. | |
161 | * | |
162 | * struct media_entity *entity; | |
163 | * | |
164 | * media_device_for_each_entity(entity, mdev) { | |
165 | * // entity will point to each entity in turn | |
166 | * ... | |
167 | * } | |
168 | * | |
169 | * Drivers might also need to iterate over all entities in a graph that can be | |
170 | * reached only through enabled links starting at a given entity. The media | |
171 | * framework provides a depth-first graph traversal API for that purpose. | |
172 | * | |
173 | * Note that graphs with cycles (whether directed or undirected) are *NOT* | |
174 | * supported by the graph traversal API. To prevent infinite loops, the graph | |
175 | * traversal code limits the maximum depth to MEDIA_ENTITY_ENUM_MAX_DEPTH, | |
176 | * currently defined as 16. | |
177 | * | |
178 | * Drivers initiate a graph traversal by calling | |
179 | * media_entity_graph_walk_start() | |
180 | * | |
181 | * The graph structure, provided by the caller, is initialized to start graph | |
182 | * traversal at the given entity. | |
183 | * | |
184 | * Drivers can then retrieve the next entity by calling | |
185 | * media_entity_graph_walk_next() | |
186 | * | |
187 | * When the graph traversal is complete the function will return NULL. | |
188 | * | |
189 | * Graph traversal can be interrupted at any moment. No cleanup function call | |
190 | * is required and the graph structure can be freed normally. | |
191 | * | |
192 | * Helper functions can be used to find a link between two given pads, or a pad | |
193 | * connected to another pad through an enabled link | |
194 | * media_entity_find_link() and media_entity_remote_pad() | |
195 | * | |
196 | * Use count and power handling: | |
197 | * | |
198 | * Due to the wide differences between drivers regarding power management | |
199 | * needs, the media controller does not implement power management. However, | |
200 | * the &media_entity structure includes a use_count field that media drivers | |
201 | * can use to track the number of users of every entity for power management | |
202 | * needs. | |
203 | * | |
204 | * The &media_entity.@use_count field is owned by media drivers and must not be | |
205 | * touched by entity drivers. Access to the field must be protected by the | |
206 | * &media_device.@graph_mutex lock. | |
207 | * | |
208 | * Links setup: | |
209 | * | |
210 | * Link properties can be modified at runtime by calling | |
211 | * media_entity_setup_link() | |
212 | * | |
213 | * Pipelines and media streams: | |
214 | * | |
215 | * When starting streaming, drivers must notify all entities in the pipeline to | |
216 | * prevent link states from being modified during streaming by calling | |
217 | * media_entity_pipeline_start(). | |
218 | * | |
219 | * The function will mark all entities connected to the given entity through | |
220 | * enabled links, either directly or indirectly, as streaming. | |
221 | * | |
222 | * The &media_pipeline instance pointed to by the pipe argument will be stored | |
223 | * in every entity in the pipeline. Drivers should embed the &media_pipeline | |
224 | * structure in higher-level pipeline structures and can then access the | |
225 | * pipeline through the &media_entity pipe field. | |
226 | * | |
227 | * Calls to media_entity_pipeline_start() can be nested. The pipeline pointer | |
228 | * must be identical for all nested calls to the function. | |
229 | * | |
230 | * media_entity_pipeline_start() may return an error. In that case, it will | |
231 | * clean up any of the changes it did by itself. | |
232 | * | |
233 | * When stopping the stream, drivers must notify the entities with | |
234 | * media_entity_pipeline_stop(). | |
235 | * | |
236 | * If multiple calls to media_entity_pipeline_start() have been made the same | |
237 | * number of media_entity_pipeline_stop() calls are required to stop streaming. | |
238 | * The &media_entity pipe field is reset to NULL on the last nested stop call. | |
239 | * | |
240 | * Link configuration will fail with -%EBUSY by default if either end of the | |
241 | * link is a streaming entity. Links that can be modified while streaming must | |
242 | * be marked with the %MEDIA_LNK_FL_DYNAMIC flag. | |
243 | * | |
244 | * If other operations need to be disallowed on streaming entities (such as | |
245 | * changing entities configuration parameters) drivers can explicitly check the | |
246 | * media_entity stream_count field to find out if an entity is streaming. This | |
247 | * operation must be done with the media_device graph_mutex held. | |
248 | * | |
249 | * Link validation: | |
250 | * | |
251 | * Link validation is performed by media_entity_pipeline_start() for any | |
252 | * entity which has sink pads in the pipeline. The | |
253 | * &media_entity.@link_validate() callback is used for that purpose. In | |
254 | * @link_validate() callback, entity driver should check that the properties of | |
255 | * the source pad of the connected entity and its own sink pad match. It is up | |
256 | * to the type of the entity (and in the end, the properties of the hardware) | |
257 | * what matching actually means. | |
258 | * | |
259 | * Subsystems should facilitate link validation by providing subsystem specific | |
260 | * helper functions to provide easy access for commonly needed information, and | |
261 | * in the end provide a way to use driver-specific callbacks. | |
262 | */ | |
263 | ||
264 | struct ida; | |
265 | struct device; | |
266 | ||
267 | /** | |
268 | * struct media_entity_notify - Media Entity Notify | |
269 | * | |
270 | * @list: List head | |
271 | * @notify_data: Input data to invoke the callback | |
272 | * @notify: Callback function pointer | |
273 | * | |
274 | * Drivers may register a callback to take action when | |
275 | * new entities get registered with the media device. | |
276 | */ | |
277 | struct media_entity_notify { | |
278 | struct list_head list; | |
279 | void *notify_data; | |
280 | void (*notify)(struct media_entity *entity, void *notify_data); | |
281 | }; | |
282 | ||
283 | /** | |
284 | * struct media_device - Media device | |
285 | * @dev: Parent device | |
286 | * @devnode: Media device node | |
287 | * @driver_name: Optional device driver name. If not set, calls to | |
288 | * %MEDIA_IOC_DEVICE_INFO will return dev->driver->name. | |
289 | * This is needed for USB drivers for example, as otherwise | |
290 | * they'll all appear as if the driver name was "usb". | |
291 | * @model: Device model name | |
292 | * @serial: Device serial number (optional) | |
293 | * @bus_info: Unique and stable device location identifier | |
294 | * @hw_revision: Hardware device revision | |
295 | * @driver_version: Device driver version | |
296 | * @topology_version: Monotonic counter for storing the version of the graph | |
297 | * topology. Should be incremented each time the topology changes. | |
298 | * @id: Unique ID used on the last registered graph object | |
299 | * @entity_internal_idx: Unique internal entity ID used by the graph traversal | |
300 | * algorithms | |
301 | * @entity_internal_idx_max: Allocated internal entity indices | |
302 | * @entities: List of registered entities | |
303 | * @interfaces: List of registered interfaces | |
304 | * @pads: List of registered pads | |
305 | * @links: List of registered links | |
306 | * @entity_notify: List of registered entity_notify callbacks | |
307 | * @lock: Entities list lock | |
308 | * @graph_mutex: Entities graph operation lock | |
309 | * @pm_count_walk: Graph walk for power state walk. Access serialised using | |
310 | * graph_mutex. | |
311 | * | |
312 | * @source_priv: Driver Private data for enable/disable source handlers | |
313 | * @enable_source: Enable Source Handler function pointer | |
314 | * @disable_source: Disable Source Handler function pointer | |
315 | * | |
316 | * @link_notify: Link state change notification callback | |
317 | * | |
318 | * This structure represents an abstract high-level media device. It allows easy | |
319 | * access to entities and provides basic media device-level support. The | |
320 | * structure can be allocated directly or embedded in a larger structure. | |
321 | * | |
322 | * The parent @dev is a physical device. It must be set before registering the | |
323 | * media device. | |
324 | * | |
325 | * @model is a descriptive model name exported through sysfs. It doesn't have to | |
326 | * be unique. | |
327 | * | |
328 | * @enable_source is a handler to find source entity for the | |
329 | * sink entity and activate the link between them if source | |
330 | * entity is free. Drivers should call this handler before | |
331 | * accessing the source. | |
332 | * | |
333 | * @disable_source is a handler to find source entity for the | |
334 | * sink entity and deactivate the link between them. Drivers | |
335 | * should call this handler to release the source. | |
336 | * | |
337 | * Note: Bridge driver is expected to implement and set the | |
338 | * handler when media_device is registered or when | |
339 | * bridge driver finds the media_device during probe. | |
340 | * Bridge driver sets source_priv with information | |
341 | * necessary to run enable/disable source handlers. | |
342 | * | |
343 | * Use-case: find tuner entity connected to the decoder | |
344 | * entity and check if it is available, and activate the | |
345 | * the link between them from enable_source and deactivate | |
346 | * from disable_source. | |
347 | */ | |
348 | struct media_device { | |
349 | /* dev->driver_data points to this struct. */ | |
350 | struct device *dev; | |
351 | struct media_devnode devnode; | |
352 | ||
353 | char model[32]; | |
354 | char driver_name[32]; | |
355 | char serial[40]; | |
356 | char bus_info[32]; | |
357 | u32 hw_revision; | |
358 | u32 driver_version; | |
359 | ||
360 | u32 topology_version; | |
361 | ||
362 | u32 id; | |
363 | struct ida entity_internal_idx; | |
364 | int entity_internal_idx_max; | |
365 | ||
366 | struct list_head entities; | |
367 | struct list_head interfaces; | |
368 | struct list_head pads; | |
369 | struct list_head links; | |
370 | ||
371 | /* notify callback list invoked when a new entity is registered */ | |
372 | struct list_head entity_notify; | |
373 | ||
374 | /* Protects the graph objects creation/removal */ | |
375 | spinlock_t lock; | |
376 | /* Serializes graph operations. */ | |
377 | struct mutex graph_mutex; | |
378 | struct media_entity_graph pm_count_walk; | |
379 | ||
380 | void *source_priv; | |
381 | int (*enable_source)(struct media_entity *entity, | |
382 | struct media_pipeline *pipe); | |
383 | void (*disable_source)(struct media_entity *entity); | |
384 | ||
385 | int (*link_notify)(struct media_link *link, u32 flags, | |
386 | unsigned int notification); | |
387 | }; | |
388 | ||
389 | /* We don't need to include pci.h or usb.h here */ | |
390 | struct pci_dev; | |
391 | struct usb_device; | |
392 | ||
393 | #ifdef CONFIG_MEDIA_CONTROLLER | |
394 | ||
395 | /* Supported link_notify @notification values. */ | |
396 | #define MEDIA_DEV_NOTIFY_PRE_LINK_CH 0 | |
397 | #define MEDIA_DEV_NOTIFY_POST_LINK_CH 1 | |
398 | ||
399 | /* media_devnode to media_device */ | |
400 | #define to_media_device(node) container_of(node, struct media_device, devnode) | |
401 | ||
402 | /** | |
403 | * media_entity_enum_init - Initialise an entity enumeration | |
404 | * | |
405 | * @ent_enum: Entity enumeration to be initialised | |
406 | * @mdev: The related media device | |
407 | * | |
408 | * Returns zero on success or a negative error code. | |
409 | */ | |
410 | static inline __must_check int media_entity_enum_init( | |
411 | struct media_entity_enum *ent_enum, struct media_device *mdev) | |
412 | { | |
413 | return __media_entity_enum_init(ent_enum, | |
414 | mdev->entity_internal_idx_max + 1); | |
415 | } | |
416 | ||
417 | /** | |
418 | * media_device_init() - Initializes a media device element | |
419 | * | |
420 | * @mdev: pointer to struct &media_device | |
421 | * | |
422 | * This function initializes the media device prior to its registration. | |
423 | * The media device initialization and registration is split in two functions | |
424 | * to avoid race conditions and make the media device available to user-space | |
425 | * before the media graph has been completed. | |
426 | * | |
427 | * So drivers need to first initialize the media device, register any entity | |
428 | * within the media device, create pad to pad links and then finally register | |
429 | * the media device by calling media_device_register() as a final step. | |
430 | */ | |
431 | void media_device_init(struct media_device *mdev); | |
432 | ||
433 | /** | |
434 | * media_device_cleanup() - Cleanups a media device element | |
435 | * | |
436 | * @mdev: pointer to struct &media_device | |
437 | * | |
438 | * This function that will destroy the graph_mutex that is | |
439 | * initialized in media_device_init(). | |
440 | */ | |
441 | void media_device_cleanup(struct media_device *mdev); | |
442 | ||
443 | /** | |
444 | * __media_device_register() - Registers a media device element | |
445 | * | |
446 | * @mdev: pointer to struct &media_device | |
447 | * @owner: should be filled with %THIS_MODULE | |
448 | * | |
449 | * Users, should, instead, call the media_device_register() macro. | |
450 | * | |
451 | * The caller is responsible for initializing the media_device structure before | |
452 | * registration. The following fields must be set: | |
453 | * | |
454 | * - dev must point to the parent device (usually a &pci_dev, &usb_interface or | |
455 | * &platform_device instance). | |
456 | * | |
457 | * - model must be filled with the device model name as a NUL-terminated UTF-8 | |
458 | * string. The device/model revision must not be stored in this field. | |
459 | * | |
460 | * The following fields are optional: | |
461 | * | |
462 | * - serial is a unique serial number stored as a NUL-terminated ASCII string. | |
463 | * The field is big enough to store a GUID in text form. If the hardware | |
464 | * doesn't provide a unique serial number this field must be left empty. | |
465 | * | |
466 | * - bus_info represents the location of the device in the system as a | |
467 | * NUL-terminated ASCII string. For PCI/PCIe devices bus_info must be set to | |
468 | * "PCI:" (or "PCIe:") followed by the value of pci_name(). For USB devices, | |
469 | * the usb_make_path() function must be used. This field is used by | |
470 | * applications to distinguish between otherwise identical devices that don't | |
471 | * provide a serial number. | |
472 | * | |
473 | * - hw_revision is the hardware device revision in a driver-specific format. | |
474 | * When possible the revision should be formatted with the KERNEL_VERSION | |
475 | * macro. | |
476 | * | |
477 | * - driver_version is formatted with the KERNEL_VERSION macro. The version | |
478 | * minor must be incremented when new features are added to the userspace API | |
479 | * without breaking binary compatibility. The version major must be | |
480 | * incremented when binary compatibility is broken. | |
481 | * | |
482 | * Notes: | |
483 | * | |
484 | * Upon successful registration a character device named media[0-9]+ is created. | |
485 | * The device major and minor numbers are dynamic. The model name is exported as | |
486 | * a sysfs attribute. | |
487 | * | |
488 | * Unregistering a media device that hasn't been registered is *NOT* safe. | |
489 | * | |
490 | * Return: returns zero on success or a negative error code. | |
491 | */ | |
492 | int __must_check __media_device_register(struct media_device *mdev, | |
493 | struct module *owner); | |
494 | #define media_device_register(mdev) __media_device_register(mdev, THIS_MODULE) | |
495 | ||
496 | /** | |
497 | * __media_device_unregister() - Unegisters a media device element | |
498 | * | |
499 | * @mdev: pointer to struct &media_device | |
500 | * | |
501 | * | |
502 | * It is safe to call this function on an unregistered (but initialised) | |
503 | * media device. | |
504 | */ | |
505 | void media_device_unregister(struct media_device *mdev); | |
506 | ||
507 | /** | |
508 | * media_device_register_entity() - registers a media entity inside a | |
509 | * previously registered media device. | |
510 | * | |
511 | * @mdev: pointer to struct &media_device | |
512 | * @entity: pointer to struct &media_entity to be registered | |
513 | * | |
514 | * Entities are identified by a unique positive integer ID. The media | |
515 | * controller framework will such ID automatically. IDs are not guaranteed | |
516 | * to be contiguous, and the ID number can change on newer Kernel versions. | |
517 | * So, neither the driver nor userspace should hardcode ID numbers to refer | |
518 | * to the entities, but, instead, use the framework to find the ID, when | |
519 | * needed. | |
520 | * | |
521 | * The media_entity name, type and flags fields should be initialized before | |
522 | * calling media_device_register_entity(). Entities embedded in higher-level | |
523 | * standard structures can have some of those fields set by the higher-level | |
524 | * framework. | |
525 | * | |
526 | * If the device has pads, media_entity_pads_init() should be called before | |
527 | * this function. Otherwise, the &media_entity.@pad and &media_entity.@num_pads | |
528 | * should be zeroed before calling this function. | |
529 | * | |
530 | * Entities have flags that describe the entity capabilities and state: | |
531 | * | |
532 | * %MEDIA_ENT_FL_DEFAULT indicates the default entity for a given type. | |
533 | * This can be used to report the default audio and video devices or the | |
534 | * default camera sensor. | |
535 | * | |
536 | * NOTE: Drivers should set the entity function before calling this function. | |
537 | * Please notice that the values %MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN and | |
538 | * %MEDIA_ENT_F_UNKNOWN should not be used by the drivers. | |
539 | */ | |
540 | int __must_check media_device_register_entity(struct media_device *mdev, | |
541 | struct media_entity *entity); | |
542 | ||
543 | /* | |
544 | * media_device_unregister_entity() - unregisters a media entity. | |
545 | * | |
546 | * @entity: pointer to struct &media_entity to be unregistered | |
547 | * | |
548 | * All links associated with the entity and all PADs are automatically | |
549 | * unregistered from the media_device when this function is called. | |
550 | * | |
551 | * Unregistering an entity will not change the IDs of the other entities and | |
552 | * the previoully used ID will never be reused for a newly registered entities. | |
553 | * | |
554 | * When a media device is unregistered, all its entities are unregistered | |
555 | * automatically. No manual entities unregistration is then required. | |
556 | * | |
557 | * Note: the media_entity instance itself must be freed explicitly by | |
558 | * the driver if required. | |
559 | */ | |
560 | void media_device_unregister_entity(struct media_entity *entity); | |
561 | ||
562 | /** | |
563 | * media_device_register_entity_notify() - Registers a media entity_notify | |
564 | * callback | |
565 | * | |
566 | * @mdev: The media device | |
567 | * @nptr: The media_entity_notify | |
568 | * | |
569 | * Note: When a new entity is registered, all the registered | |
570 | * media_entity_notify callbacks are invoked. | |
571 | */ | |
572 | ||
573 | int __must_check media_device_register_entity_notify(struct media_device *mdev, | |
574 | struct media_entity_notify *nptr); | |
575 | ||
576 | /** | |
577 | * media_device_unregister_entity_notify() - Unregister a media entity notify | |
578 | * callback | |
579 | * | |
580 | * @mdev: The media device | |
581 | * @nptr: The media_entity_notify | |
582 | * | |
583 | */ | |
584 | void media_device_unregister_entity_notify(struct media_device *mdev, | |
585 | struct media_entity_notify *nptr); | |
586 | ||
587 | /** | |
588 | * media_device_get_devres() - get media device as device resource | |
589 | * creates if one doesn't exist | |
590 | * | |
591 | * @dev: pointer to struct &device. | |
592 | * | |
593 | * Sometimes, the media controller &media_device needs to be shared by more | |
594 | * than one driver. This function adds support for that, by dynamically | |
595 | * allocating the &media_device and allowing it to be obtained from the | |
596 | * struct &device associated with the common device where all sub-device | |
597 | * components belong. So, for example, on an USB device with multiple | |
598 | * interfaces, each interface may be handled by a separate per-interface | |
599 | * drivers. While each interface have its own &device, they all share a | |
600 | * common &device associated with the hole USB device. | |
601 | */ | |
602 | struct media_device *media_device_get_devres(struct device *dev); | |
603 | ||
604 | /** | |
605 | * media_device_find_devres() - find media device as device resource | |
606 | * | |
607 | * @dev: pointer to struct &device. | |
608 | */ | |
609 | struct media_device *media_device_find_devres(struct device *dev); | |
610 | ||
611 | /* Iterate over all entities. */ | |
612 | #define media_device_for_each_entity(entity, mdev) \ | |
613 | list_for_each_entry(entity, &(mdev)->entities, graph_obj.list) | |
614 | ||
615 | /* Iterate over all interfaces. */ | |
616 | #define media_device_for_each_intf(intf, mdev) \ | |
617 | list_for_each_entry(intf, &(mdev)->interfaces, graph_obj.list) | |
618 | ||
619 | /* Iterate over all pads. */ | |
620 | #define media_device_for_each_pad(pad, mdev) \ | |
621 | list_for_each_entry(pad, &(mdev)->pads, graph_obj.list) | |
622 | ||
623 | /* Iterate over all links. */ | |
624 | #define media_device_for_each_link(link, mdev) \ | |
625 | list_for_each_entry(link, &(mdev)->links, graph_obj.list) | |
626 | ||
627 | /** | |
628 | * media_device_pci_init() - create and initialize a | |
629 | * struct &media_device from a PCI device. | |
630 | * | |
631 | * @mdev: pointer to struct &media_device | |
632 | * @pci_dev: pointer to struct pci_dev | |
633 | * @name: media device name. If %NULL, the routine will use the default | |
634 | * name for the pci device, given by pci_name() macro. | |
635 | */ | |
636 | void media_device_pci_init(struct media_device *mdev, | |
637 | struct pci_dev *pci_dev, | |
638 | const char *name); | |
639 | /** | |
640 | * __media_device_usb_init() - create and initialize a | |
641 | * struct &media_device from a PCI device. | |
642 | * | |
643 | * @mdev: pointer to struct &media_device | |
644 | * @udev: pointer to struct usb_device | |
645 | * @board_name: media device name. If %NULL, the routine will use the usb | |
646 | * product name, if available. | |
647 | * @driver_name: name of the driver. if %NULL, the routine will use the name | |
648 | * given by udev->dev->driver->name, with is usually the wrong | |
649 | * thing to do. | |
650 | * | |
651 | * NOTE: It is better to call media_device_usb_init() instead, as | |
652 | * such macro fills driver_name with %KBUILD_MODNAME. | |
653 | */ | |
654 | void __media_device_usb_init(struct media_device *mdev, | |
655 | struct usb_device *udev, | |
656 | const char *board_name, | |
657 | const char *driver_name); | |
658 | ||
659 | #else | |
660 | static inline int media_device_register(struct media_device *mdev) | |
661 | { | |
662 | return 0; | |
663 | } | |
664 | static inline void media_device_unregister(struct media_device *mdev) | |
665 | { | |
666 | } | |
667 | static inline int media_device_register_entity(struct media_device *mdev, | |
668 | struct media_entity *entity) | |
669 | { | |
670 | return 0; | |
671 | } | |
672 | static inline void media_device_unregister_entity(struct media_entity *entity) | |
673 | { | |
674 | } | |
675 | static inline int media_device_register_entity_notify( | |
676 | struct media_device *mdev, | |
677 | struct media_entity_notify *nptr) | |
678 | { | |
679 | return 0; | |
680 | } | |
681 | static inline void media_device_unregister_entity_notify( | |
682 | struct media_device *mdev, | |
683 | struct media_entity_notify *nptr) | |
684 | { | |
685 | } | |
686 | static inline struct media_device *media_device_get_devres(struct device *dev) | |
687 | { | |
688 | return NULL; | |
689 | } | |
690 | static inline struct media_device *media_device_find_devres(struct device *dev) | |
691 | { | |
692 | return NULL; | |
693 | } | |
694 | ||
695 | static inline void media_device_pci_init(struct media_device *mdev, | |
696 | struct pci_dev *pci_dev, | |
697 | char *name) | |
698 | { | |
699 | } | |
700 | ||
701 | static inline void __media_device_usb_init(struct media_device *mdev, | |
702 | struct usb_device *udev, | |
703 | char *board_name, | |
704 | char *driver_name) | |
705 | { | |
706 | } | |
707 | ||
708 | #endif /* CONFIG_MEDIA_CONTROLLER */ | |
709 | ||
710 | #define media_device_usb_init(mdev, udev, name) \ | |
711 | __media_device_usb_init(mdev, udev, name, KBUILD_MODNAME) | |
712 | ||
713 | #endif |