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                 :            : #include <linux/module.h>
      28                 :            : 
      29                 :            : #include <drm/drm_encoder_slave.h>
      30                 :            : 
      31                 :            : /**
      32                 :            :  * drm_i2c_encoder_init - Initialize an I2C slave encoder
      33                 :            :  * @dev:        DRM device.
      34                 :            :  * @encoder:    Encoder to be attached to the I2C device. You aren't
      35                 :            :  *              required to have called drm_encoder_init() before.
      36                 :            :  * @adap:       I2C adapter that will be used to communicate with
      37                 :            :  *              the device.
      38                 :            :  * @info:       Information that will be used to create the I2C device.
      39                 :            :  *              Required fields are @addr and @type.
      40                 :            :  *
      41                 :            :  * Create an I2C device on the specified bus (the module containing its
      42                 :            :  * driver is transparently loaded) and attach it to the specified
      43                 :            :  * &drm_encoder_slave. The @slave_funcs field will be initialized with
      44                 :            :  * the hooks provided by the slave driver.
      45                 :            :  *
      46                 :            :  * If @info.platform_data is non-NULL it will be used as the initial
      47                 :            :  * slave config.
      48                 :            :  *
      49                 :            :  * Returns 0 on success or a negative errno on failure, in particular,
      50                 :            :  * -ENODEV is returned when no matching driver is found.
      51                 :            :  */
      52                 :          0 : int drm_i2c_encoder_init(struct drm_device *dev,
      53                 :            :                          struct drm_encoder_slave *encoder,
      54                 :            :                          struct i2c_adapter *adap,
      55                 :            :                          const struct i2c_board_info *info)
      56                 :            : {
      57                 :          0 :         struct module *module = NULL;
      58                 :          0 :         struct i2c_client *client;
      59                 :          0 :         struct drm_i2c_encoder_driver *encoder_drv;
      60                 :          0 :         int err = 0;
      61                 :            : 
      62                 :          0 :         request_module("%s%s", I2C_MODULE_PREFIX, info->type);
      63                 :            : 
      64                 :          0 :         client = i2c_new_device(adap, info);
      65         [ #  # ]:          0 :         if (!client) {
      66                 :          0 :                 err = -ENOMEM;
      67                 :          0 :                 goto fail;
      68                 :            :         }
      69                 :            : 
      70         [ #  # ]:          0 :         if (!client->dev.driver) {
      71                 :          0 :                 err = -ENODEV;
      72                 :          0 :                 goto fail_unregister;
      73                 :            :         }
      74                 :            : 
      75                 :          0 :         module = client->dev.driver->owner;
      76         [ #  # ]:          0 :         if (!try_module_get(module)) {
      77                 :          0 :                 err = -ENODEV;
      78                 :          0 :                 goto fail_unregister;
      79                 :            :         }
      80                 :            : 
      81                 :          0 :         encoder->bus_priv = client;
      82                 :            : 
      83                 :          0 :         encoder_drv = to_drm_i2c_encoder_driver(to_i2c_driver(client->dev.driver));
      84                 :            : 
      85                 :          0 :         err = encoder_drv->encoder_init(client, dev, encoder);
      86         [ #  # ]:          0 :         if (err)
      87                 :          0 :                 goto fail_unregister;
      88                 :            : 
      89         [ #  # ]:          0 :         if (info->platform_data)
      90                 :          0 :                 encoder->slave_funcs->set_config(&encoder->base,
      91                 :            :                                                  info->platform_data);
      92                 :            : 
      93                 :            :         return 0;
      94                 :            : 
      95                 :          0 : fail_unregister:
      96                 :          0 :         i2c_unregister_device(client);
      97                 :          0 :         module_put(module);
      98                 :            : fail:
      99                 :            :         return err;
     100                 :            : }
     101                 :            : EXPORT_SYMBOL(drm_i2c_encoder_init);
     102                 :            : 
     103                 :            : /**
     104                 :            :  * drm_i2c_encoder_destroy - Unregister the I2C device backing an encoder
     105                 :            :  * @drm_encoder:        Encoder to be unregistered.
     106                 :            :  *
     107                 :            :  * This should be called from the @destroy method of an I2C slave
     108                 :            :  * encoder driver once I2C access is no longer needed.
     109                 :            :  */
     110                 :          0 : void drm_i2c_encoder_destroy(struct drm_encoder *drm_encoder)
     111                 :            : {
     112                 :          0 :         struct drm_encoder_slave *encoder = to_encoder_slave(drm_encoder);
     113                 :          0 :         struct i2c_client *client = drm_i2c_encoder_get_client(drm_encoder);
     114                 :          0 :         struct module *module = client->dev.driver->owner;
     115                 :            : 
     116                 :          0 :         i2c_unregister_device(client);
     117                 :          0 :         encoder->bus_priv = NULL;
     118                 :            : 
     119                 :          0 :         module_put(module);
     120                 :          0 : }
     121                 :            : EXPORT_SYMBOL(drm_i2c_encoder_destroy);
     122                 :            : 
     123                 :            : /*
     124                 :            :  * Wrapper fxns which can be plugged in to drm_encoder_helper_funcs:
     125                 :            :  */
     126                 :            : 
     127                 :            : static inline const struct drm_encoder_slave_funcs *
     128                 :          0 : get_slave_funcs(struct drm_encoder *enc)
     129                 :            : {
     130                 :          0 :         return to_encoder_slave(enc)->slave_funcs;
     131                 :            : }
     132                 :            : 
     133                 :          0 : void drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode)
     134                 :            : {
     135                 :          0 :         get_slave_funcs(encoder)->dpms(encoder, mode);
     136                 :          0 : }
     137                 :            : EXPORT_SYMBOL(drm_i2c_encoder_dpms);
     138                 :            : 
     139                 :          0 : bool drm_i2c_encoder_mode_fixup(struct drm_encoder *encoder,
     140                 :            :                 const struct drm_display_mode *mode,
     141                 :            :                 struct drm_display_mode *adjusted_mode)
     142                 :            : {
     143         [ #  # ]:          0 :         if (!get_slave_funcs(encoder)->mode_fixup)
     144                 :            :                 return true;
     145                 :            : 
     146                 :          0 :         return get_slave_funcs(encoder)->mode_fixup(encoder, mode, adjusted_mode);
     147                 :            : }
     148                 :            : EXPORT_SYMBOL(drm_i2c_encoder_mode_fixup);
     149                 :            : 
     150                 :          0 : void drm_i2c_encoder_prepare(struct drm_encoder *encoder)
     151                 :            : {
     152                 :          0 :         drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
     153                 :          0 : }
     154                 :            : EXPORT_SYMBOL(drm_i2c_encoder_prepare);
     155                 :            : 
     156                 :          0 : void drm_i2c_encoder_commit(struct drm_encoder *encoder)
     157                 :            : {
     158                 :          0 :         drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
     159                 :          0 : }
     160                 :            : EXPORT_SYMBOL(drm_i2c_encoder_commit);
     161                 :            : 
     162                 :          0 : void drm_i2c_encoder_mode_set(struct drm_encoder *encoder,
     163                 :            :                 struct drm_display_mode *mode,
     164                 :            :                 struct drm_display_mode *adjusted_mode)
     165                 :            : {
     166                 :          0 :         get_slave_funcs(encoder)->mode_set(encoder, mode, adjusted_mode);
     167                 :          0 : }
     168                 :            : EXPORT_SYMBOL(drm_i2c_encoder_mode_set);
     169                 :            : 
     170                 :          0 : enum drm_connector_status drm_i2c_encoder_detect(struct drm_encoder *encoder,
     171                 :            :             struct drm_connector *connector)
     172                 :            : {
     173                 :          0 :         return get_slave_funcs(encoder)->detect(encoder, connector);
     174                 :            : }
     175                 :            : EXPORT_SYMBOL(drm_i2c_encoder_detect);
     176                 :            : 
     177                 :          0 : void drm_i2c_encoder_save(struct drm_encoder *encoder)
     178                 :            : {
     179                 :          0 :         get_slave_funcs(encoder)->save(encoder);
     180                 :          0 : }
     181                 :            : EXPORT_SYMBOL(drm_i2c_encoder_save);
     182                 :            : 
     183                 :          0 : void drm_i2c_encoder_restore(struct drm_encoder *encoder)
     184                 :            : {
     185                 :          0 :         get_slave_funcs(encoder)->restore(encoder);
     186                 :          0 : }
     187                 :            : EXPORT_SYMBOL(drm_i2c_encoder_restore);