video: tegra: host: Move device data to nvhost_device
[linux-2.6.git] / drivers / video / tegra / dc / dc_priv.h
1 /*
2  * drivers/video/tegra/dc/dc_priv.h
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Author: Erik Gilling <konkers@android.com>
6  *
7  * This software is licensed under the terms of the GNU General Public
8  * License version 2, as published by the Free Software Foundation, and
9  * may be copied, distributed, and modified under those terms.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17
18 #ifndef __DRIVERS_VIDEO_TEGRA_DC_DC_PRIV_H
19 #define __DRIVERS_VIDEO_TEGRA_DC_DC_PRIV_H
20
21 #include <linux/io.h>
22 #include <linux/mutex.h>
23 #include <linux/wait.h>
24 #include <linux/completion.h>
25 #include <linux/switch.h>
26
27 #include <mach/dc.h>
28
29 #include "../host/dev.h"
30 #include "../host/host1x/host1x_syncpt.h"
31
32 #include <mach/tegra_dc_ext.h>
33
34 #define WIN_IS_TILED(win)       ((win)->flags & TEGRA_WIN_FLAG_TILED)
35 #define WIN_IS_ENABLED(win)     ((win)->flags & TEGRA_WIN_FLAG_ENABLED)
36
37 #define NEED_UPDATE_EMC_ON_EVERY_FRAME (windows_idle_detection_time == 0)
38
39 /* DDR: 8 bytes transfer per clock */
40 #define DDR_BW_TO_FREQ(bw) ((bw) / 8)
41
42 #if defined(CONFIG_TEGRA_EMC_TO_DDR_CLOCK)
43 #define EMC_BW_TO_FREQ(bw) (DDR_BW_TO_FREQ(bw) * CONFIG_TEGRA_EMC_TO_DDR_CLOCK)
44 #else
45 #define EMC_BW_TO_FREQ(bw) (DDR_BW_TO_FREQ(bw) * 2)
46 #endif
47
48 struct tegra_dc;
49
50 struct tegra_dc_blend {
51         unsigned z[DC_N_WINDOWS];
52         unsigned flags[DC_N_WINDOWS];
53 };
54
55 struct tegra_dc_out_ops {
56         /* initialize output.  dc clocks are not on at this point */
57         int (*init)(struct tegra_dc *dc);
58         /* destroy output.  dc clocks are not on at this point */
59         void (*destroy)(struct tegra_dc *dc);
60         /* detect connected display.  can sleep.*/
61         bool (*detect)(struct tegra_dc *dc);
62         /* enable output.  dc clocks are on at this point */
63         void (*enable)(struct tegra_dc *dc);
64         /* disable output.  dc clocks are on at this point */
65         void (*disable)(struct tegra_dc *dc);
66
67         /* suspend output.  dc clocks are on at this point */
68         void (*suspend)(struct tegra_dc *dc);
69         /* resume output.  dc clocks are on at this point */
70         void (*resume)(struct tegra_dc *dc);
71 };
72
73 struct tegra_dc {
74         struct nvhost_device            *ndev;
75         struct tegra_dc_platform_data   *pdata;
76
77         struct resource                 *base_res;
78         void __iomem                    *base;
79         int                             irq;
80
81         int                             pixel_clk;
82         struct clk                      *clk;
83         struct clk                      *emc_clk;
84         int                             emc_clk_rate;
85         int                             new_emc_clk_rate;
86
87         bool                            connected;
88         bool                            enabled;
89         bool                            suspended;
90
91         struct tegra_dc_out             *out;
92         struct tegra_dc_out_ops         *out_ops;
93         void                            *out_data;
94
95         struct tegra_dc_mode            mode;
96
97         struct tegra_dc_win             windows[DC_N_WINDOWS];
98         struct tegra_dc_blend           blend;
99         int                             n_windows;
100
101         wait_queue_head_t               wq;
102
103         struct mutex                    lock;
104
105         struct resource                 *fb_mem;
106         struct tegra_fb_info            *fb;
107
108         struct tegra_overlay_info       *overlay;
109
110         struct {
111                 u32                     id;
112                 u32                     min;
113                 u32                     max;
114         } syncpt[DC_N_WINDOWS];
115         u32                             vblank_syncpt;
116
117         unsigned long                   underflow_mask;
118         struct work_struct              reset_work;
119
120 #ifdef CONFIG_SWITCH
121         struct switch_dev               modeset_switch;
122 #endif
123
124         struct completion               frame_end_complete;
125
126         struct work_struct              vblank_work;
127
128         struct {
129                 u64                     underflows;
130                 u64                     underflows_a;
131                 u64                     underflows_b;
132                 u64                     underflows_c;
133         } stats;
134
135         struct tegra_dc_ext             *ext;
136
137 #ifdef CONFIG_DEBUG_FS
138         struct dentry                   *debugdir;
139 #endif
140         struct tegra_dc_lut             fb_lut;
141 };
142
143 static inline void tegra_dc_io_start(struct tegra_dc *dc)
144 {
145         nvhost_module_busy(dc->ndev->host->dev);
146 }
147
148 static inline void tegra_dc_io_end(struct tegra_dc *dc)
149 {
150         nvhost_module_idle(dc->ndev->host->dev);
151 }
152
153 static inline unsigned long tegra_dc_readl(struct tegra_dc *dc,
154                                            unsigned long reg)
155 {
156         BUG_ON(!nvhost_module_powered(dc->ndev->host->dev));
157         return readl(dc->base + reg * 4);
158 }
159
160 static inline void tegra_dc_writel(struct tegra_dc *dc, unsigned long val,
161                                    unsigned long reg)
162 {
163         BUG_ON(!nvhost_module_powered(dc->ndev->host->dev));
164         writel(val, dc->base + reg * 4);
165 }
166
167 static inline void _tegra_dc_write_table(struct tegra_dc *dc, const u32 *table,
168                                          unsigned len)
169 {
170         int i;
171
172         for (i = 0; i < len; i++)
173                 tegra_dc_writel(dc, table[i * 2 + 1], table[i * 2]);
174 }
175
176 #define tegra_dc_write_table(dc, table)         \
177         _tegra_dc_write_table(dc, table, ARRAY_SIZE(table) / 2)
178
179 static inline void tegra_dc_set_outdata(struct tegra_dc *dc, void *data)
180 {
181         dc->out_data = data;
182 }
183
184 static inline void *tegra_dc_get_outdata(struct tegra_dc *dc)
185 {
186         return dc->out_data;
187 }
188
189 static inline unsigned long tegra_dc_get_default_emc_clk_rate(
190                                                         struct tegra_dc *dc)
191 {
192         return dc->pdata->emc_clk_rate ? dc->pdata->emc_clk_rate : ULONG_MAX;
193 }
194
195 void tegra_dc_setup_clk(struct tegra_dc *dc, struct clk *clk);
196
197 extern struct tegra_dc_out_ops tegra_dc_rgb_ops;
198 extern struct tegra_dc_out_ops tegra_dc_hdmi_ops;
199 extern struct tegra_dc_out_ops tegra_dc_dsi_ops;
200
201 /* defined in dc_sysfs.c, used by dc.c */
202 void __devexit tegra_dc_remove_sysfs(struct device *dev);
203 void tegra_dc_create_sysfs(struct device *dev);
204
205 /* defined in dc.c, used by dc_sysfs.c */
206 void tegra_dc_stats_enable(struct tegra_dc *dc, bool enable);
207 bool tegra_dc_stats_get(struct tegra_dc *dc);
208
209 /* defined in dc.c, used by overlay.c */
210 unsigned int tegra_dc_has_multiple_dc(void);
211 unsigned long tegra_dc_get_bandwidth(struct tegra_dc_win *wins[], int n);
212
213 /* defined in dc.c, used by dc_sysfs.c */
214 u32 tegra_dc_read_checksum_latched(struct tegra_dc *dc);
215 void tegra_dc_enable_crc(struct tegra_dc *dc);
216 void tegra_dc_disable_crc(struct tegra_dc *dc);
217
218 void tegra_dc_set_out_pin_polars(struct tegra_dc *dc,
219                                 const struct tegra_dc_out_pin *pins,
220                                 const unsigned int n_pins);
221 #endif
222