1 /* 2 * Copyright (C) 2013, NVIDIA Corporation. All rights reserved. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sub license, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the 12 * next paragraph) shall be included in all copies or substantial portions 13 * of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 #ifndef __DRM_PANEL_H__ 25 #define __DRM_PANEL_H__ 26 27 #include <linux/err.h> 28 #include <linux/errno.h> 29 #include <linux/list.h> 30 31 struct backlight_device; 32 struct device_node; 33 struct drm_connector; 34 struct drm_device; 35 struct drm_panel; 36 struct display_timing; 37 38 enum drm_panel_orientation; 39 40 /** 41 * struct drm_panel_funcs - perform operations on a given panel 42 * 43 * The .prepare() function is typically called before the display controller 44 * starts to transmit video data. Panel drivers can use this to turn the panel 45 * on and wait for it to become ready. If additional configuration is required 46 * (via a control bus such as I2C, SPI or DSI for example) this is a good time 47 * to do that. 48 * 49 * After the display controller has started transmitting video data, it's safe 50 * to call the .enable() function. This will typically enable the backlight to 51 * make the image on screen visible. Some panels require a certain amount of 52 * time or frames before the image is displayed. This function is responsible 53 * for taking this into account before enabling the backlight to avoid visual 54 * glitches. 55 * 56 * Before stopping video transmission from the display controller it can be 57 * necessary to turn off the panel to avoid visual glitches. This is done in 58 * the .disable() function. Analogously to .enable() this typically involves 59 * turning off the backlight and waiting for some time to make sure no image 60 * is visible on the panel. It is then safe for the display controller to 61 * cease transmission of video data. 62 * 63 * To save power when no video data is transmitted, a driver can power down 64 * the panel. This is the job of the .unprepare() function. 65 * 66 * Backlight can be handled automatically if configured using 67 * drm_panel_of_backlight(). Then the driver does not need to implement the 68 * functionality to enable/disable backlight. 69 */ 70 struct drm_panel_funcs { 71 /** 72 * @prepare: 73 * 74 * Turn on panel and perform set up. 75 * 76 * This function is optional. 77 */ 78 int (*prepare)(struct drm_panel *panel); 79 80 /** 81 * @enable: 82 * 83 * Enable panel (turn on back light, etc.). 84 * 85 * This function is optional. 86 */ 87 int (*enable)(struct drm_panel *panel); 88 89 /** 90 * @disable: 91 * 92 * Disable panel (turn off back light, etc.). 93 * 94 * This function is optional. 95 */ 96 int (*disable)(struct drm_panel *panel); 97 98 /** 99 * @unprepare: 100 * 101 * Turn off panel. 102 * 103 * This function is optional. 104 */ 105 int (*unprepare)(struct drm_panel *panel); 106 107 /** 108 * @get_modes: 109 * 110 * Add modes to the connector that the panel is attached to 111 * and returns the number of modes added. 112 * 113 * This function is mandatory. 114 */ 115 int (*get_modes)(struct drm_panel *panel, 116 struct drm_connector *connector); 117 118 /** 119 * @get_timings: 120 * 121 * Copy display timings into the provided array and return 122 * the number of display timings available. 123 * 124 * This function is optional. 125 */ 126 int (*get_timings)(struct drm_panel *panel, unsigned int num_timings, 127 struct display_timing *timings); 128 }; 129 130 /** 131 * struct drm_panel - DRM panel object 132 */ 133 struct drm_panel { 134 /** 135 * @dev: 136 * 137 * Parent device of the panel. 138 */ 139 struct device *dev; 140 141 /** 142 * @backlight: 143 * 144 * Backlight device, used to turn on backlight after the call 145 * to enable(), and to turn off backlight before the call to 146 * disable(). 147 * backlight is set by drm_panel_of_backlight() and drivers 148 * shall not assign it. 149 */ 150 struct backlight_device *backlight; 151 152 /** 153 * @funcs: 154 * 155 * Operations that can be performed on the panel. 156 */ 157 const struct drm_panel_funcs *funcs; 158 159 /** 160 * @connector_type: 161 * 162 * Type of the panel as a DRM_MODE_CONNECTOR_* value. This is used to 163 * initialise the drm_connector corresponding to the panel with the 164 * correct connector type. 165 */ 166 int connector_type; 167 168 /** 169 * @list: 170 * 171 * Panel entry in registry. 172 */ 173 struct list_head list; 174 }; 175 176 void drm_panel_init(struct drm_panel *panel, struct device *dev, 177 const struct drm_panel_funcs *funcs, 178 int connector_type); 179 180 void drm_panel_add(struct drm_panel *panel); 181 void drm_panel_remove(struct drm_panel *panel); 182 183 int drm_panel_prepare(struct drm_panel *panel); 184 int drm_panel_unprepare(struct drm_panel *panel); 185 186 int drm_panel_enable(struct drm_panel *panel); 187 int drm_panel_disable(struct drm_panel *panel); 188 189 int drm_panel_get_modes(struct drm_panel *panel, struct drm_connector *connector); 190 191 #if defined(CONFIG_OF) && defined(CONFIG_DRM_PANEL) 192 struct drm_panel *of_drm_find_panel(const struct device_node *np); 193 int of_drm_get_panel_orientation(const struct device_node *np, 194 enum drm_panel_orientation *orientation); 195 #else 196 static inline struct drm_panel *of_drm_find_panel(const struct device_node *np) 197 { 198 return ERR_PTR(-ENODEV); 199 } 200 201 static inline int of_drm_get_panel_orientation(const struct device_node *np, 202 enum drm_panel_orientation *orientation) 203 { 204 return -ENODEV; 205 } 206 #endif 207 208 #if IS_ENABLED(CONFIG_DRM_PANEL) && (IS_BUILTIN(CONFIG_BACKLIGHT_CLASS_DEVICE) || \ 209 (IS_MODULE(CONFIG_DRM) && IS_MODULE(CONFIG_BACKLIGHT_CLASS_DEVICE))) 210 int drm_panel_of_backlight(struct drm_panel *panel); 211 #else 212 static inline int drm_panel_of_backlight(struct drm_panel *panel) 213 { 214 return 0; 215 } 216 #endif 217 218 #endif 219