LCOV - code coverage report
Current view: top level - include/drm - drm_encoder_slave.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 2 0.0 %
Date: 2022-04-01 14:58:12 Functions: 0 0 -
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (C) 2009 Francisco Jerez.
       3                 :            :  * All Rights Reserved.
       4                 :            :  *
       5                 :            :  * Permission is hereby granted, free of charge, to any person obtaining
       6                 :            :  * a copy of this software and associated documentation files (the
       7                 :            :  * "Software"), to deal in the Software without restriction, including
       8                 :            :  * without limitation the rights to use, copy, modify, merge, publish,
       9                 :            :  * distribute, sublicense, and/or sell copies of the Software, and to
      10                 :            :  * permit persons to whom the Software is furnished to do so, subject to
      11                 :            :  * the following conditions:
      12                 :            :  *
      13                 :            :  * The above copyright notice and this permission notice (including the
      14                 :            :  * next paragraph) shall be included in all copies or substantial
      15                 :            :  * portions of the Software.
      16                 :            :  *
      17                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      18                 :            :  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      19                 :            :  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
      20                 :            :  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
      21                 :            :  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
      22                 :            :  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
      23                 :            :  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
      24                 :            :  *
      25                 :            :  */
      26                 :            : 
      27                 :            : #ifndef __DRM_ENCODER_SLAVE_H__
      28                 :            : #define __DRM_ENCODER_SLAVE_H__
      29                 :            : 
      30                 :            : #include <drm/drm_crtc.h>
      31                 :            : #include <drm/drm_encoder.h>
      32                 :            : 
      33                 :            : /**
      34                 :            :  * struct drm_encoder_slave_funcs - Entry points exposed by a slave encoder driver
      35                 :            :  * @set_config: Initialize any encoder-specific modesetting parameters.
      36                 :            :  *              The meaning of the @params parameter is implementation
      37                 :            :  *              dependent. It will usually be a structure with DVO port
      38                 :            :  *              data format settings or timings. It's not required for
      39                 :            :  *              the new parameters to take effect until the next mode
      40                 :            :  *              is set.
      41                 :            :  *
      42                 :            :  * Most of its members are analogous to the function pointers in
      43                 :            :  * &drm_encoder_helper_funcs and they can optionally be used to
      44                 :            :  * initialize the latter. Connector-like methods (e.g. @get_modes and
      45                 :            :  * @set_property) will typically be wrapped around and only be called
      46                 :            :  * if the encoder is the currently selected one for the connector.
      47                 :            :  */
      48                 :            : struct drm_encoder_slave_funcs {
      49                 :            :         void (*set_config)(struct drm_encoder *encoder,
      50                 :            :                            void *params);
      51                 :            : 
      52                 :            :         void (*destroy)(struct drm_encoder *encoder);
      53                 :            :         void (*dpms)(struct drm_encoder *encoder, int mode);
      54                 :            :         void (*save)(struct drm_encoder *encoder);
      55                 :            :         void (*restore)(struct drm_encoder *encoder);
      56                 :            :         bool (*mode_fixup)(struct drm_encoder *encoder,
      57                 :            :                            const struct drm_display_mode *mode,
      58                 :            :                            struct drm_display_mode *adjusted_mode);
      59                 :            :         int (*mode_valid)(struct drm_encoder *encoder,
      60                 :            :                           struct drm_display_mode *mode);
      61                 :            :         void (*mode_set)(struct drm_encoder *encoder,
      62                 :            :                          struct drm_display_mode *mode,
      63                 :            :                          struct drm_display_mode *adjusted_mode);
      64                 :            : 
      65                 :            :         enum drm_connector_status (*detect)(struct drm_encoder *encoder,
      66                 :            :                                             struct drm_connector *connector);
      67                 :            :         int (*get_modes)(struct drm_encoder *encoder,
      68                 :            :                          struct drm_connector *connector);
      69                 :            :         int (*create_resources)(struct drm_encoder *encoder,
      70                 :            :                                  struct drm_connector *connector);
      71                 :            :         int (*set_property)(struct drm_encoder *encoder,
      72                 :            :                             struct drm_connector *connector,
      73                 :            :                             struct drm_property *property,
      74                 :            :                             uint64_t val);
      75                 :            : 
      76                 :            : };
      77                 :            : 
      78                 :            : /**
      79                 :            :  * struct drm_encoder_slave - Slave encoder struct
      80                 :            :  * @base: DRM encoder object.
      81                 :            :  * @slave_funcs: Slave encoder callbacks.
      82                 :            :  * @slave_priv: Slave encoder private data.
      83                 :            :  * @bus_priv: Bus specific data.
      84                 :            :  *
      85                 :            :  * A &drm_encoder_slave has two sets of callbacks, @slave_funcs and the
      86                 :            :  * ones in @base. The former are never actually called by the common
      87                 :            :  * CRTC code, it's just a convenience for splitting the encoder
      88                 :            :  * functions in an upper, GPU-specific layer and a (hopefully)
      89                 :            :  * GPU-agnostic lower layer: It's the GPU driver responsibility to
      90                 :            :  * call the slave methods when appropriate.
      91                 :            :  *
      92                 :            :  * drm_i2c_encoder_init() provides a way to get an implementation of
      93                 :            :  * this.
      94                 :            :  */
      95                 :            : struct drm_encoder_slave {
      96                 :            :         struct drm_encoder base;
      97                 :            : 
      98                 :            :         const struct drm_encoder_slave_funcs *slave_funcs;
      99                 :            :         void *slave_priv;
     100                 :            :         void *bus_priv;
     101                 :            : };
     102                 :            : #define to_encoder_slave(x) container_of((x), struct drm_encoder_slave, base)
     103                 :            : 
     104                 :            : int drm_i2c_encoder_init(struct drm_device *dev,
     105                 :            :                          struct drm_encoder_slave *encoder,
     106                 :            :                          struct i2c_adapter *adap,
     107                 :            :                          const struct i2c_board_info *info);
     108                 :            : 
     109                 :            : 
     110                 :            : /**
     111                 :            :  * struct drm_i2c_encoder_driver
     112                 :            :  *
     113                 :            :  * Describes a device driver for an encoder connected to the GPU
     114                 :            :  * through an I2C bus. In addition to the entry points in @i2c_driver
     115                 :            :  * an @encoder_init function should be provided. It will be called to
     116                 :            :  * give the driver an opportunity to allocate any per-encoder data
     117                 :            :  * structures and to initialize the @slave_funcs and (optionally)
     118                 :            :  * @slave_priv members of @encoder.
     119                 :            :  */
     120                 :            : struct drm_i2c_encoder_driver {
     121                 :            :         struct i2c_driver i2c_driver;
     122                 :            : 
     123                 :            :         int (*encoder_init)(struct i2c_client *client,
     124                 :            :                             struct drm_device *dev,
     125                 :            :                             struct drm_encoder_slave *encoder);
     126                 :            : 
     127                 :            : };
     128                 :            : #define to_drm_i2c_encoder_driver(x) container_of((x),                  \
     129                 :            :                                                   struct drm_i2c_encoder_driver, \
     130                 :            :                                                   i2c_driver)
     131                 :            : 
     132                 :            : /**
     133                 :            :  * drm_i2c_encoder_get_client - Get the I2C client corresponding to an encoder
     134                 :            :  */
     135                 :          0 : static inline struct i2c_client *drm_i2c_encoder_get_client(struct drm_encoder *encoder)
     136                 :            : {
     137                 :          0 :         return (struct i2c_client *)to_encoder_slave(encoder)->bus_priv;
     138                 :            : }
     139                 :            : 
     140                 :            : /**
     141                 :            :  * drm_i2c_encoder_register - Register an I2C encoder driver
     142                 :            :  * @owner:      Module containing the driver.
     143                 :            :  * @driver:     Driver to be registered.
     144                 :            :  */
     145                 :            : static inline int drm_i2c_encoder_register(struct module *owner,
     146                 :            :                                            struct drm_i2c_encoder_driver *driver)
     147                 :            : {
     148                 :            :         return i2c_register_driver(owner, &driver->i2c_driver);
     149                 :            : }
     150                 :            : 
     151                 :            : /**
     152                 :            :  * drm_i2c_encoder_unregister - Unregister an I2C encoder driver
     153                 :            :  * @driver:     Driver to be unregistered.
     154                 :            :  */
     155                 :            : static inline void drm_i2c_encoder_unregister(struct drm_i2c_encoder_driver *driver)
     156                 :            : {
     157                 :            :         i2c_del_driver(&driver->i2c_driver);
     158                 :            : }
     159                 :            : 
     160                 :            : void drm_i2c_encoder_destroy(struct drm_encoder *encoder);
     161                 :            : 
     162                 :            : 
     163                 :            : /*
     164                 :            :  * Wrapper fxns which can be plugged in to drm_encoder_helper_funcs:
     165                 :            :  */
     166                 :            : 
     167                 :            : void drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode);
     168                 :            : bool drm_i2c_encoder_mode_fixup(struct drm_encoder *encoder,
     169                 :            :                 const struct drm_display_mode *mode,
     170                 :            :                 struct drm_display_mode *adjusted_mode);
     171                 :            : void drm_i2c_encoder_prepare(struct drm_encoder *encoder);
     172                 :            : void drm_i2c_encoder_commit(struct drm_encoder *encoder);
     173                 :            : void drm_i2c_encoder_mode_set(struct drm_encoder *encoder,
     174                 :            :                 struct drm_display_mode *mode,
     175                 :            :                 struct drm_display_mode *adjusted_mode);
     176                 :            : enum drm_connector_status drm_i2c_encoder_detect(struct drm_encoder *encoder,
     177                 :            :             struct drm_connector *connector);
     178                 :            : void drm_i2c_encoder_save(struct drm_encoder *encoder);
     179                 :            : void drm_i2c_encoder_restore(struct drm_encoder *encoder);
     180                 :            : 
     181                 :            : 
     182                 :            : #endif

Generated by: LCOV version 1.14