← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to include/video/omapdss.h

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/video/omapdss.h
 
1
/*
 
2
 * Copyright (C) 2008 Nokia Corporation
 
3
 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify it
 
6
 * under the terms of the GNU General Public License version 2 as published by
 
7
 * the Free Software Foundation.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful, but WITHOUT
 
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 
12
 * more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License along with
 
15
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 
16
 */
 
17
 
 
18
#ifndef __OMAP_OMAPDSS_H
 
19
#define __OMAP_OMAPDSS_H
 
20
 
 
21
#include <linux/list.h>
 
22
#include <linux/kobject.h>
 
23
#include <linux/device.h>
 
24
#include <linux/notifier.h>
 
25
#include <linux/platform_device.h>
 
26
#include <asm/atomic.h>
 
27
 
 
28
#define DISPC_IRQ_FRAMEDONE             (1 << 0)
 
29
#define DISPC_IRQ_VSYNC                 (1 << 1)
 
30
#define DISPC_IRQ_EVSYNC_EVEN           (1 << 2)
 
31
#define DISPC_IRQ_EVSYNC_ODD            (1 << 3)
 
32
#define DISPC_IRQ_ACBIAS_COUNT_STAT     (1 << 4)
 
33
#define DISPC_IRQ_PROG_LINE_NUM         (1 << 5)
 
34
#define DISPC_IRQ_GFX_FIFO_UNDERFLOW    (1 << 6)
 
35
#define DISPC_IRQ_GFX_END_WIN           (1 << 7)
 
36
#define DISPC_IRQ_PAL_GAMMA_MASK        (1 << 8)
 
37
#define DISPC_IRQ_OCP_ERR               (1 << 9)
 
38
#define DISPC_IRQ_VID1_FIFO_UNDERFLOW   (1 << 10)
 
39
#define DISPC_IRQ_VID1_END_WIN          (1 << 11)
 
40
#define DISPC_IRQ_VID2_FIFO_UNDERFLOW   (1 << 12)
 
41
#define DISPC_IRQ_VID2_END_WIN          (1 << 13)
 
42
#define DISPC_IRQ_SYNC_LOST             (1 << 14)
 
43
#define DISPC_IRQ_SYNC_LOST_DIGIT       (1 << 15)
 
44
#define DISPC_IRQ_WAKEUP                (1 << 16)
 
45
#define DISPC_IRQ_SYNC_LOST2            (1 << 17)
 
46
#define DISPC_IRQ_VSYNC2                (1 << 18)
 
47
#define DISPC_IRQ_ACBIAS_COUNT_STAT2    (1 << 21)
 
48
#define DISPC_IRQ_FRAMEDONE2            (1 << 22)
 
49
 
 
50
struct omap_dss_device;
 
51
struct omap_overlay_manager;
 
52
 
 
53
enum omap_display_type {
 
54
        OMAP_DISPLAY_TYPE_NONE          = 0,
 
55
        OMAP_DISPLAY_TYPE_DPI           = 1 << 0,
 
56
        OMAP_DISPLAY_TYPE_DBI           = 1 << 1,
 
57
        OMAP_DISPLAY_TYPE_SDI           = 1 << 2,
 
58
        OMAP_DISPLAY_TYPE_DSI           = 1 << 3,
 
59
        OMAP_DISPLAY_TYPE_VENC          = 1 << 4,
 
60
        OMAP_DISPLAY_TYPE_HDMI          = 1 << 5,
 
61
};
 
62
 
 
63
enum omap_plane {
 
64
        OMAP_DSS_GFX    = 0,
 
65
        OMAP_DSS_VIDEO1 = 1,
 
66
        OMAP_DSS_VIDEO2 = 2
 
67
};
 
68
 
 
69
enum omap_channel {
 
70
        OMAP_DSS_CHANNEL_LCD    = 0,
 
71
        OMAP_DSS_CHANNEL_DIGIT  = 1,
 
72
        OMAP_DSS_CHANNEL_LCD2   = 2,
 
73
};
 
74
 
 
75
enum omap_color_mode {
 
76
        OMAP_DSS_COLOR_CLUT1    = 1 << 0,  /* BITMAP 1 */
 
77
        OMAP_DSS_COLOR_CLUT2    = 1 << 1,  /* BITMAP 2 */
 
78
        OMAP_DSS_COLOR_CLUT4    = 1 << 2,  /* BITMAP 4 */
 
79
        OMAP_DSS_COLOR_CLUT8    = 1 << 3,  /* BITMAP 8 */
 
80
        OMAP_DSS_COLOR_RGB12U   = 1 << 4,  /* RGB12, 16-bit container */
 
81
        OMAP_DSS_COLOR_ARGB16   = 1 << 5,  /* ARGB16 */
 
82
        OMAP_DSS_COLOR_RGB16    = 1 << 6,  /* RGB16 */
 
83
        OMAP_DSS_COLOR_RGB24U   = 1 << 7,  /* RGB24, 32-bit container */
 
84
        OMAP_DSS_COLOR_RGB24P   = 1 << 8,  /* RGB24, 24-bit container */
 
85
        OMAP_DSS_COLOR_YUV2     = 1 << 9,  /* YUV2 4:2:2 co-sited */
 
86
        OMAP_DSS_COLOR_UYVY     = 1 << 10, /* UYVY 4:2:2 co-sited */
 
87
        OMAP_DSS_COLOR_ARGB32   = 1 << 11, /* ARGB32 */
 
88
        OMAP_DSS_COLOR_RGBA32   = 1 << 12, /* RGBA32 */
 
89
        OMAP_DSS_COLOR_RGBX32   = 1 << 13, /* RGBx32 */
 
90
        OMAP_DSS_COLOR_NV12             = 1 << 14, /* NV12 format: YUV 4:2:0 */
 
91
        OMAP_DSS_COLOR_RGBA16           = 1 << 15, /* RGBA16 - 4444 */
 
92
        OMAP_DSS_COLOR_RGBX16           = 1 << 16, /* RGBx16 - 4444 */
 
93
        OMAP_DSS_COLOR_ARGB16_1555      = 1 << 17, /* ARGB16 - 1555 */
 
94
        OMAP_DSS_COLOR_XRGB16_1555      = 1 << 18, /* xRGB16 - 1555 */
 
95
};
 
96
 
 
97
enum omap_lcd_display_type {
 
98
        OMAP_DSS_LCD_DISPLAY_STN,
 
99
        OMAP_DSS_LCD_DISPLAY_TFT,
 
100
};
 
101
 
 
102
enum omap_dss_load_mode {
 
103
        OMAP_DSS_LOAD_CLUT_AND_FRAME    = 0,
 
104
        OMAP_DSS_LOAD_CLUT_ONLY         = 1,
 
105
        OMAP_DSS_LOAD_FRAME_ONLY        = 2,
 
106
        OMAP_DSS_LOAD_CLUT_ONCE_FRAME   = 3,
 
107
};
 
108
 
 
109
enum omap_dss_trans_key_type {
 
110
        OMAP_DSS_COLOR_KEY_GFX_DST = 0,
 
111
        OMAP_DSS_COLOR_KEY_VID_SRC = 1,
 
112
};
 
113
 
 
114
enum omap_rfbi_te_mode {
 
115
        OMAP_DSS_RFBI_TE_MODE_1 = 1,
 
116
        OMAP_DSS_RFBI_TE_MODE_2 = 2,
 
117
};
 
118
 
 
119
enum omap_panel_config {
 
120
        OMAP_DSS_LCD_IVS                = 1<<0,
 
121
        OMAP_DSS_LCD_IHS                = 1<<1,
 
122
        OMAP_DSS_LCD_IPC                = 1<<2,
 
123
        OMAP_DSS_LCD_IEO                = 1<<3,
 
124
        OMAP_DSS_LCD_RF                 = 1<<4,
 
125
        OMAP_DSS_LCD_ONOFF              = 1<<5,
 
126
 
 
127
        OMAP_DSS_LCD_TFT                = 1<<20,
 
128
};
 
129
 
 
130
enum omap_dss_venc_type {
 
131
        OMAP_DSS_VENC_TYPE_COMPOSITE,
 
132
        OMAP_DSS_VENC_TYPE_SVIDEO,
 
133
};
 
134
 
 
135
enum omap_display_caps {
 
136
        OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE      = 1 << 0,
 
137
        OMAP_DSS_DISPLAY_CAP_TEAR_ELIM          = 1 << 1,
 
138
        /* set if display supports hotplug detect, and will call
 
139
         * omap_dss_notify(CONNECT/DISCONNECT) at appropriate times
 
140
         */
 
141
        OMAP_DSS_DISPLAY_CAP_HPD                        = 1 << 2,
 
142
};
 
143
 
 
144
enum omap_dss_update_mode {
 
145
        OMAP_DSS_UPDATE_DISABLED = 0,
 
146
        OMAP_DSS_UPDATE_AUTO,
 
147
        OMAP_DSS_UPDATE_MANUAL,
 
148
};
 
149
 
 
150
enum omap_dss_display_state {
 
151
        OMAP_DSS_DISPLAY_DISABLED = 0,
 
152
        OMAP_DSS_DISPLAY_ACTIVE,
 
153
        OMAP_DSS_DISPLAY_SUSPENDED,
 
154
};
 
155
 
 
156
/* XXX perhaps this should be removed */
 
157
enum omap_dss_overlay_managers {
 
158
        OMAP_DSS_OVL_MGR_LCD,
 
159
        OMAP_DSS_OVL_MGR_TV,
 
160
        OMAP_DSS_OVL_MGR_LCD2,
 
161
};
 
162
 
 
163
enum omap_dss_rotation_type {
 
164
        OMAP_DSS_ROT_DMA = 0,
 
165
        OMAP_DSS_ROT_VRFB = 1,
 
166
};
 
167
 
 
168
/* clockwise rotation angle */
 
169
enum omap_dss_rotation_angle {
 
170
        OMAP_DSS_ROT_0   = 0,
 
171
        OMAP_DSS_ROT_90  = 1,
 
172
        OMAP_DSS_ROT_180 = 2,
 
173
        OMAP_DSS_ROT_270 = 3,
 
174
};
 
175
 
 
176
enum omap_overlay_caps {
 
177
        OMAP_DSS_OVL_CAP_SCALE = 1 << 0,
 
178
        OMAP_DSS_OVL_CAP_DISPC = 1 << 1,
 
179
};
 
180
 
 
181
enum omap_overlay_manager_caps {
 
182
        OMAP_DSS_OVL_MGR_CAP_DISPC = 1 << 0,
 
183
};
 
184
 
 
185
enum omap_dss_clk_source {
 
186
        OMAP_DSS_CLK_SRC_FCK = 0,               /* OMAP2/3: DSS1_ALWON_FCLK
 
187
                                                 * OMAP4: DSS_FCLK */
 
188
        OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC,   /* OMAP3: DSI1_PLL_FCLK
 
189
                                                 * OMAP4: PLL1_CLK1 */
 
190
        OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DSI,     /* OMAP3: DSI2_PLL_FCLK
 
191
                                                 * OMAP4: PLL1_CLK2 */
 
192
        OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC,  /* OMAP4: PLL2_CLK1 */
 
193
        OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DSI,    /* OMAP4: PLL2_CLK2 */
 
194
};
 
195
 
 
196
/* RFBI */
 
197
 
 
198
struct rfbi_timings {
 
199
        int cs_on_time;
 
200
        int cs_off_time;
 
201
        int we_on_time;
 
202
        int we_off_time;
 
203
        int re_on_time;
 
204
        int re_off_time;
 
205
        int we_cycle_time;
 
206
        int re_cycle_time;
 
207
        int cs_pulse_width;
 
208
        int access_time;
 
209
 
 
210
        int clk_div;
 
211
 
 
212
        u32 tim[5];             /* set by rfbi_convert_timings() */
 
213
 
 
214
        int converted;
 
215
};
 
216
 
 
217
void omap_rfbi_write_command(const void *buf, u32 len);
 
218
void omap_rfbi_read_data(void *buf, u32 len);
 
219
void omap_rfbi_write_data(const void *buf, u32 len);
 
220
void omap_rfbi_write_pixels(const void __iomem *buf, int scr_width,
 
221
                u16 x, u16 y,
 
222
                u16 w, u16 h);
 
223
int omap_rfbi_enable_te(bool enable, unsigned line);
 
224
int omap_rfbi_setup_te(enum omap_rfbi_te_mode mode,
 
225
                             unsigned hs_pulse_time, unsigned vs_pulse_time,
 
226
                             int hs_pol_inv, int vs_pol_inv, int extif_div);
 
227
void rfbi_bus_lock(void);
 
228
void rfbi_bus_unlock(void);
 
229
 
 
230
/* DSI */
 
231
void dsi_bus_lock(struct omap_dss_device *dssdev);
 
232
void dsi_bus_unlock(struct omap_dss_device *dssdev);
 
233
int dsi_vc_dcs_write(struct omap_dss_device *dssdev, int channel, u8 *data,
 
234
                int len);
 
235
int dsi_vc_dcs_write_0(struct omap_dss_device *dssdev, int channel,
 
236
                u8 dcs_cmd);
 
237
int dsi_vc_dcs_write_1(struct omap_dss_device *dssdev, int channel, u8 dcs_cmd,
 
238
                u8 param);
 
239
int dsi_vc_dcs_write_nosync(struct omap_dss_device *dssdev, int channel,
 
240
                u8 *data, int len);
 
241
int dsi_vc_dcs_read(struct omap_dss_device *dssdev, int channel, u8 dcs_cmd,
 
242
                u8 *buf, int buflen);
 
243
int dsi_vc_dcs_read_1(struct omap_dss_device *dssdev, int channel, u8 dcs_cmd,
 
244
                u8 *data);
 
245
int dsi_vc_dcs_read_2(struct omap_dss_device *dssdev, int channel, u8 dcs_cmd,
 
246
                u8 *data1, u8 *data2);
 
247
int dsi_vc_set_max_rx_packet_size(struct omap_dss_device *dssdev, int channel,
 
248
                u16 len);
 
249
int dsi_vc_send_null(struct omap_dss_device *dssdev, int channel);
 
250
int dsi_vc_send_bta_sync(struct omap_dss_device *dssdev, int channel);
 
251
 
 
252
/* Board specific data */
 
253
struct omap_dss_board_info {
 
254
        int (*get_last_off_on_transaction_id)(struct device *dev);
 
255
        int num_devices;
 
256
        struct omap_dss_device **devices;
 
257
        struct omap_dss_device *default_device;
 
258
        void (*dsi_mux_pads)(bool enable);
 
259
};
 
260
 
 
261
#if defined(CONFIG_OMAP2_DSS_MODULE) || defined(CONFIG_OMAP2_DSS)
 
262
/* Init with the board info */
 
263
extern int omap_display_init(struct omap_dss_board_info *board_data);
 
264
#else
 
265
static inline int omap_display_init(struct omap_dss_board_info *board_data)
 
266
{
 
267
        return 0;
 
268
}
 
269
#endif
 
270
 
 
271
struct omap_display_platform_data {
 
272
        struct omap_dss_board_info *board_data;
 
273
        /* TODO: Additional members to be added when PM is considered */
 
274
 
 
275
        bool (*opt_clock_available)(const char *clk_role);
 
276
};
 
277
 
 
278
struct omap_video_timings {
 
279
        /* Unit: pixels */
 
280
        u16 x_res;
 
281
        /* Unit: pixels */
 
282
        u16 y_res;
 
283
        /* Unit: KHz */
 
284
        u32 pixel_clock;
 
285
        /* Unit: pixel clocks */
 
286
        u16 hsw;        /* Horizontal synchronization pulse width */
 
287
        /* Unit: pixel clocks */
 
288
        u16 hfp;        /* Horizontal front porch */
 
289
        /* Unit: pixel clocks */
 
290
        u16 hbp;        /* Horizontal back porch */
 
291
        /* Unit: line clocks */
 
292
        u16 vsw;        /* Vertical synchronization pulse width */
 
293
        /* Unit: line clocks */
 
294
        u16 vfp;        /* Vertical front porch */
 
295
        /* Unit: line clocks */
 
296
        u16 vbp;        /* Vertical back porch */
 
297
};
 
298
 
 
299
#ifdef CONFIG_OMAP2_DSS_VENC
 
300
/* Hardcoded timings for tv modes. Venc only uses these to
 
301
 * identify the mode, and does not actually use the configs
 
302
 * itself. However, the configs should be something that
 
303
 * a normal monitor can also show */
 
304
extern const struct omap_video_timings omap_dss_pal_timings;
 
305
extern const struct omap_video_timings omap_dss_ntsc_timings;
 
306
#endif
 
307
 
 
308
struct omap_overlay_info {
 
309
        bool enabled;
 
310
 
 
311
        u32 paddr;
 
312
        void __iomem *vaddr;
 
313
        u32 p_uv_addr;  /* for NV12 format */
 
314
        u16 screen_width;
 
315
        u16 width;
 
316
        u16 height;
 
317
        enum omap_color_mode color_mode;
 
318
        u8 rotation;
 
319
        enum omap_dss_rotation_type rotation_type;
 
320
        bool mirror;
 
321
 
 
322
        u16 pos_x;
 
323
        u16 pos_y;
 
324
        u16 out_width;  /* if 0, out_width == width */
 
325
        u16 out_height; /* if 0, out_height == height */
 
326
        u8 global_alpha;
 
327
        u8 pre_mult_alpha;
 
328
};
 
329
 
 
330
struct omap_overlay {
 
331
        struct kobject kobj;
 
332
        struct list_head list;
 
333
 
 
334
        /* static fields */
 
335
        const char *name;
 
336
        int id;
 
337
        enum omap_color_mode supported_modes;
 
338
        enum omap_overlay_caps caps;
 
339
 
 
340
        /* dynamic fields */
 
341
        struct omap_overlay_manager *manager;
 
342
        struct omap_overlay_info info;
 
343
 
 
344
        /* if true, info has been changed, but not applied() yet */
 
345
        bool info_dirty;
 
346
 
 
347
        int (*set_manager)(struct omap_overlay *ovl,
 
348
                struct omap_overlay_manager *mgr);
 
349
        int (*unset_manager)(struct omap_overlay *ovl);
 
350
 
 
351
        int (*set_overlay_info)(struct omap_overlay *ovl,
 
352
                        struct omap_overlay_info *info);
 
353
        void (*get_overlay_info)(struct omap_overlay *ovl,
 
354
                        struct omap_overlay_info *info);
 
355
 
 
356
        int (*wait_for_go)(struct omap_overlay *ovl);
 
357
};
 
358
 
 
359
struct omap_overlay_manager_info {
 
360
        u32 default_color;
 
361
 
 
362
        enum omap_dss_trans_key_type trans_key_type;
 
363
        u32 trans_key;
 
364
        bool trans_enabled;
 
365
 
 
366
        bool alpha_enabled;
 
367
};
 
368
 
 
369
struct omap_overlay_manager {
 
370
        struct kobject kobj;
 
371
        struct list_head list;
 
372
 
 
373
        /* static fields */
 
374
        const char *name;
 
375
        int id;
 
376
        enum omap_overlay_manager_caps caps;
 
377
        int num_overlays;
 
378
        struct omap_overlay **overlays;
 
379
        enum omap_display_type supported_displays;
 
380
 
 
381
        /* dynamic fields */
 
382
        struct omap_dss_device *device;
 
383
        struct omap_overlay_manager_info info;
 
384
 
 
385
        bool device_changed;
 
386
        /* if true, info has been changed but not applied() yet */
 
387
        bool info_dirty;
 
388
 
 
389
        int (*set_device)(struct omap_overlay_manager *mgr,
 
390
                struct omap_dss_device *dssdev);
 
391
        int (*unset_device)(struct omap_overlay_manager *mgr);
 
392
 
 
393
        int (*set_manager_info)(struct omap_overlay_manager *mgr,
 
394
                        struct omap_overlay_manager_info *info);
 
395
        void (*get_manager_info)(struct omap_overlay_manager *mgr,
 
396
                        struct omap_overlay_manager_info *info);
 
397
 
 
398
        int (*apply)(struct omap_overlay_manager *mgr);
 
399
        int (*wait_for_go)(struct omap_overlay_manager *mgr);
 
400
        int (*wait_for_vsync)(struct omap_overlay_manager *mgr);
 
401
 
 
402
        int (*enable)(struct omap_overlay_manager *mgr);
 
403
        int (*disable)(struct omap_overlay_manager *mgr);
 
404
};
 
405
 
 
406
struct omap_dss_device {
 
407
        struct device dev;
 
408
 
 
409
        enum omap_display_type type;
 
410
 
 
411
        enum omap_channel channel;
 
412
 
 
413
        union {
 
414
                struct {
 
415
                        u8 data_lines;
 
416
                } dpi;
 
417
 
 
418
                struct {
 
419
                        u8 channel;
 
420
                        u8 data_lines;
 
421
                } rfbi;
 
422
 
 
423
                struct {
 
424
                        u8 datapairs;
 
425
                } sdi;
 
426
 
 
427
                struct {
 
428
                        u8 clk_lane;
 
429
                        u8 clk_pol;
 
430
                        u8 data1_lane;
 
431
                        u8 data1_pol;
 
432
                        u8 data2_lane;
 
433
                        u8 data2_pol;
 
434
                        u8 data3_lane;
 
435
                        u8 data3_pol;
 
436
                        u8 data4_lane;
 
437
                        u8 data4_pol;
 
438
 
 
439
                        int module;
 
440
 
 
441
                        bool ext_te;
 
442
                        u8 ext_te_gpio;
 
443
                } dsi;
 
444
 
 
445
                struct {
 
446
                        enum omap_dss_venc_type type;
 
447
                        bool invert_polarity;
 
448
                } venc;
 
449
        } phy;
 
450
 
 
451
        struct {
 
452
                struct {
 
453
                        struct {
 
454
                                u16 lck_div;
 
455
                                u16 pck_div;
 
456
                                enum omap_dss_clk_source lcd_clk_src;
 
457
                        } channel;
 
458
 
 
459
                        enum omap_dss_clk_source dispc_fclk_src;
 
460
                } dispc;
 
461
 
 
462
                struct {
 
463
                        u16 regn;
 
464
                        u16 regm;
 
465
                        u16 regm_dispc;
 
466
                        u16 regm_dsi;
 
467
 
 
468
                        u16 lp_clk_div;
 
469
                        enum omap_dss_clk_source dsi_fclk_src;
 
470
                } dsi;
 
471
 
 
472
                struct {
 
473
                        u16 regn;
 
474
                        u16 regm2;
 
475
                } hdmi;
 
476
        } clocks;
 
477
 
 
478
        struct {
 
479
                struct omap_video_timings timings;
 
480
 
 
481
                int acbi;       /* ac-bias pin transitions per interrupt */
 
482
                /* Unit: line clocks */
 
483
                int acb;        /* ac-bias pin frequency */
 
484
 
 
485
                enum omap_panel_config config;
 
486
        } panel;
 
487
 
 
488
        struct {
 
489
                u8 pixel_size;
 
490
                struct rfbi_timings rfbi_timings;
 
491
        } ctrl;
 
492
 
 
493
        int reset_gpio;
 
494
 
 
495
        int max_backlight_level;
 
496
 
 
497
        const char *name;
 
498
 
 
499
        /* used to match device to driver */
 
500
        const char *driver_name;
 
501
 
 
502
        void *data;
 
503
 
 
504
        struct omap_dss_driver *driver;
 
505
 
 
506
        /* helper variable for driver suspend/resume */
 
507
        bool activate_after_resume;
 
508
 
 
509
        enum omap_display_caps caps;
 
510
 
 
511
        struct omap_overlay_manager *manager;
 
512
 
 
513
        enum omap_dss_display_state state;
 
514
        struct blocking_notifier_head notifier;
 
515
 
 
516
        /* platform specific  */
 
517
        int (*platform_enable)(struct omap_dss_device *dssdev);
 
518
        void (*platform_disable)(struct omap_dss_device *dssdev);
 
519
        int (*set_backlight)(struct omap_dss_device *dssdev, int level);
 
520
        int (*get_backlight)(struct omap_dss_device *dssdev);
 
521
};
 
522
 
 
523
struct omap_dss_driver {
 
524
        struct device_driver driver;
 
525
 
 
526
        int (*probe)(struct omap_dss_device *);
 
527
        void (*remove)(struct omap_dss_device *);
 
528
 
 
529
        int (*enable)(struct omap_dss_device *display);
 
530
        void (*disable)(struct omap_dss_device *display);
 
531
        int (*suspend)(struct omap_dss_device *display);
 
532
        int (*resume)(struct omap_dss_device *display);
 
533
        int (*run_test)(struct omap_dss_device *display, int test);
 
534
 
 
535
        int (*set_update_mode)(struct omap_dss_device *dssdev,
 
536
                        enum omap_dss_update_mode);
 
537
        enum omap_dss_update_mode (*get_update_mode)(
 
538
                        struct omap_dss_device *dssdev);
 
539
 
 
540
        int (*update)(struct omap_dss_device *dssdev,
 
541
                               u16 x, u16 y, u16 w, u16 h);
 
542
        int (*sync)(struct omap_dss_device *dssdev);
 
543
 
 
544
        int (*enable_te)(struct omap_dss_device *dssdev, bool enable);
 
545
        int (*get_te)(struct omap_dss_device *dssdev);
 
546
 
 
547
        u8 (*get_rotate)(struct omap_dss_device *dssdev);
 
548
        int (*set_rotate)(struct omap_dss_device *dssdev, u8 rotate);
 
549
 
 
550
        bool (*get_mirror)(struct omap_dss_device *dssdev);
 
551
        int (*set_mirror)(struct omap_dss_device *dssdev, bool enable);
 
552
 
 
553
        int (*memory_read)(struct omap_dss_device *dssdev,
 
554
                        void *buf, size_t size,
 
555
                        u16 x, u16 y, u16 w, u16 h);
 
556
 
 
557
        void (*get_resolution)(struct omap_dss_device *dssdev,
 
558
                        u16 *xres, u16 *yres);
 
559
        void (*get_dimensions)(struct omap_dss_device *dssdev,
 
560
                        u32 *width, u32 *height);
 
561
        int (*get_recommended_bpp)(struct omap_dss_device *dssdev);
 
562
 
 
563
        int (*check_timings)(struct omap_dss_device *dssdev,
 
564
                        struct omap_video_timings *timings);
 
565
        void (*set_timings)(struct omap_dss_device *dssdev,
 
566
                        struct omap_video_timings *timings);
 
567
        void (*get_timings)(struct omap_dss_device *dssdev,
 
568
                        struct omap_video_timings *timings);
 
569
 
 
570
        int (*set_wss)(struct omap_dss_device *dssdev, u32 wss);
 
571
        u32 (*get_wss)(struct omap_dss_device *dssdev);
 
572
 
 
573
        /* return raw EDID.. len indicates the max number of bytes of the
 
574
         * EDID to read */
 
575
        int (*get_edid)(struct omap_dss_device *dssdev, u8 *edid, int len);
 
576
 
 
577
        /* is this display physically present / plugged-in?  For hot-plug
 
578
         * type displays (DVI, HDMI), this means is the cable plugged in.
 
579
         * For displays like LCD panels, this means is the display present
 
580
         * on the board.
 
581
         */
 
582
        bool (*is_detected)(struct omap_dss_device *dssdev, bool force);
 
583
};
 
584
 
 
585
int omap_dss_register_driver(struct omap_dss_driver *);
 
586
void omap_dss_unregister_driver(struct omap_dss_driver *);
 
587
const char* omap_dss_get_def_disp(void);
 
588
 
 
589
void omap_dss_get_device(struct omap_dss_device *dssdev);
 
590
void omap_dss_put_device(struct omap_dss_device *dssdev);
 
591
#define for_each_dss_dev(d) while ((d = omap_dss_get_next_device(d)) != NULL)
 
592
struct omap_dss_device *omap_dss_get_next_device(struct omap_dss_device *from);
 
593
struct omap_dss_device *omap_dss_find_device(void *data,
 
594
                int (*match)(struct omap_dss_device *dssdev, void *data));
 
595
 
 
596
int omap_dss_start_device(struct omap_dss_device *dssdev);
 
597
void omap_dss_stop_device(struct omap_dss_device *dssdev);
 
598
 
 
599
/* the event id of the event that occurred is passed in as the second arg
 
600
 * to the notifier function, and the dssdev is passed as the third.
 
601
 */
 
602
enum omap_dss_event {
 
603
        OMAP_DSS_SIZE_CHANGE,
 
604
        /* the CONNECT/DISCONNECT events will be sent if OMAP_DSS_DISPLAY_CAP_HPD
 
605
         * flag is set in the dssdev->caps.  Otherwise the user will have to poll
 
606
         * for detection when a monitor is plugged/unplugged.
 
607
         */
 
608
        OMAP_DSS_HOTPLUG_CONNECT,
 
609
        OMAP_DSS_HOTPLUG_DISCONNECT,
 
610
};
 
611
 
 
612
void omap_dss_notify(struct omap_dss_device *dssdev, enum omap_dss_event evt);
 
613
void omap_dss_add_notify(struct omap_dss_device *dssdev, struct notifier_block *nb);
 
614
void omap_dss_remove_notify(struct omap_dss_device *dssdev, struct notifier_block *nb);
 
615
 
 
616
int omap_dss_get_num_overlay_managers(void);
 
617
struct omap_overlay_manager *omap_dss_get_overlay_manager(int num);
 
618
 
 
619
int omap_dss_get_num_overlays(void);
 
620
struct omap_overlay *omap_dss_get_overlay(int num);
 
621
 
 
622
void omapdss_default_get_timings(struct omap_dss_device *dssdev,
 
623
                struct omap_video_timings *timings);
 
624
int omapdss_default_check_timings(struct omap_dss_device *dssdev,
 
625
                struct omap_video_timings *timings);
 
626
bool omapdss_default_is_detected(struct omap_dss_device *dssdev, bool force);
 
627
void omapdss_default_get_resolution(struct omap_dss_device *dssdev,
 
628
                u16 *xres, u16 *yres);
 
629
int omapdss_default_get_recommended_bpp(struct omap_dss_device *dssdev);
 
630
 
 
631
typedef void (*omap_dispc_isr_t) (void *arg, u32 mask);
 
632
int omap_dispc_register_isr(omap_dispc_isr_t isr, void *arg, u32 mask);
 
633
int omap_dispc_unregister_isr(omap_dispc_isr_t isr, void *arg, u32 mask);
 
634
 
 
635
int omap_dispc_wait_for_irq_timeout(u32 irqmask, unsigned long timeout);
 
636
int omap_dispc_wait_for_irq_interruptible_timeout(u32 irqmask,
 
637
                unsigned long timeout);
 
638
 
 
639
#define to_dss_driver(x) container_of((x), struct omap_dss_driver, driver)
 
640
#define to_dss_device(x) container_of((x), struct omap_dss_device, dev)
 
641
 
 
642
void omapdss_dsi_vc_enable_hs(struct omap_dss_device *dssdev, int channel,
 
643
                bool enable);
 
644
int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable);
 
645
 
 
646
int omap_dsi_prepare_update(struct omap_dss_device *dssdev,
 
647
                                    u16 *x, u16 *y, u16 *w, u16 *h,
 
648
                                    bool enlarge_update_area);
 
649
int omap_dsi_update(struct omap_dss_device *dssdev,
 
650
                int channel,
 
651
                u16 x, u16 y, u16 w, u16 h,
 
652
                void (*callback)(int, void *), void *data);
 
653
int omap_dsi_request_vc(struct omap_dss_device *dssdev, int *channel);
 
654
int omap_dsi_set_vc_id(struct omap_dss_device *dssdev, int channel, int vc_id);
 
655
void omap_dsi_release_vc(struct omap_dss_device *dssdev, int channel);
 
656
 
 
657
int omapdss_dsi_display_enable(struct omap_dss_device *dssdev);
 
658
void omapdss_dsi_display_disable(struct omap_dss_device *dssdev,
 
659
                bool disconnect_lanes, bool enter_ulps);
 
660
 
 
661
int omapdss_dpi_display_enable(struct omap_dss_device *dssdev);
 
662
void omapdss_dpi_display_disable(struct omap_dss_device *dssdev);
 
663
void dpi_set_timings(struct omap_dss_device *dssdev,
 
664
                        struct omap_video_timings *timings);
 
665
int dpi_check_timings(struct omap_dss_device *dssdev,
 
666
                        struct omap_video_timings *timings);
 
667
 
 
668
int omapdss_sdi_display_enable(struct omap_dss_device *dssdev);
 
669
void omapdss_sdi_display_disable(struct omap_dss_device *dssdev);
 
670
 
 
671
int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev);
 
672
void omapdss_rfbi_display_disable(struct omap_dss_device *dssdev);
 
673
int omap_rfbi_prepare_update(struct omap_dss_device *dssdev,
 
674
                u16 *x, u16 *y, u16 *w, u16 *h);
 
675
int omap_rfbi_update(struct omap_dss_device *dssdev,
 
676
                u16 x, u16 y, u16 w, u16 h,
 
677
                void (*callback)(void *), void *data);
 
678
int omap_rfbi_configure(struct omap_dss_device *dssdev, int pixel_size,
 
679
                int data_lines);
 
680
 
 
681
#endif