Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 1 | /* |
| 2 | * MIPI DSI Bus |
| 3 | * |
| 4 | * Copyright (C) 2012-2013, Samsung Electronics, Co., Ltd. |
| 5 | * Andrzej Hajda <a.hajda@samsung.com> |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License version 2 as |
| 9 | * published by the Free Software Foundation. |
| 10 | */ |
| 11 | |
| 12 | #ifndef __DRM_MIPI_DSI_H__ |
| 13 | #define __DRM_MIPI_DSI_H__ |
| 14 | |
| 15 | #include <linux/device.h> |
| 16 | |
| 17 | struct mipi_dsi_host; |
| 18 | struct mipi_dsi_device; |
| 19 | |
Andrzej Hajda | 1d96d4a | 2014-03-28 12:52:36 +0100 | [diff] [blame] | 20 | /* request ACK from peripheral */ |
| 21 | #define MIPI_DSI_MSG_REQ_ACK BIT(0) |
| 22 | /* use Low Power Mode to transmit message */ |
| 23 | #define MIPI_DSI_MSG_USE_LPM BIT(1) |
Lloyd Atkinson | 1fde228 | 2017-02-02 16:30:00 -0500 | [diff] [blame] | 24 | /* read mipi_dsi_msg.ctrl and unicast to only that ctrls */ |
| 25 | #define MIPI_DSI_MSG_UNICAST BIT(2) |
Vara Reddy | 326612b | 2017-09-20 04:41:10 -0700 | [diff] [blame] | 26 | /* Stack all commands until lastcommand bit and trigger all in one go */ |
| 27 | #define MIPI_DSI_MSG_LASTCOMMAND BIT(3) |
Andrzej Hajda | 1d96d4a | 2014-03-28 12:52:36 +0100 | [diff] [blame] | 28 | |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 29 | /** |
| 30 | * struct mipi_dsi_msg - read/write DSI buffer |
| 31 | * @channel: virtual channel id |
| 32 | * @type: payload data type |
Thierry Reding | 009081e | 2014-08-05 10:41:13 +0200 | [diff] [blame] | 33 | * @flags: flags controlling this message transmission |
Lloyd Atkinson | 1fde228 | 2017-02-02 16:30:00 -0500 | [diff] [blame] | 34 | * @ctrl: ctrl index to transmit on |
Sandeep Panda | ae2b028 | 2018-05-09 15:39:39 +0530 | [diff] [blame^] | 35 | * @wait_ms: duration in ms to wait after message transmission |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 36 | * @tx_len: length of @tx_buf |
| 37 | * @tx_buf: data to be written |
| 38 | * @rx_len: length of @rx_buf |
| 39 | * @rx_buf: data to be read, or NULL |
| 40 | */ |
| 41 | struct mipi_dsi_msg { |
| 42 | u8 channel; |
| 43 | u8 type; |
Andrzej Hajda | 1d96d4a | 2014-03-28 12:52:36 +0100 | [diff] [blame] | 44 | u16 flags; |
Lloyd Atkinson | 1fde228 | 2017-02-02 16:30:00 -0500 | [diff] [blame] | 45 | u32 ctrl; |
Sandeep Panda | ae2b028 | 2018-05-09 15:39:39 +0530 | [diff] [blame^] | 46 | u32 wait_ms; |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 47 | |
| 48 | size_t tx_len; |
| 49 | const void *tx_buf; |
| 50 | |
| 51 | size_t rx_len; |
| 52 | void *rx_buf; |
| 53 | }; |
| 54 | |
Thierry Reding | 02acb76 | 2014-11-04 14:59:14 +0100 | [diff] [blame] | 55 | bool mipi_dsi_packet_format_is_short(u8 type); |
| 56 | bool mipi_dsi_packet_format_is_long(u8 type); |
| 57 | |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 58 | /** |
Thierry Reding | a52879e | 2014-10-16 13:44:02 +0200 | [diff] [blame] | 59 | * struct mipi_dsi_packet - represents a MIPI DSI packet in protocol format |
| 60 | * @size: size (in bytes) of the packet |
| 61 | * @header: the four bytes that make up the header (Data ID, Word Count or |
| 62 | * Packet Data, and ECC) |
| 63 | * @payload_length: number of bytes in the payload |
| 64 | * @payload: a pointer to a buffer containing the payload, if any |
| 65 | */ |
| 66 | struct mipi_dsi_packet { |
| 67 | size_t size; |
| 68 | u8 header[4]; |
| 69 | size_t payload_length; |
| 70 | const u8 *payload; |
| 71 | }; |
| 72 | |
| 73 | int mipi_dsi_create_packet(struct mipi_dsi_packet *packet, |
| 74 | const struct mipi_dsi_msg *msg); |
| 75 | |
| 76 | /** |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 77 | * struct mipi_dsi_host_ops - DSI bus operations |
| 78 | * @attach: attach DSI device to DSI host |
| 79 | * @detach: detach DSI device from DSI host |
Thierry Reding | 009081e | 2014-08-05 10:41:13 +0200 | [diff] [blame] | 80 | * @transfer: transmit a DSI packet |
| 81 | * |
| 82 | * DSI packets transmitted by .transfer() are passed in as mipi_dsi_msg |
| 83 | * structures. This structure contains information about the type of packet |
| 84 | * being transmitted as well as the transmit and receive buffers. When an |
| 85 | * error is encountered during transmission, this function will return a |
| 86 | * negative error code. On success it shall return the number of bytes |
| 87 | * transmitted for write packets or the number of bytes received for read |
| 88 | * packets. |
| 89 | * |
| 90 | * Note that typically DSI packet transmission is atomic, so the .transfer() |
| 91 | * function will seldomly return anything other than the number of bytes |
| 92 | * contained in the transmit buffer on success. |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 93 | */ |
| 94 | struct mipi_dsi_host_ops { |
| 95 | int (*attach)(struct mipi_dsi_host *host, |
| 96 | struct mipi_dsi_device *dsi); |
| 97 | int (*detach)(struct mipi_dsi_host *host, |
| 98 | struct mipi_dsi_device *dsi); |
| 99 | ssize_t (*transfer)(struct mipi_dsi_host *host, |
Thierry Reding | ed6ff40 | 2014-08-05 11:27:56 +0200 | [diff] [blame] | 100 | const struct mipi_dsi_msg *msg); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 101 | }; |
| 102 | |
| 103 | /** |
| 104 | * struct mipi_dsi_host - DSI host device |
| 105 | * @dev: driver model device node for this DSI host |
| 106 | * @ops: DSI host operations |
Archit Taneja | 97b6ae5 | 2016-02-12 14:48:34 +0530 | [diff] [blame] | 107 | * @list: list management |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 108 | */ |
| 109 | struct mipi_dsi_host { |
| 110 | struct device *dev; |
| 111 | const struct mipi_dsi_host_ops *ops; |
Archit Taneja | 97b6ae5 | 2016-02-12 14:48:34 +0530 | [diff] [blame] | 112 | struct list_head list; |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 113 | }; |
| 114 | |
| 115 | int mipi_dsi_host_register(struct mipi_dsi_host *host); |
| 116 | void mipi_dsi_host_unregister(struct mipi_dsi_host *host); |
Archit Taneja | 97b6ae5 | 2016-02-12 14:48:34 +0530 | [diff] [blame] | 117 | struct mipi_dsi_host *of_find_mipi_dsi_host_by_node(struct device_node *node); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 118 | |
| 119 | /* DSI mode flags */ |
| 120 | |
| 121 | /* video mode */ |
| 122 | #define MIPI_DSI_MODE_VIDEO BIT(0) |
| 123 | /* video burst mode */ |
| 124 | #define MIPI_DSI_MODE_VIDEO_BURST BIT(1) |
| 125 | /* video pulse mode */ |
| 126 | #define MIPI_DSI_MODE_VIDEO_SYNC_PULSE BIT(2) |
| 127 | /* enable auto vertical count mode */ |
| 128 | #define MIPI_DSI_MODE_VIDEO_AUTO_VERT BIT(3) |
| 129 | /* enable hsync-end packets in vsync-pulse and v-porch area */ |
| 130 | #define MIPI_DSI_MODE_VIDEO_HSE BIT(4) |
| 131 | /* disable hfront-porch area */ |
| 132 | #define MIPI_DSI_MODE_VIDEO_HFP BIT(5) |
| 133 | /* disable hback-porch area */ |
| 134 | #define MIPI_DSI_MODE_VIDEO_HBP BIT(6) |
| 135 | /* disable hsync-active area */ |
| 136 | #define MIPI_DSI_MODE_VIDEO_HSA BIT(7) |
| 137 | /* flush display FIFO on vsync pulse */ |
| 138 | #define MIPI_DSI_MODE_VSYNC_FLUSH BIT(8) |
| 139 | /* disable EoT packets in HS mode */ |
| 140 | #define MIPI_DSI_MODE_EOT_PACKET BIT(9) |
Alexandre Courbot | 884d6a0 | 2014-07-08 21:32:11 +0900 | [diff] [blame] | 141 | /* device supports non-continuous clock behavior (DSI spec 5.6.1) */ |
| 142 | #define MIPI_DSI_CLOCK_NON_CONTINUOUS BIT(10) |
Inki Dae | d87f09a | 2014-08-13 16:38:23 +0900 | [diff] [blame] | 143 | /* transmit data in low power */ |
| 144 | #define MIPI_DSI_MODE_LPM BIT(11) |
Ray Zhang | c05fa3d | 2018-01-22 10:00:02 +0800 | [diff] [blame] | 145 | /* disable BLLP area */ |
| 146 | #define MIPI_DSI_MODE_VIDEO_BLLP BIT(12) |
| 147 | /* disable EOF BLLP area */ |
| 148 | #define MIPI_DSI_MODE_VIDEO_EOF_BLLP BIT(13) |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 149 | |
| 150 | enum mipi_dsi_pixel_format { |
| 151 | MIPI_DSI_FMT_RGB888, |
| 152 | MIPI_DSI_FMT_RGB666, |
| 153 | MIPI_DSI_FMT_RGB666_PACKED, |
| 154 | MIPI_DSI_FMT_RGB565, |
| 155 | }; |
| 156 | |
Archit Taneja | bf4363c | 2016-02-12 14:48:32 +0530 | [diff] [blame] | 157 | #define DSI_DEV_NAME_SIZE 20 |
| 158 | |
| 159 | /** |
Archit Taneja | c63ae8a | 2016-02-12 14:48:31 +0530 | [diff] [blame] | 160 | * struct mipi_dsi_device_info - template for creating a mipi_dsi_device |
Archit Taneja | bf4363c | 2016-02-12 14:48:32 +0530 | [diff] [blame] | 161 | * @type: DSI peripheral chip type |
Archit Taneja | c63ae8a | 2016-02-12 14:48:31 +0530 | [diff] [blame] | 162 | * @channel: DSI virtual channel assigned to peripheral |
Archit Taneja | bf4363c | 2016-02-12 14:48:32 +0530 | [diff] [blame] | 163 | * @node: pointer to OF device node or NULL |
Archit Taneja | c63ae8a | 2016-02-12 14:48:31 +0530 | [diff] [blame] | 164 | * |
| 165 | * This is populated and passed to mipi_dsi_device_new to create a new |
| 166 | * DSI device |
| 167 | */ |
| 168 | struct mipi_dsi_device_info { |
Archit Taneja | bf4363c | 2016-02-12 14:48:32 +0530 | [diff] [blame] | 169 | char type[DSI_DEV_NAME_SIZE]; |
Archit Taneja | c63ae8a | 2016-02-12 14:48:31 +0530 | [diff] [blame] | 170 | u32 channel; |
| 171 | struct device_node *node; |
| 172 | }; |
| 173 | |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 174 | /** |
| 175 | * struct mipi_dsi_device - DSI peripheral device |
| 176 | * @host: DSI host for this peripheral |
| 177 | * @dev: driver model device node for this peripheral |
Archit Taneja | bf4363c | 2016-02-12 14:48:32 +0530 | [diff] [blame] | 178 | * @name: DSI peripheral chip type |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 179 | * @channel: virtual channel assigned to the peripheral |
| 180 | * @format: pixel format for video mode |
| 181 | * @lanes: number of active data lanes |
| 182 | * @mode_flags: DSI operation mode related flags |
| 183 | */ |
| 184 | struct mipi_dsi_device { |
| 185 | struct mipi_dsi_host *host; |
| 186 | struct device dev; |
| 187 | |
Archit Taneja | bf4363c | 2016-02-12 14:48:32 +0530 | [diff] [blame] | 188 | char name[DSI_DEV_NAME_SIZE]; |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 189 | unsigned int channel; |
| 190 | unsigned int lanes; |
| 191 | enum mipi_dsi_pixel_format format; |
| 192 | unsigned long mode_flags; |
| 193 | }; |
| 194 | |
Thierry Reding | babb24f | 2016-06-03 14:23:00 +0200 | [diff] [blame] | 195 | #define MIPI_DSI_MODULE_PREFIX "mipi-dsi:" |
| 196 | |
Thierry Reding | 77df01d | 2014-08-05 09:01:32 +0200 | [diff] [blame] | 197 | static inline struct mipi_dsi_device *to_mipi_dsi_device(struct device *dev) |
| 198 | { |
| 199 | return container_of(dev, struct mipi_dsi_device, dev); |
| 200 | } |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 201 | |
Liu Ying | ec26d9e | 2015-11-20 16:15:30 +0800 | [diff] [blame] | 202 | /** |
| 203 | * mipi_dsi_pixel_format_to_bpp - obtain the number of bits per pixel for any |
| 204 | * given pixel format defined by the MIPI DSI |
| 205 | * specification |
| 206 | * @fmt: MIPI DSI pixel format |
| 207 | * |
| 208 | * Returns: The number of bits per pixel of the given pixel format. |
| 209 | */ |
| 210 | static inline int mipi_dsi_pixel_format_to_bpp(enum mipi_dsi_pixel_format fmt) |
| 211 | { |
| 212 | switch (fmt) { |
| 213 | case MIPI_DSI_FMT_RGB888: |
| 214 | case MIPI_DSI_FMT_RGB666: |
| 215 | return 24; |
| 216 | |
| 217 | case MIPI_DSI_FMT_RGB666_PACKED: |
| 218 | return 18; |
| 219 | |
| 220 | case MIPI_DSI_FMT_RGB565: |
| 221 | return 16; |
| 222 | } |
| 223 | |
| 224 | return -EINVAL; |
| 225 | } |
| 226 | |
Archit Taneja | c63ae8a | 2016-02-12 14:48:31 +0530 | [diff] [blame] | 227 | struct mipi_dsi_device * |
| 228 | mipi_dsi_device_register_full(struct mipi_dsi_host *host, |
| 229 | const struct mipi_dsi_device_info *info); |
Archit Taneja | 509e42c | 2016-02-12 14:48:33 +0530 | [diff] [blame] | 230 | void mipi_dsi_device_unregister(struct mipi_dsi_device *dsi); |
Thierry Reding | 3ef0592 | 2014-08-06 08:53:39 +0200 | [diff] [blame] | 231 | struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 232 | int mipi_dsi_attach(struct mipi_dsi_device *dsi); |
| 233 | int mipi_dsi_detach(struct mipi_dsi_device *dsi); |
Werner Johansson | 6e8c9e3 | 2015-10-30 17:38:26 -0700 | [diff] [blame] | 234 | int mipi_dsi_shutdown_peripheral(struct mipi_dsi_device *dsi); |
| 235 | int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi); |
YoungJun Cho | dbf30b6 | 2014-08-05 09:27:15 +0200 | [diff] [blame] | 236 | int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi, |
| 237 | u16 value); |
Thierry Reding | 550ab84 | 2014-08-05 10:36:21 +0200 | [diff] [blame] | 238 | |
| 239 | ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload, |
| 240 | size_t size); |
| 241 | ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params, |
| 242 | size_t num_params, void *data, size_t size); |
| 243 | |
YoungJun Cho | 42fe1e7 | 2014-08-05 10:38:31 +0200 | [diff] [blame] | 244 | /** |
| 245 | * enum mipi_dsi_dcs_tear_mode - Tearing Effect Output Line mode |
| 246 | * @MIPI_DSI_DCS_TEAR_MODE_VBLANK: the TE output line consists of V-Blanking |
| 247 | * information only |
| 248 | * @MIPI_DSI_DCS_TEAR_MODE_VHBLANK : the TE output line consists of both |
| 249 | * V-Blanking and H-Blanking information |
| 250 | */ |
| 251 | enum mipi_dsi_dcs_tear_mode { |
| 252 | MIPI_DSI_DCS_TEAR_MODE_VBLANK, |
| 253 | MIPI_DSI_DCS_TEAR_MODE_VHBLANK, |
| 254 | }; |
| 255 | |
Thierry Reding | 3d9a8fc | 2014-08-05 11:17:06 +0200 | [diff] [blame] | 256 | #define MIPI_DSI_DCS_POWER_MODE_DISPLAY (1 << 2) |
| 257 | #define MIPI_DSI_DCS_POWER_MODE_NORMAL (1 << 3) |
| 258 | #define MIPI_DSI_DCS_POWER_MODE_SLEEP (1 << 4) |
| 259 | #define MIPI_DSI_DCS_POWER_MODE_PARTIAL (1 << 5) |
| 260 | #define MIPI_DSI_DCS_POWER_MODE_IDLE (1 << 6) |
| 261 | |
Thierry Reding | 960dd61 | 2014-07-21 15:47:10 +0200 | [diff] [blame] | 262 | ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi, |
| 263 | const void *data, size_t len); |
| 264 | ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd, |
| 265 | const void *data, size_t len); |
Thierry Reding | 3c523d7 | 2014-07-21 12:28:25 +0200 | [diff] [blame] | 266 | ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data, |
| 267 | size_t len); |
Thierry Reding | 083d573 | 2014-08-05 11:14:02 +0200 | [diff] [blame] | 268 | int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi); |
Thierry Reding | 2f16b89 | 2014-08-05 11:15:15 +0200 | [diff] [blame] | 269 | int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi); |
Thierry Reding | 3d9a8fc | 2014-08-05 11:17:06 +0200 | [diff] [blame] | 270 | int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode); |
Thierry Reding | 5cc0af1 | 2014-08-05 11:18:46 +0200 | [diff] [blame] | 271 | int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format); |
YoungJun Cho | 42fe1e7 | 2014-08-05 10:38:31 +0200 | [diff] [blame] | 272 | int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi); |
| 273 | int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi); |
| 274 | int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi); |
| 275 | int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi); |
Thierry Reding | 3b46d4a | 2014-08-05 11:20:25 +0200 | [diff] [blame] | 276 | int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start, |
| 277 | u16 end); |
| 278 | int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start, |
| 279 | u16 end); |
YoungJun Cho | 42fe1e7 | 2014-08-05 10:38:31 +0200 | [diff] [blame] | 280 | int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi); |
| 281 | int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi, |
| 282 | enum mipi_dsi_dcs_tear_mode mode); |
Thierry Reding | 5cc0af1 | 2014-08-05 11:18:46 +0200 | [diff] [blame] | 283 | int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format); |
Thierry Reding | bbdcf51 | 2016-08-24 13:28:39 +0200 | [diff] [blame] | 284 | int mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device *dsi, u16 scanline); |
Vinay Simha BN | 1a9d759 | 2016-07-31 20:45:22 +0530 | [diff] [blame] | 285 | int mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device *dsi, |
| 286 | u16 brightness); |
| 287 | int mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device *dsi, |
| 288 | u16 *brightness); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 289 | |
| 290 | /** |
| 291 | * struct mipi_dsi_driver - DSI driver |
| 292 | * @driver: device driver model driver |
| 293 | * @probe: callback for device binding |
| 294 | * @remove: callback for device unbinding |
Thierry Reding | d1621803 | 2014-04-29 17:19:57 +0200 | [diff] [blame] | 295 | * @shutdown: called at shutdown time to quiesce the device |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 296 | */ |
| 297 | struct mipi_dsi_driver { |
| 298 | struct device_driver driver; |
| 299 | int(*probe)(struct mipi_dsi_device *dsi); |
| 300 | int(*remove)(struct mipi_dsi_device *dsi); |
Thierry Reding | d1621803 | 2014-04-29 17:19:57 +0200 | [diff] [blame] | 301 | void (*shutdown)(struct mipi_dsi_device *dsi); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 302 | }; |
| 303 | |
Thierry Reding | 77df01d | 2014-08-05 09:01:32 +0200 | [diff] [blame] | 304 | static inline struct mipi_dsi_driver * |
| 305 | to_mipi_dsi_driver(struct device_driver *driver) |
| 306 | { |
| 307 | return container_of(driver, struct mipi_dsi_driver, driver); |
| 308 | } |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 309 | |
| 310 | static inline void *mipi_dsi_get_drvdata(const struct mipi_dsi_device *dsi) |
| 311 | { |
| 312 | return dev_get_drvdata(&dsi->dev); |
| 313 | } |
| 314 | |
| 315 | static inline void mipi_dsi_set_drvdata(struct mipi_dsi_device *dsi, void *data) |
| 316 | { |
| 317 | dev_set_drvdata(&dsi->dev, data); |
| 318 | } |
| 319 | |
Thierry Reding | 99035e9 | 2014-11-04 16:09:56 +0100 | [diff] [blame] | 320 | int mipi_dsi_driver_register_full(struct mipi_dsi_driver *driver, |
| 321 | struct module *owner); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 322 | void mipi_dsi_driver_unregister(struct mipi_dsi_driver *driver); |
| 323 | |
Thierry Reding | 99035e9 | 2014-11-04 16:09:56 +0100 | [diff] [blame] | 324 | #define mipi_dsi_driver_register(driver) \ |
| 325 | mipi_dsi_driver_register_full(driver, THIS_MODULE) |
| 326 | |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 327 | #define module_mipi_dsi_driver(__mipi_dsi_driver) \ |
| 328 | module_driver(__mipi_dsi_driver, mipi_dsi_driver_register, \ |
| 329 | mipi_dsi_driver_unregister) |
| 330 | |
| 331 | #endif /* __DRM_MIPI_DSI__ */ |