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             :         struct i2c_client *client;
      59             :         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_client_device(adap, info);
      65           0 :         if (!i2c_client_has_driver(client)) {
      66             :                 err = -ENODEV;
      67             :                 goto fail_unregister;
      68             :         }
      69             : 
      70           0 :         module = client->dev.driver->owner;
      71           0 :         if (!try_module_get(module)) {
      72             :                 err = -ENODEV;
      73             :                 goto fail_unregister;
      74             :         }
      75             : 
      76           0 :         encoder->bus_priv = client;
      77             : 
      78           0 :         encoder_drv = to_drm_i2c_encoder_driver(to_i2c_driver(client->dev.driver));
      79             : 
      80           0 :         err = encoder_drv->encoder_init(client, dev, encoder);
      81           0 :         if (err)
      82             :                 goto fail_module_put;
      83             : 
      84           0 :         if (info->platform_data)
      85           0 :                 encoder->slave_funcs->set_config(&encoder->base,
      86             :                                                  info->platform_data);
      87             : 
      88             :         return 0;
      89             : 
      90             : fail_module_put:
      91             :         module_put(module);
      92             : fail_unregister:
      93           0 :         i2c_unregister_device(client);
      94           0 :         return err;
      95             : }
      96             : EXPORT_SYMBOL(drm_i2c_encoder_init);
      97             : 
      98             : /**
      99             :  * drm_i2c_encoder_destroy - Unregister the I2C device backing an encoder
     100             :  * @drm_encoder:        Encoder to be unregistered.
     101             :  *
     102             :  * This should be called from the @destroy method of an I2C slave
     103             :  * encoder driver once I2C access is no longer needed.
     104             :  */
     105           0 : void drm_i2c_encoder_destroy(struct drm_encoder *drm_encoder)
     106             : {
     107           0 :         struct drm_encoder_slave *encoder = to_encoder_slave(drm_encoder);
     108           0 :         struct i2c_client *client = drm_i2c_encoder_get_client(drm_encoder);
     109           0 :         struct module *module = client->dev.driver->owner;
     110             : 
     111           0 :         i2c_unregister_device(client);
     112           0 :         encoder->bus_priv = NULL;
     113             : 
     114           0 :         module_put(module);
     115           0 : }
     116             : EXPORT_SYMBOL(drm_i2c_encoder_destroy);
     117             : 
     118             : /*
     119             :  * Wrapper fxns which can be plugged in to drm_encoder_helper_funcs:
     120             :  */
     121             : 
     122             : static inline const struct drm_encoder_slave_funcs *
     123             : get_slave_funcs(struct drm_encoder *enc)
     124             : {
     125           0 :         return to_encoder_slave(enc)->slave_funcs;
     126             : }
     127             : 
     128           0 : void drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode)
     129             : {
     130           0 :         get_slave_funcs(encoder)->dpms(encoder, mode);
     131           0 : }
     132             : EXPORT_SYMBOL(drm_i2c_encoder_dpms);
     133             : 
     134           0 : bool drm_i2c_encoder_mode_fixup(struct drm_encoder *encoder,
     135             :                 const struct drm_display_mode *mode,
     136             :                 struct drm_display_mode *adjusted_mode)
     137             : {
     138           0 :         if (!get_slave_funcs(encoder)->mode_fixup)
     139             :                 return true;
     140             : 
     141           0 :         return get_slave_funcs(encoder)->mode_fixup(encoder, mode, adjusted_mode);
     142             : }
     143             : EXPORT_SYMBOL(drm_i2c_encoder_mode_fixup);
     144             : 
     145           0 : void drm_i2c_encoder_prepare(struct drm_encoder *encoder)
     146             : {
     147           0 :         drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
     148           0 : }
     149             : EXPORT_SYMBOL(drm_i2c_encoder_prepare);
     150             : 
     151           0 : void drm_i2c_encoder_commit(struct drm_encoder *encoder)
     152             : {
     153           0 :         drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
     154           0 : }
     155             : EXPORT_SYMBOL(drm_i2c_encoder_commit);
     156             : 
     157           0 : void drm_i2c_encoder_mode_set(struct drm_encoder *encoder,
     158             :                 struct drm_display_mode *mode,
     159             :                 struct drm_display_mode *adjusted_mode)
     160             : {
     161           0 :         get_slave_funcs(encoder)->mode_set(encoder, mode, adjusted_mode);
     162           0 : }
     163             : EXPORT_SYMBOL(drm_i2c_encoder_mode_set);
     164             : 
     165           0 : enum drm_connector_status drm_i2c_encoder_detect(struct drm_encoder *encoder,
     166             :             struct drm_connector *connector)
     167             : {
     168           0 :         return get_slave_funcs(encoder)->detect(encoder, connector);
     169             : }
     170             : EXPORT_SYMBOL(drm_i2c_encoder_detect);
     171             : 
     172           0 : void drm_i2c_encoder_save(struct drm_encoder *encoder)
     173             : {
     174           0 :         get_slave_funcs(encoder)->save(encoder);
     175           0 : }
     176             : EXPORT_SYMBOL(drm_i2c_encoder_save);
     177             : 
     178           0 : void drm_i2c_encoder_restore(struct drm_encoder *encoder)
     179             : {
     180           0 :         get_slave_funcs(encoder)->restore(encoder);
     181           0 : }
     182             : EXPORT_SYMBOL(drm_i2c_encoder_restore);