video: tegra: gk20a: Fix protected elpg race.
[linux-3.10.git] / drivers / video / tegra / host / gk20a / gr_gk20a.h
1 /*
2  * GK20A Graphics Engine
3  *
4  * Copyright (c) 2011-2014, NVIDIA CORPORATION.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 #ifndef __GR_GK20A_H__
19 #define __GR_GK20A_H__
20
21 #include <linux/slab.h>
22
23 #include "gr_ctx_gk20a.h"
24
25 #define GR_IDLE_CHECK_DEFAULT           10 /* usec */
26 #define GR_IDLE_CHECK_MAX               200 /* usec */
27
28 #define INVALID_SCREEN_TILE_ROW_OFFSET  0xFFFFFFFF
29 #define INVALID_MAX_WAYS                0xFFFFFFFF
30
31 #define GK20A_FECS_UCODE_IMAGE  "fecs.bin"
32 #define GK20A_GPCCS_UCODE_IMAGE "gpccs.bin"
33
34 enum /* global_ctx_buffer */ {
35         CIRCULAR                = 0,
36         PAGEPOOL                = 1,
37         ATTRIBUTE               = 2,
38         CIRCULAR_VPR            = 3,
39         PAGEPOOL_VPR            = 4,
40         ATTRIBUTE_VPR           = 5,
41         GOLDEN_CTX              = 6,
42         NR_GLOBAL_CTX_BUF       = 7
43 };
44
45 /* either ATTRIBUTE or ATTRIBUTE_VPR maps to ATTRIBUTE_VA */
46 enum  /*global_ctx_buffer_va */ {
47         CIRCULAR_VA             = 0,
48         PAGEPOOL_VA             = 1,
49         ATTRIBUTE_VA            = 2,
50         GOLDEN_CTX_VA           = 3,
51         NR_GLOBAL_CTX_BUF_VA    = 4
52 };
53
54 enum {
55         WAIT_UCODE_LOOP,
56         WAIT_UCODE_TIMEOUT,
57         WAIT_UCODE_ERROR,
58         WAIT_UCODE_OK
59 };
60
61 enum {
62         GR_IS_UCODE_OP_EQUAL,
63         GR_IS_UCODE_OP_NOT_EQUAL,
64         GR_IS_UCODE_OP_AND,
65         GR_IS_UCODE_OP_LESSER,
66         GR_IS_UCODE_OP_LESSER_EQUAL,
67         GR_IS_UCODE_OP_SKIP
68 };
69
70 enum {
71         eUcodeHandshakeInitComplete = 1,
72         eUcodeHandshakeMethodFinished
73 };
74
75 enum {
76         ELCG_RUN,       /* clk always run, i.e. disable elcg */
77         ELCG_STOP,      /* clk is stopped */
78         ELCG_AUTO       /* clk will run when non-idle, standard elcg mode */
79 };
80
81 enum {
82         BLCG_RUN,       /* clk always run, i.e. disable blcg */
83         BLCG_AUTO       /* clk will run when non-idle, standard blcg mode */
84 };
85
86 #ifndef GR_GO_IDLE_BUNDLE
87 #define GR_GO_IDLE_BUNDLE       0x0000e100 /* --V-B */
88 #endif
89
90 struct gr_channel_map_tlb_entry {
91         u32 curr_ctx;
92         u32 hw_chid;
93 };
94
95 struct gr_zcull_gk20a {
96         u32 aliquot_width;
97         u32 aliquot_height;
98         u32 aliquot_size;
99         u32 total_aliquots;
100
101         u32 width_align_pixels;
102         u32 height_align_pixels;
103         u32 pixel_squares_by_aliquots;
104 };
105
106 struct gr_zcull_info {
107         u32 width_align_pixels;
108         u32 height_align_pixels;
109         u32 pixel_squares_by_aliquots;
110         u32 aliquot_total;
111         u32 region_byte_multiplier;
112         u32 region_header_size;
113         u32 subregion_header_size;
114         u32 subregion_width_align_pixels;
115         u32 subregion_height_align_pixels;
116         u32 subregion_count;
117 };
118
119 #define GK20A_ZBC_COLOR_VALUE_SIZE      4  /* RGBA */
120
121 #define GK20A_STARTOF_ZBC_TABLE         1   /* index zero reserved to indicate "not ZBCd" */
122 #define GK20A_SIZEOF_ZBC_TABLE          16  /* match ltcs_ltss_dstg_zbc_index_address width (4) */
123 #define GK20A_ZBC_TABLE_SIZE            (16 - 1)
124
125 #define GK20A_ZBC_TYPE_INVALID          0
126 #define GK20A_ZBC_TYPE_COLOR            1
127 #define GK20A_ZBC_TYPE_DEPTH            2
128
129 struct zbc_color_table {
130         u32 color_ds[GK20A_ZBC_COLOR_VALUE_SIZE];
131         u32 color_l2[GK20A_ZBC_COLOR_VALUE_SIZE];
132         u32 format;
133         u32 ref_cnt;
134 };
135
136 struct zbc_depth_table {
137         u32 depth;
138         u32 format;
139         u32 ref_cnt;
140 };
141
142 struct zbc_entry {
143         u32 color_ds[GK20A_ZBC_COLOR_VALUE_SIZE];
144         u32 color_l2[GK20A_ZBC_COLOR_VALUE_SIZE];
145         u32 depth;
146         u32 type;       /* color or depth */
147         u32 format;
148 };
149
150 struct zbc_query_params {
151         u32 color_ds[GK20A_ZBC_COLOR_VALUE_SIZE];
152         u32 color_l2[GK20A_ZBC_COLOR_VALUE_SIZE];
153         u32 depth;
154         u32 ref_cnt;
155         u32 format;
156         u32 type;       /* color or depth */
157         u32 index_size; /* [out] size, [in] index */
158 };
159
160 struct gr_gk20a {
161         struct gk20a *g;
162         struct {
163                 bool dynamic;
164
165                 u32 buffer_size;
166                 u32 buffer_total_size;
167
168                 bool golden_image_initialized;
169                 u32 golden_image_size;
170                 u32 *local_golden_image;
171
172                 u32 zcull_ctxsw_image_size;
173
174                 u32 buffer_header_size;
175
176                 struct gr_ucode_gk20a ucode;
177
178                 struct av_list_gk20a  sw_bundle_init;
179                 struct av_list_gk20a  sw_method_init;
180                 struct aiv_list_gk20a sw_ctx_load;
181                 struct av_list_gk20a  sw_non_ctx_load;
182                 struct {
183                         struct aiv_list_gk20a sys;
184                         struct aiv_list_gk20a gpc;
185                         struct aiv_list_gk20a tpc;
186                         struct aiv_list_gk20a zcull_gpc;
187                         struct aiv_list_gk20a ppc;
188                         struct aiv_list_gk20a pm_sys;
189                         struct aiv_list_gk20a pm_gpc;
190                         struct aiv_list_gk20a pm_tpc;
191                 } ctxsw_regs;
192                 int regs_base_index;
193                 bool valid;
194         } ctx_vars;
195
196         struct mutex ctx_mutex; /* protect golden ctx init */
197         struct mutex fecs_mutex; /* protect fecs method */
198
199 #define GR_NETLIST_DYNAMIC      -1
200 #define GR_NETLIST_STATIC_A     'A'
201         int netlist;
202
203         int initialized;
204         u32 num_fbps;
205
206         u32 max_gpc_count;
207         u32 max_fbps_count;
208         u32 max_tpc_per_gpc_count;
209         u32 max_zcull_per_gpc_count;
210         u32 max_tpc_count;
211
212         u32 sys_count;
213         u32 gpc_count;
214         u32 pe_count_per_gpc;
215         u32 ppc_count;
216         u32 *gpc_ppc_count;
217         u32 tpc_count;
218         u32 *gpc_tpc_count;
219         u32 zcb_count;
220         u32 *gpc_zcb_count;
221         u32 *pes_tpc_count[2];
222         u32 *pes_tpc_mask[2];
223         u32 *gpc_skip_mask;
224
225         u32 bundle_cb_default_size;
226         u32 min_gpm_fifo_depth;
227         u32 bundle_cb_token_limit;
228         u32 attrib_cb_default_size;
229         u32 attrib_cb_size;
230         u32 alpha_cb_default_size;
231         u32 alpha_cb_size;
232         u32 timeslice_mode;
233
234         struct mem_desc global_ctx_buffer[NR_GLOBAL_CTX_BUF];
235
236         struct mmu_desc mmu_wr_mem;
237         u32 mmu_wr_mem_size;
238         struct mmu_desc mmu_rd_mem;
239         u32 mmu_rd_mem_size;
240
241         u8 *map_tiles;
242         u32 map_tile_count;
243         u32 map_row_offset;
244
245 #define COMP_TAG_LINE_SIZE_SHIFT        (17)    /* one tag covers 128K */
246 #define COMP_TAG_LINE_SIZE              (1 << COMP_TAG_LINE_SIZE_SHIFT)
247
248         u32 max_comptag_mem; /* max memory size (MB) for comptag */
249         struct compbit_store_desc compbit_store;
250         struct nvhost_allocator comp_tags;
251
252         struct gr_zcull_gk20a zcull;
253
254         struct zbc_color_table zbc_col_tbl[GK20A_ZBC_TABLE_SIZE];
255         struct zbc_depth_table zbc_dep_tbl[GK20A_ZBC_TABLE_SIZE];
256
257         s32 max_default_color_index;
258         s32 max_default_depth_index;
259
260         s32 max_used_color_index;
261         s32 max_used_depth_index;
262
263         u32 status_disable_mask;
264
265 #define GR_CHANNEL_MAP_TLB_SIZE         2 /* must of power of 2 */
266         struct gr_channel_map_tlb_entry chid_tlb[GR_CHANNEL_MAP_TLB_SIZE];
267         u32 channel_tlb_flush_index;
268         spinlock_t ch_tlb_lock;
269
270         void (*remove_support)(struct gr_gk20a *gr);
271         bool sw_ready;
272         bool skip_ucode_init;
273 };
274
275 void gk20a_fecs_dump_falcon_stats(struct gk20a *g);
276
277 struct gk20a_ctxsw_ucode_segment {
278         u32 offset;
279         u32 size;
280 };
281
282 struct gk20a_ctxsw_ucode_inst {
283         u32 boot_entry;
284         u32 boot_imem_offset;
285         struct gk20a_ctxsw_ucode_segment boot;
286         struct gk20a_ctxsw_ucode_segment code;
287         struct gk20a_ctxsw_ucode_segment data;
288 };
289
290 struct gk20a_ctxsw_ucode_info {
291         u64 *p_va;
292         struct inst_desc inst_blk_desc;
293         struct surface_mem_desc surface_desc;
294         u64 ucode_gpuva;
295         struct gk20a_ctxsw_ucode_inst fecs;
296         struct gk20a_ctxsw_ucode_inst gpcs;
297 };
298
299 struct gk20a_ctxsw_bootloader_desc {
300         u32 bootloader_start_offset;
301         u32 bootloader_size;
302         u32 bootloader_imem_offset;
303         u32 bootloader_entry_point;
304 };
305
306 int gk20a_init_gr_support(struct gk20a *g);
307 void gk20a_gr_reset(struct gk20a *g);
308
309 int gk20a_init_gr_channel(struct channel_gk20a *ch_gk20a);
310
311 int gr_gk20a_init_ctx_vars(struct gk20a *g, struct gr_gk20a *gr);
312
313 struct nvhost_alloc_obj_ctx_args;
314 struct nvhost_free_obj_ctx_args;
315
316 int gk20a_alloc_obj_ctx(struct channel_gk20a *c,
317                         struct nvhost_alloc_obj_ctx_args *args);
318 int gk20a_free_obj_ctx(struct channel_gk20a *c,
319                         struct nvhost_free_obj_ctx_args *args);
320 void gk20a_free_channel_ctx(struct channel_gk20a *c);
321
322 int gk20a_gr_isr(struct gk20a *g);
323 int gk20a_gr_nonstall_isr(struct gk20a *g);
324
325 int gk20a_gr_clear_comptags(struct gk20a *g, u32 min, u32 max);
326 /* zcull */
327 u32 gr_gk20a_get_ctxsw_zcull_size(struct gk20a *g, struct gr_gk20a *gr);
328 int gr_gk20a_bind_ctxsw_zcull(struct gk20a *g, struct gr_gk20a *gr,
329                         struct channel_gk20a *c, u64 zcull_va, u32 mode);
330 int gr_gk20a_get_zcull_info(struct gk20a *g, struct gr_gk20a *gr,
331                         struct gr_zcull_info *zcull_params);
332 /* zbc */
333 int gr_gk20a_add_zbc(struct gk20a *g, struct gr_gk20a *gr,
334                         struct zbc_entry *zbc_val);
335 int gr_gk20a_query_zbc(struct gk20a *g, struct gr_gk20a *gr,
336                         struct zbc_query_params *query_params);
337 int gk20a_gr_zbc_set_table(struct gk20a *g, struct gr_gk20a *gr,
338                         struct zbc_entry *zbc_val);
339 /* pmu */
340 int gr_gk20a_fecs_get_reglist_img_size(struct gk20a *g, u32 *size);
341 int gr_gk20a_fecs_set_reglist_bind_inst(struct gk20a *g, phys_addr_t addr);
342 int gr_gk20a_fecs_set_reglist_virual_addr(struct gk20a *g, u64 pmu_va);
343
344 void gr_gk20a_init_elcg_mode(struct gk20a *g, u32 mode, u32 engine);
345 void gr_gk20a_init_blcg_mode(struct gk20a *g, u32 mode, u32 engine);
346
347 /* sm */
348 bool gk20a_gr_sm_debugger_attached(struct gk20a *g);
349
350 #define gr_gk20a_elpg_protected_call(g, func) \
351         ({ \
352                 int err; \
353                 mutex_lock(&g->pmu.pg_init_mutex); \
354                 gk20a_pmu_disable_elpg(g); \
355                 err = func; \
356                 gk20a_pmu_enable_elpg(g); \
357                 mutex_unlock(&g->pmu.pg_init_mutex); \
358                 err; \
359         })
360
361 int gk20a_gr_suspend(struct gk20a *g);
362
363 struct nvhost_dbg_gpu_reg_op;
364 int gr_gk20a_exec_ctx_ops(struct channel_gk20a *ch,
365                           struct nvhost_dbg_gpu_reg_op *ctx_ops, u32 num_ops,
366                           u32 num_ctx_wr_ops, u32 num_ctx_rd_ops);
367 int gr_gk20a_get_ctx_buffer_offsets(struct gk20a *g,
368                                     u32 addr,
369                                     u32 max_offsets,
370                                     u32 *offsets, u32 *offset_addrs,
371                                     u32 *num_offsets,
372                                     bool is_quad, u32 quad);
373
374 #endif /*__GR_GK20A_H__*/