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) |
| 24 | |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 25 | /** |
| 26 | * struct mipi_dsi_msg - read/write DSI buffer |
| 27 | * @channel: virtual channel id |
| 28 | * @type: payload data type |
Thierry Reding | 009081e | 2014-08-05 10:41:13 +0200 | [diff] [blame] | 29 | * @flags: flags controlling this message transmission |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 30 | * @tx_len: length of @tx_buf |
| 31 | * @tx_buf: data to be written |
| 32 | * @rx_len: length of @rx_buf |
| 33 | * @rx_buf: data to be read, or NULL |
| 34 | */ |
| 35 | struct mipi_dsi_msg { |
| 36 | u8 channel; |
| 37 | u8 type; |
Andrzej Hajda | 1d96d4a | 2014-03-28 12:52:36 +0100 | [diff] [blame] | 38 | u16 flags; |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 39 | |
| 40 | size_t tx_len; |
| 41 | const void *tx_buf; |
| 42 | |
| 43 | size_t rx_len; |
| 44 | void *rx_buf; |
| 45 | }; |
| 46 | |
Thierry Reding | 02acb76 | 2014-11-04 14:59:14 +0100 | [diff] [blame] | 47 | bool mipi_dsi_packet_format_is_short(u8 type); |
| 48 | bool mipi_dsi_packet_format_is_long(u8 type); |
| 49 | |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 50 | /** |
Thierry Reding | a52879e | 2014-10-16 13:44:02 +0200 | [diff] [blame] | 51 | * struct mipi_dsi_packet - represents a MIPI DSI packet in protocol format |
| 52 | * @size: size (in bytes) of the packet |
| 53 | * @header: the four bytes that make up the header (Data ID, Word Count or |
| 54 | * Packet Data, and ECC) |
| 55 | * @payload_length: number of bytes in the payload |
| 56 | * @payload: a pointer to a buffer containing the payload, if any |
| 57 | */ |
| 58 | struct mipi_dsi_packet { |
| 59 | size_t size; |
| 60 | u8 header[4]; |
| 61 | size_t payload_length; |
| 62 | const u8 *payload; |
| 63 | }; |
| 64 | |
| 65 | int mipi_dsi_create_packet(struct mipi_dsi_packet *packet, |
| 66 | const struct mipi_dsi_msg *msg); |
| 67 | |
| 68 | /** |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 69 | * struct mipi_dsi_host_ops - DSI bus operations |
| 70 | * @attach: attach DSI device to DSI host |
| 71 | * @detach: detach DSI device from DSI host |
Thierry Reding | 009081e | 2014-08-05 10:41:13 +0200 | [diff] [blame] | 72 | * @transfer: transmit a DSI packet |
| 73 | * |
| 74 | * DSI packets transmitted by .transfer() are passed in as mipi_dsi_msg |
| 75 | * structures. This structure contains information about the type of packet |
| 76 | * being transmitted as well as the transmit and receive buffers. When an |
| 77 | * error is encountered during transmission, this function will return a |
| 78 | * negative error code. On success it shall return the number of bytes |
| 79 | * transmitted for write packets or the number of bytes received for read |
| 80 | * packets. |
| 81 | * |
| 82 | * Note that typically DSI packet transmission is atomic, so the .transfer() |
| 83 | * function will seldomly return anything other than the number of bytes |
| 84 | * contained in the transmit buffer on success. |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 85 | */ |
| 86 | struct mipi_dsi_host_ops { |
| 87 | int (*attach)(struct mipi_dsi_host *host, |
| 88 | struct mipi_dsi_device *dsi); |
| 89 | int (*detach)(struct mipi_dsi_host *host, |
| 90 | struct mipi_dsi_device *dsi); |
| 91 | ssize_t (*transfer)(struct mipi_dsi_host *host, |
Thierry Reding | ed6ff40 | 2014-08-05 11:27:56 +0200 | [diff] [blame] | 92 | const struct mipi_dsi_msg *msg); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 93 | }; |
| 94 | |
| 95 | /** |
| 96 | * struct mipi_dsi_host - DSI host device |
| 97 | * @dev: driver model device node for this DSI host |
| 98 | * @ops: DSI host operations |
| 99 | */ |
| 100 | struct mipi_dsi_host { |
| 101 | struct device *dev; |
| 102 | const struct mipi_dsi_host_ops *ops; |
| 103 | }; |
| 104 | |
| 105 | int mipi_dsi_host_register(struct mipi_dsi_host *host); |
| 106 | void mipi_dsi_host_unregister(struct mipi_dsi_host *host); |
| 107 | |
| 108 | /* DSI mode flags */ |
| 109 | |
| 110 | /* video mode */ |
| 111 | #define MIPI_DSI_MODE_VIDEO BIT(0) |
| 112 | /* video burst mode */ |
| 113 | #define MIPI_DSI_MODE_VIDEO_BURST BIT(1) |
| 114 | /* video pulse mode */ |
| 115 | #define MIPI_DSI_MODE_VIDEO_SYNC_PULSE BIT(2) |
| 116 | /* enable auto vertical count mode */ |
| 117 | #define MIPI_DSI_MODE_VIDEO_AUTO_VERT BIT(3) |
| 118 | /* enable hsync-end packets in vsync-pulse and v-porch area */ |
| 119 | #define MIPI_DSI_MODE_VIDEO_HSE BIT(4) |
| 120 | /* disable hfront-porch area */ |
| 121 | #define MIPI_DSI_MODE_VIDEO_HFP BIT(5) |
| 122 | /* disable hback-porch area */ |
| 123 | #define MIPI_DSI_MODE_VIDEO_HBP BIT(6) |
| 124 | /* disable hsync-active area */ |
| 125 | #define MIPI_DSI_MODE_VIDEO_HSA BIT(7) |
| 126 | /* flush display FIFO on vsync pulse */ |
| 127 | #define MIPI_DSI_MODE_VSYNC_FLUSH BIT(8) |
| 128 | /* disable EoT packets in HS mode */ |
| 129 | #define MIPI_DSI_MODE_EOT_PACKET BIT(9) |
Alexandre Courbot | 884d6a0 | 2014-07-08 21:32:11 +0900 | [diff] [blame] | 130 | /* device supports non-continuous clock behavior (DSI spec 5.6.1) */ |
| 131 | #define MIPI_DSI_CLOCK_NON_CONTINUOUS BIT(10) |
Inki Dae | d87f09a | 2014-08-13 16:38:23 +0900 | [diff] [blame] | 132 | /* transmit data in low power */ |
| 133 | #define MIPI_DSI_MODE_LPM BIT(11) |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 134 | |
| 135 | enum mipi_dsi_pixel_format { |
| 136 | MIPI_DSI_FMT_RGB888, |
| 137 | MIPI_DSI_FMT_RGB666, |
| 138 | MIPI_DSI_FMT_RGB666_PACKED, |
| 139 | MIPI_DSI_FMT_RGB565, |
| 140 | }; |
| 141 | |
| 142 | /** |
| 143 | * struct mipi_dsi_device - DSI peripheral device |
| 144 | * @host: DSI host for this peripheral |
| 145 | * @dev: driver model device node for this peripheral |
| 146 | * @channel: virtual channel assigned to the peripheral |
| 147 | * @format: pixel format for video mode |
| 148 | * @lanes: number of active data lanes |
| 149 | * @mode_flags: DSI operation mode related flags |
| 150 | */ |
| 151 | struct mipi_dsi_device { |
| 152 | struct mipi_dsi_host *host; |
| 153 | struct device dev; |
| 154 | |
| 155 | unsigned int channel; |
| 156 | unsigned int lanes; |
| 157 | enum mipi_dsi_pixel_format format; |
| 158 | unsigned long mode_flags; |
| 159 | }; |
| 160 | |
Thierry Reding | 77df01d | 2014-08-05 09:01:32 +0200 | [diff] [blame] | 161 | static inline struct mipi_dsi_device *to_mipi_dsi_device(struct device *dev) |
| 162 | { |
| 163 | return container_of(dev, struct mipi_dsi_device, dev); |
| 164 | } |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 165 | |
Liu Ying | ec26d9e | 2015-11-20 16:15:30 +0800 | [diff] [blame] | 166 | /** |
| 167 | * mipi_dsi_pixel_format_to_bpp - obtain the number of bits per pixel for any |
| 168 | * given pixel format defined by the MIPI DSI |
| 169 | * specification |
| 170 | * @fmt: MIPI DSI pixel format |
| 171 | * |
| 172 | * Returns: The number of bits per pixel of the given pixel format. |
| 173 | */ |
| 174 | static inline int mipi_dsi_pixel_format_to_bpp(enum mipi_dsi_pixel_format fmt) |
| 175 | { |
| 176 | switch (fmt) { |
| 177 | case MIPI_DSI_FMT_RGB888: |
| 178 | case MIPI_DSI_FMT_RGB666: |
| 179 | return 24; |
| 180 | |
| 181 | case MIPI_DSI_FMT_RGB666_PACKED: |
| 182 | return 18; |
| 183 | |
| 184 | case MIPI_DSI_FMT_RGB565: |
| 185 | return 16; |
| 186 | } |
| 187 | |
| 188 | return -EINVAL; |
| 189 | } |
| 190 | |
Thierry Reding | 3ef0592 | 2014-08-06 08:53:39 +0200 | [diff] [blame] | 191 | 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] | 192 | int mipi_dsi_attach(struct mipi_dsi_device *dsi); |
| 193 | int mipi_dsi_detach(struct mipi_dsi_device *dsi); |
Werner Johansson | 6e8c9e3 | 2015-10-30 17:38:26 -0700 | [diff] [blame] | 194 | int mipi_dsi_shutdown_peripheral(struct mipi_dsi_device *dsi); |
| 195 | int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi); |
YoungJun Cho | dbf30b6 | 2014-08-05 09:27:15 +0200 | [diff] [blame] | 196 | int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi, |
| 197 | u16 value); |
Thierry Reding | 550ab84 | 2014-08-05 10:36:21 +0200 | [diff] [blame] | 198 | |
| 199 | ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload, |
| 200 | size_t size); |
| 201 | ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params, |
| 202 | size_t num_params, void *data, size_t size); |
| 203 | |
YoungJun Cho | 42fe1e7 | 2014-08-05 10:38:31 +0200 | [diff] [blame] | 204 | /** |
| 205 | * enum mipi_dsi_dcs_tear_mode - Tearing Effect Output Line mode |
| 206 | * @MIPI_DSI_DCS_TEAR_MODE_VBLANK: the TE output line consists of V-Blanking |
| 207 | * information only |
| 208 | * @MIPI_DSI_DCS_TEAR_MODE_VHBLANK : the TE output line consists of both |
| 209 | * V-Blanking and H-Blanking information |
| 210 | */ |
| 211 | enum mipi_dsi_dcs_tear_mode { |
| 212 | MIPI_DSI_DCS_TEAR_MODE_VBLANK, |
| 213 | MIPI_DSI_DCS_TEAR_MODE_VHBLANK, |
| 214 | }; |
| 215 | |
Thierry Reding | 3d9a8fc | 2014-08-05 11:17:06 +0200 | [diff] [blame] | 216 | #define MIPI_DSI_DCS_POWER_MODE_DISPLAY (1 << 2) |
| 217 | #define MIPI_DSI_DCS_POWER_MODE_NORMAL (1 << 3) |
| 218 | #define MIPI_DSI_DCS_POWER_MODE_SLEEP (1 << 4) |
| 219 | #define MIPI_DSI_DCS_POWER_MODE_PARTIAL (1 << 5) |
| 220 | #define MIPI_DSI_DCS_POWER_MODE_IDLE (1 << 6) |
| 221 | |
Thierry Reding | 960dd61 | 2014-07-21 15:47:10 +0200 | [diff] [blame] | 222 | ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi, |
| 223 | const void *data, size_t len); |
| 224 | ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd, |
| 225 | const void *data, size_t len); |
Thierry Reding | 3c523d7 | 2014-07-21 12:28:25 +0200 | [diff] [blame] | 226 | ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data, |
| 227 | size_t len); |
Thierry Reding | 083d573 | 2014-08-05 11:14:02 +0200 | [diff] [blame] | 228 | int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi); |
Thierry Reding | 2f16b89 | 2014-08-05 11:15:15 +0200 | [diff] [blame] | 229 | int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi); |
Thierry Reding | 3d9a8fc | 2014-08-05 11:17:06 +0200 | [diff] [blame] | 230 | 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] | 231 | 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] | 232 | int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi); |
| 233 | int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi); |
| 234 | int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi); |
| 235 | int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi); |
Thierry Reding | 3b46d4a | 2014-08-05 11:20:25 +0200 | [diff] [blame] | 236 | int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start, |
| 237 | u16 end); |
| 238 | int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start, |
| 239 | u16 end); |
YoungJun Cho | 42fe1e7 | 2014-08-05 10:38:31 +0200 | [diff] [blame] | 240 | int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi); |
| 241 | int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi, |
| 242 | enum mipi_dsi_dcs_tear_mode mode); |
Thierry Reding | 5cc0af1 | 2014-08-05 11:18:46 +0200 | [diff] [blame] | 243 | int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 244 | |
| 245 | /** |
| 246 | * struct mipi_dsi_driver - DSI driver |
| 247 | * @driver: device driver model driver |
| 248 | * @probe: callback for device binding |
| 249 | * @remove: callback for device unbinding |
Thierry Reding | d1621803 | 2014-04-29 17:19:57 +0200 | [diff] [blame] | 250 | * @shutdown: called at shutdown time to quiesce the device |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 251 | */ |
| 252 | struct mipi_dsi_driver { |
| 253 | struct device_driver driver; |
| 254 | int(*probe)(struct mipi_dsi_device *dsi); |
| 255 | int(*remove)(struct mipi_dsi_device *dsi); |
Thierry Reding | d1621803 | 2014-04-29 17:19:57 +0200 | [diff] [blame] | 256 | void (*shutdown)(struct mipi_dsi_device *dsi); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 257 | }; |
| 258 | |
Thierry Reding | 77df01d | 2014-08-05 09:01:32 +0200 | [diff] [blame] | 259 | static inline struct mipi_dsi_driver * |
| 260 | to_mipi_dsi_driver(struct device_driver *driver) |
| 261 | { |
| 262 | return container_of(driver, struct mipi_dsi_driver, driver); |
| 263 | } |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 264 | |
| 265 | static inline void *mipi_dsi_get_drvdata(const struct mipi_dsi_device *dsi) |
| 266 | { |
| 267 | return dev_get_drvdata(&dsi->dev); |
| 268 | } |
| 269 | |
| 270 | static inline void mipi_dsi_set_drvdata(struct mipi_dsi_device *dsi, void *data) |
| 271 | { |
| 272 | dev_set_drvdata(&dsi->dev, data); |
| 273 | } |
| 274 | |
Thierry Reding | 99035e9 | 2014-11-04 16:09:56 +0100 | [diff] [blame] | 275 | int mipi_dsi_driver_register_full(struct mipi_dsi_driver *driver, |
| 276 | struct module *owner); |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 277 | void mipi_dsi_driver_unregister(struct mipi_dsi_driver *driver); |
| 278 | |
Thierry Reding | 99035e9 | 2014-11-04 16:09:56 +0100 | [diff] [blame] | 279 | #define mipi_dsi_driver_register(driver) \ |
| 280 | mipi_dsi_driver_register_full(driver, THIS_MODULE) |
| 281 | |
Andrzej Hajda | 068a002 | 2013-12-04 16:35:12 +0100 | [diff] [blame] | 282 | #define module_mipi_dsi_driver(__mipi_dsi_driver) \ |
| 283 | module_driver(__mipi_dsi_driver, mipi_dsi_driver_register, \ |
| 284 | mipi_dsi_driver_unregister) |
| 285 | |
| 286 | #endif /* __DRM_MIPI_DSI__ */ |