include/media/v4l2-subdev.h

   1 /*
   2     V4L2 sub-device support header.
   3
   4     Copyright (C) 2008  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #ifndef _V4L2_SUBDEV_H
  22 #define _V4L2_SUBDEV_H
  23
  24 #include <media/v4l2-common.h>
  25 #include <media/v4l2-dev.h>
  26 #include <media/v4l2-mediabus.h>
  27
  28 /* generic v4l2_device notify callback notification values */
  29 #define V4L2_SUBDEV_IR_RX_NOTIFY                _IOW('v', 0, u32)
  30 #define V4L2_SUBDEV_IR_RX_FIFO_SERVICE_REQ      0x00000001
  31 #define V4L2_SUBDEV_IR_RX_END_OF_RX_DETECTED    0x00000002
  32 #define V4L2_SUBDEV_IR_RX_HW_FIFO_OVERRUN       0x00000004
  33 #define V4L2_SUBDEV_IR_RX_SW_FIFO_OVERRUN       0x00000008
  34
  35 #define V4L2_SUBDEV_IR_TX_NOTIFY                _IOW('v', 1, u32)
  36 #define V4L2_SUBDEV_IR_TX_FIFO_SERVICE_REQ      0x00000001
  37
  38 struct v4l2_device;
  39 struct v4l2_ctrl_handler;
  40 struct v4l2_subdev;
  41 struct tuner_setup;
  42
  43 /* decode_vbi_line */
  44 struct v4l2_decode_vbi_line {
  45         u32 is_second_field;    /* Set to 0 for the first (odd) field,
  46                                    set to 1 for the second (even) field. */
  47         u8 *p;                  /* Pointer to the sliced VBI data from the decoder.
  48                                    On exit points to the start of the payload. */
  49         u32 line;               /* Line number of the sliced VBI data (1-23) */
  50         u32 type;               /* VBI service type (V4L2_SLICED_*). 0 if no service found */
  51 };
  52
  53 /* Sub-devices are devices that are connected somehow to the main bridge
  54    device. These devices are usually audio/video muxers/encoders/decoders or
  55    sensors and webcam controllers.
  56
  57    Usually these devices are controlled through an i2c bus, but other busses
  58    may also be used.
  59
  60    The v4l2_subdev struct provides a way of accessing these devices in a
  61    generic manner. Most operations that these sub-devices support fall in
  62    a few categories: core ops, audio ops, video ops and tuner ops.
  63
  64    More categories can be added if needed, although this should remain a
  65    limited set (no more than approx. 8 categories).
  66
  67    Each category has its own set of ops that subdev drivers can implement.
  68
  69    A subdev driver can leave the pointer to the category ops NULL if
  70    it does not implement them (e.g. an audio subdev will generally not
  71    implement the video category ops). The exception is the core category:
  72    this must always be present.
  73
  74    These ops are all used internally so it is no problem to change, remove
  75    or add ops or move ops from one to another category. Currently these
  76    ops are based on the original ioctls, but since ops are not limited to
  77    one argument there is room for improvement here once all i2c subdev
  78    drivers are converted to use these ops.
  79  */
  80
  81 /* Core ops: it is highly recommended to implement at least these ops:
  82
  83    g_chip_ident
  84    log_status
  85    g_register
  86    s_register
  87
  88    This provides basic debugging support.
  89
  90    The ioctl ops is meant for generic ioctl-like commands. Depending on
  91    the use-case it might be better to use subdev-specific ops (currently
  92    not yet implemented) since ops provide proper type-checking.
  93  */
  94
  95 /* Subdevice external IO pin configuration */
  96 #define V4L2_SUBDEV_IO_PIN_DISABLE      (1 << 0) /* ENABLE assumed */
  97 #define V4L2_SUBDEV_IO_PIN_OUTPUT       (1 << 1)
  98 #define V4L2_SUBDEV_IO_PIN_INPUT        (1 << 2)
  99 #define V4L2_SUBDEV_IO_PIN_SET_VALUE    (1 << 3) /* Set output value */
 100 #define V4L2_SUBDEV_IO_PIN_ACTIVE_LOW   (1 << 4) /* ACTIVE HIGH assumed */
 101
 102 struct v4l2_subdev_io_pin_config {
 103         u32 flags;      /* V4L2_SUBDEV_IO_PIN_* flags for this pin's config */
 104         u8 pin;         /* Chip external IO pin to configure */
 105         u8 function;    /* Internal signal pad/function to route to IO pin */
 106         u8 value;       /* Initial value for pin - e.g. GPIO output value */
 107         u8 strength;    /* Pin drive strength */
 108 };
 109
 110 /*
 111    s_io_pin_config: configure one or more chip I/O pins for chips that
 112         multiplex different internal signal pads out to IO pins.  This function
 113         takes a pointer to an array of 'n' pin configuration entries, one for
 114         each pin being configured.  This function could be called at times
 115         other than just subdevice initialization.
 116
 117    init: initialize the sensor registors to some sort of reasonable default
 118         values. Do not use for new drivers and should be removed in existing
 119         drivers.
 120
 121    load_fw: load firmware.
 122
 123    reset: generic reset command. The argument selects which subsystems to
 124         reset. Passing 0 will always reset the whole chip. Do not use for new
 125         drivers without discussing this first on the linux-media mailinglist.
 126         There should be no reason normally to reset a device.
 127
 128    s_gpio: set GPIO pins. Very simple right now, might need to be extended with
 129         a direction argument if needed.
 130
 131    s_power: puts subdevice in power saving mode (on == 0) or normal operation
 132         mode (on == 1).
 133
 134    interrupt_service_routine: Called by the bridge chip's interrupt service
 135         handler, when an interrupt status has be raised due to this subdev,
 136         so that this subdev can handle the details.  It may schedule work to be
 137         performed later.  It must not sleep.  *Called from an IRQ context*.
 138  */
 139 struct v4l2_subdev_core_ops {
 140         int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip);
 141         int (*log_status)(struct v4l2_subdev *sd);
 142         int (*s_io_pin_config)(struct v4l2_subdev *sd, size_t n,
 143                                       struct v4l2_subdev_io_pin_config *pincfg);
 144         int (*init)(struct v4l2_subdev *sd, u32 val);
 145         int (*load_fw)(struct v4l2_subdev *sd);
 146         int (*reset)(struct v4l2_subdev *sd, u32 val);
 147         int (*s_gpio)(struct v4l2_subdev *sd, u32 val);
 148         int (*queryctrl)(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc);
 149         int (*g_ctrl)(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
 150         int (*s_ctrl)(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
 151         int (*g_ext_ctrls)(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls);
 152         int (*s_ext_ctrls)(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls);
 153         int (*try_ext_ctrls)(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls);
 154         int (*querymenu)(struct v4l2_subdev *sd, struct v4l2_querymenu *qm);
 155         int (*s_std)(struct v4l2_subdev *sd, v4l2_std_id norm);
 156         long (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
 157 #ifdef CONFIG_VIDEO_ADV_DEBUG
 158         int (*g_register)(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg);
 159         int (*s_register)(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg);
 160 #endif
 161         int (*s_power)(struct v4l2_subdev *sd, int on);
 162         int (*interrupt_service_routine)(struct v4l2_subdev *sd,
 163                                                 u32 status, bool *handled);
 164 };
 165
 166 /* s_mode: switch the tuner to a specific tuner mode. Replacement of s_radio.
 167
 168    s_radio: v4l device was opened in Radio mode, to be replaced by s_mode.
 169
 170    s_type_addr: sets tuner type and its I2C addr.
 171
 172    s_config: sets tda9887 specific stuff, like port1, port2 and qss
 173  */
 174 struct v4l2_subdev_tuner_ops {
 175         int (*s_mode)(struct v4l2_subdev *sd, enum v4l2_tuner_type);
 176         int (*s_radio)(struct v4l2_subdev *sd);
 177         int (*s_frequency)(struct v4l2_subdev *sd, struct v4l2_frequency *freq);
 178         int (*g_frequency)(struct v4l2_subdev *sd, struct v4l2_frequency *freq);
 179         int (*g_tuner)(struct v4l2_subdev *sd, struct v4l2_tuner *vt);
 180         int (*s_tuner)(struct v4l2_subdev *sd, struct v4l2_tuner *vt);
 181         int (*g_modulator)(struct v4l2_subdev *sd, struct v4l2_modulator *vm);
 182         int (*s_modulator)(struct v4l2_subdev *sd, struct v4l2_modulator *vm);
 183         int (*s_type_addr)(struct v4l2_subdev *sd, struct tuner_setup *type);
 184         int (*s_config)(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *config);
 185 };
 186
 187 /* s_clock_freq: set the frequency (in Hz) of the audio clock output.
 188         Used to slave an audio processor to the video decoder, ensuring that
 189         audio and video remain synchronized. Usual values for the frequency
 190         are 48000, 44100 or 32000 Hz. If the frequency is not supported, then
 191         -EINVAL is returned.
 192
 193    s_i2s_clock_freq: sets I2S speed in bps. This is used to provide a standard
 194         way to select I2S clock used by driving digital audio streams at some
 195         board designs. Usual values for the frequency are 1024000 and 2048000.
 196         If the frequency is not supported, then -EINVAL is returned.
 197
 198    s_routing: used to define the input and/or output pins of an audio chip,
 199         and any additional configuration data.
 200         Never attempt to use user-level input IDs (e.g. Composite, S-Video,
 201         Tuner) at this level. An i2c device shouldn't know about whether an
 202         input pin is connected to a Composite connector, become on another
 203         board or platform it might be connected to something else entirely.
 204         The calling driver is responsible for mapping a user-level input to
 205         the right pins on the i2c device.
 206  */
 207 struct v4l2_subdev_audio_ops {
 208         int (*s_clock_freq)(struct v4l2_subdev *sd, u32 freq);
 209         int (*s_i2s_clock_freq)(struct v4l2_subdev *sd, u32 freq);
 210         int (*s_routing)(struct v4l2_subdev *sd, u32 input, u32 output, u32 config);
 211         int (*s_stream)(struct v4l2_subdev *sd, int enable);
 212 };
 213
 214 /*
 215    s_std_output: set v4l2_std_id for video OUTPUT devices. This is ignored by
 216         video input devices.
 217
 218    s_crystal_freq: sets the frequency of the crystal used to generate the
 219         clocks in Hz. An extra flags field allows device specific configuration
 220         regarding clock frequency dividers, etc. If not used, then set flags
 221         to 0. If the frequency is not supported, then -EINVAL is returned.
 222
 223    g_input_status: get input status. Same as the status field in the v4l2_input
 224         struct.
 225
 226    s_routing: see s_routing in audio_ops, except this version is for video
 227         devices.
 228
 229    s_dv_preset: set dv (Digital Video) preset in the sub device. Similar to
 230         s_std()
 231
 232    query_dv_preset: query dv preset in the sub device. This is similar to
 233         querystd()
 234
 235    s_dv_timings(): Set custom dv timings in the sub device. This is used
 236         when sub device is capable of setting detailed timing information
 237         in the hardware to generate/detect the video signal.
 238
 239    g_dv_timings(): Get custom dv timings in the sub device.
 240
 241    enum_mbus_fmt: enumerate pixel formats, provided by a video data source
 242
 243    g_mbus_fmt: get the current pixel format, provided by a video data source
 244
 245    try_mbus_fmt: try to set a pixel format on a video data source
 246
 247    s_mbus_fmt: set a pixel format on a video data source
 248  */
 249 struct v4l2_subdev_video_ops {
 250         int (*s_routing)(struct v4l2_subdev *sd, u32 input, u32 output, u32 config);
 251         int (*s_crystal_freq)(struct v4l2_subdev *sd, u32 freq, u32 flags);
 252         int (*s_std_output)(struct v4l2_subdev *sd, v4l2_std_id std);
 253         int (*querystd)(struct v4l2_subdev *sd, v4l2_std_id *std);
 254         int (*g_input_status)(struct v4l2_subdev *sd, u32 *status);
 255         int (*s_stream)(struct v4l2_subdev *sd, int enable);
 256         int (*cropcap)(struct v4l2_subdev *sd, struct v4l2_cropcap *cc);
 257         int (*g_crop)(struct v4l2_subdev *sd, struct v4l2_crop *crop);
 258         int (*s_crop)(struct v4l2_subdev *sd, struct v4l2_crop *crop);
 259         int (*g_parm)(struct v4l2_subdev *sd, struct v4l2_streamparm *param);
 260         int (*s_parm)(struct v4l2_subdev *sd, struct v4l2_streamparm *param);
 261         int (*enum_framesizes)(struct v4l2_subdev *sd, struct v4l2_frmsizeenum *fsize);
 262         int (*enum_frameintervals)(struct v4l2_subdev *sd, struct v4l2_frmivalenum *fival);
 263         int (*enum_dv_presets) (struct v4l2_subdev *sd,
 264                         struct v4l2_dv_enum_preset *preset);
 265         int (*s_dv_preset)(struct v4l2_subdev *sd,
 266                         struct v4l2_dv_preset *preset);
 267         int (*query_dv_preset)(struct v4l2_subdev *sd,
 268                         struct v4l2_dv_preset *preset);
 269         int (*s_dv_timings)(struct v4l2_subdev *sd,
 270                         struct v4l2_dv_timings *timings);
 271         int (*g_dv_timings)(struct v4l2_subdev *sd,
 272                         struct v4l2_dv_timings *timings);
 273         int (*enum_mbus_fmt)(struct v4l2_subdev *sd, unsigned int index,
 274                              enum v4l2_mbus_pixelcode *code);
 275         int (*enum_mbus_fsizes)(struct v4l2_subdev *sd,
 276                              struct v4l2_frmsizeenum *fsize);
 277         int (*g_mbus_fmt)(struct v4l2_subdev *sd,
 278                           struct v4l2_mbus_framefmt *fmt);
 279         int (*try_mbus_fmt)(struct v4l2_subdev *sd,
 280                             struct v4l2_mbus_framefmt *fmt);
 281         int (*s_mbus_fmt)(struct v4l2_subdev *sd,
 282                           struct v4l2_mbus_framefmt *fmt);
 283 };
 284
 285 /*
 286    decode_vbi_line: video decoders that support sliced VBI need to implement
 287         this ioctl. Field p of the v4l2_sliced_vbi_line struct is set to the
 288         start of the VBI data that was generated by the decoder. The driver
 289         then parses the sliced VBI data and sets the other fields in the
 290         struct accordingly. The pointer p is updated to point to the start of
 291         the payload which can be copied verbatim into the data field of the
 292         v4l2_sliced_vbi_data struct. If no valid VBI data was found, then the
 293         type field is set to 0 on return.
 294
 295    s_vbi_data: used to generate VBI signals on a video signal.
 296         v4l2_sliced_vbi_data is filled with the data packets that should be
 297         output. Note that if you set the line field to 0, then that VBI signal
 298         is disabled. If no valid VBI data was found, then the type field is
 299         set to 0 on return.
 300
 301    g_vbi_data: used to obtain the sliced VBI packet from a readback register.
 302         Not all video decoders support this. If no data is available because
 303         the readback register contains invalid or erroneous data -EIO is
 304         returned. Note that you must fill in the 'id' member and the 'field'
 305         member (to determine whether CC data from the first or second field
 306         should be obtained).
 307
 308    s_raw_fmt: setup the video encoder/decoder for raw VBI.
 309
 310    g_sliced_fmt: retrieve the current sliced VBI settings.
 311
 312    s_sliced_fmt: setup the sliced VBI settings.
 313  */
 314 struct v4l2_subdev_vbi_ops {
 315         int (*decode_vbi_line)(struct v4l2_subdev *sd, struct v4l2_decode_vbi_line *vbi_line);
 316         int (*s_vbi_data)(struct v4l2_subdev *sd, const struct v4l2_sliced_vbi_data *vbi_data);
 317         int (*g_vbi_data)(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_data *vbi_data);
 318         int (*g_sliced_vbi_cap)(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_cap *cap);
 319         int (*s_raw_fmt)(struct v4l2_subdev *sd, struct v4l2_vbi_format *fmt);
 320         int (*g_sliced_fmt)(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *fmt);
 321         int (*s_sliced_fmt)(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *fmt);
 322 };
 323
 324 /**
 325  * struct v4l2_subdev_sensor_ops - v4l2-subdev sensor operations
 326  * @g_skip_top_lines: number of lines at the top of the image to be skipped.
 327  *                    This is needed for some sensors, which always corrupt
 328  *                    several top lines of the output image, or which send their
 329  *                    metadata in them.
 330  */
 331 struct v4l2_subdev_sensor_ops {
 332         int (*g_skip_top_lines)(struct v4l2_subdev *sd, u32 *lines);
 333 };
 334
 335 /*
 336    [rt]x_g_parameters: Get the current operating parameters and state of the
 337         the IR receiver or transmitter.
 338
 339    [rt]x_s_parameters: Set the current operating parameters and state of the
 340         the IR receiver or transmitter.  It is recommended to call
 341         [rt]x_g_parameters first to fill out the current state, and only change
 342         the fields that need to be changed.  Upon return, the actual device
 343         operating parameters and state will be returned.  Note that hardware
 344         limitations may prevent the actual settings from matching the requested
 345         settings - e.g. an actual carrier setting of 35,904 Hz when 36,000 Hz
 346         was requested.  An exception is when the shutdown parameter is true.
 347         The last used operational parameters will be returned, but the actual
 348         state of the hardware be different to minimize power consumption and
 349         processing when shutdown is true.
 350
 351    rx_read: Reads received codes or pulse width data.
 352         The semantics are similar to a non-blocking read() call.
 353
 354    tx_write: Writes codes or pulse width data for transmission.
 355         The semantics are similar to a non-blocking write() call.
 356  */
 357
 358 enum v4l2_subdev_ir_mode {
 359         V4L2_SUBDEV_IR_MODE_PULSE_WIDTH, /* uses struct ir_raw_event records */
 360 };
 361
 362 struct v4l2_subdev_ir_parameters {
 363         /* Either Rx or Tx */
 364         unsigned int bytes_per_data_element; /* of data in read or write call */
 365         enum v4l2_subdev_ir_mode mode;
 366
 367         bool enable;
 368         bool interrupt_enable;
 369         bool shutdown; /* true: set hardware to low/no power, false: normal */
 370
 371         bool modulation;           /* true: uses carrier, false: baseband */
 372         u32 max_pulse_width;       /* ns,      valid only for baseband signal */
 373         unsigned int carrier_freq; /* Hz,      valid only for modulated signal*/
 374         unsigned int duty_cycle;   /* percent, valid only for modulated signal*/
 375         bool invert_level;         /* invert signal level */
 376
 377         /* Tx only */
 378         bool invert_carrier_sense; /* Send 0/space as a carrier burst */
 379
 380         /* Rx only */
 381         u32 noise_filter_min_width;       /* ns, min time of a valid pulse */
 382         unsigned int carrier_range_lower; /* Hz, valid only for modulated sig */
 383         unsigned int carrier_range_upper; /* Hz, valid only for modulated sig */
 384         u32 resolution;                   /* ns */
 385 };
 386
 387 struct v4l2_subdev_ir_ops {
 388         /* Receiver */
 389         int (*rx_read)(struct v4l2_subdev *sd, u8 *buf, size_t count,
 390                                 ssize_t *num);
 391
 392         int (*rx_g_parameters)(struct v4l2_subdev *sd,
 393                                 struct v4l2_subdev_ir_parameters *params);
 394         int (*rx_s_parameters)(struct v4l2_subdev *sd,
 395                                 struct v4l2_subdev_ir_parameters *params);
 396
 397         /* Transmitter */
 398         int (*tx_write)(struct v4l2_subdev *sd, u8 *buf, size_t count,
 399                                 ssize_t *num);
 400
 401         int (*tx_g_parameters)(struct v4l2_subdev *sd,
 402                                 struct v4l2_subdev_ir_parameters *params);
 403         int (*tx_s_parameters)(struct v4l2_subdev *sd,
 404                                 struct v4l2_subdev_ir_parameters *params);
 405 };
 406
 407 struct v4l2_subdev_ops {
 408         const struct v4l2_subdev_core_ops       *core;
 409         const struct v4l2_subdev_tuner_ops      *tuner;
 410         const struct v4l2_subdev_audio_ops      *audio;
 411         const struct v4l2_subdev_video_ops      *video;
 412         const struct v4l2_subdev_vbi_ops        *vbi;
 413         const struct v4l2_subdev_ir_ops         *ir;
 414         const struct v4l2_subdev_sensor_ops     *sensor;
 415 };
 416
 417 /*
 418  * Internal ops. Never call this from drivers, only the v4l2 framework can call
 419  * these ops.
 420  *
 421  * registered: called when this subdev is registered. When called the v4l2_dev
 422  *      field is set to the correct v4l2_device.
 423  *
 424  * unregistered: called when this subdev is unregistered. When called the
 425  *      v4l2_dev field is still set to the correct v4l2_device.
 426  */
 427 struct v4l2_subdev_internal_ops {
 428         int (*registered)(struct v4l2_subdev *sd);
 429         void (*unregistered)(struct v4l2_subdev *sd);
 430 };
 431
 432 #define V4L2_SUBDEV_NAME_SIZE 32
 433
 434 /* Set this flag if this subdev is a i2c device. */
 435 #define V4L2_SUBDEV_FL_IS_I2C                   (1U << 0)
 436 /* Set this flag if this subdev is a spi device. */
 437 #define V4L2_SUBDEV_FL_IS_SPI                   (1U << 1)
 438 /* Set this flag if this subdev needs a device node. */
 439 #define V4L2_SUBDEV_FL_HAS_DEVNODE              (1U << 2)
 440
 441 /* Each instance of a subdev driver should create this struct, either
 442    stand-alone or embedded in a larger struct.
 443  */
 444 struct v4l2_subdev {
 445         struct list_head list;
 446         struct module *owner;
 447         u32 flags;
 448         struct v4l2_device *v4l2_dev;
 449         const struct v4l2_subdev_ops *ops;
 450         /* Never call these internal ops from within a driver! */
 451         const struct v4l2_subdev_internal_ops *internal_ops;
 452         /* The control handler of this subdev. May be NULL. */
 453         struct v4l2_ctrl_handler *ctrl_handler;
 454         /* name must be unique */
 455         char name[V4L2_SUBDEV_NAME_SIZE];
 456         /* can be used to group similar subdevs, value is driver-specific */
 457         u32 grp_id;
 458         /* pointer to private data */
 459         void *dev_priv;
 460         void *host_priv;
 461         /* subdev device node */
 462         struct video_device devnode;
 463 };
 464
 465 #define vdev_to_v4l2_subdev(vdev) \
 466         container_of(vdev, struct v4l2_subdev, devnode)
 467
 468 extern const struct v4l2_file_operations v4l2_subdev_fops;
 469
 470 static inline void v4l2_set_subdevdata(struct v4l2_subdev *sd, void *p)
 471 {
 472         sd->dev_priv = p;
 473 }
 474
 475 static inline void *v4l2_get_subdevdata(const struct v4l2_subdev *sd)
 476 {
 477         return sd->dev_priv;
 478 }
 479
 480 static inline void v4l2_set_subdev_hostdata(struct v4l2_subdev *sd, void *p)
 481 {
 482         sd->host_priv = p;
 483 }
 484
 485 static inline void *v4l2_get_subdev_hostdata(const struct v4l2_subdev *sd)
 486 {
 487         return sd->host_priv;
 488 }
 489
 490 static inline void v4l2_subdev_init(struct v4l2_subdev *sd,
 491                                         const struct v4l2_subdev_ops *ops)
 492 {
 493         INIT_LIST_HEAD(&sd->list);
 494         BUG_ON(!ops);
 495         sd->ops = ops;
 496         sd->v4l2_dev = NULL;
 497         sd->flags = 0;
 498         sd->name[0] = '\0';
 499         sd->grp_id = 0;
 500         sd->dev_priv = NULL;
 501         sd->host_priv = NULL;
 502 }
 503
 504 /* Call an ops of a v4l2_subdev, doing the right checks against
 505    NULL pointers.
 506
 507    Example: err = v4l2_subdev_call(sd, core, g_chip_ident, &chip);
 508  */
 509 #define v4l2_subdev_call(sd, o, f, args...)                             \
 510         (!(sd) ? -ENODEV : (((sd)->ops->o && (sd)->ops->o->f) ? \
 511                 (sd)->ops->o->f((sd) , ##args) : -ENOIOCTLCMD))
 512
 513 /* Send a notification to v4l2_device. */
 514 #define v4l2_subdev_notify(sd, notification, arg)                          \
 515         ((!(sd) || !(sd)->v4l2_dev || !(sd)->v4l2_dev->notify) ? -ENODEV : \
 516          (sd)->v4l2_dev->notify((sd), (notification), (arg)))
 517
 518 #endif