video: tegra: gk20a GPC/TPC/SM exception handling, event notifications
[linux-3.10.git] / drivers / video / tegra / host / gk20a / mm_gk20a.h
1 /*
2  * drivers/video/tegra/host/gk20a/mm_gk20a.h
3  *
4  * GK20A memory management
5  *
6  * Copyright (c) 2011-2013, NVIDIA CORPORATION.  All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms and conditions of the GNU General Public License,
10  * version 2, as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along with
18  * this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21 #ifndef __MM_GK20A_H__
22 #define __MM_GK20A_H__
23
24 #include <linux/scatterlist.h>
25 #include "../nvhost_allocator.h"
26
27 /* This "address bit" in the gmmu ptes (and other gk20a accesses)
28  * signals the address as presented should be translated by the SMMU.
29  * Without this bit present gk20a accesses are *not* translated.
30  */
31 /* Hack, get this from manuals somehow... */
32 #define NV_MC_SMMU_VADDR_TRANSLATION_BIT     34
33
34 /* For now keep the size relatively small-ish compared to the full
35  * 40b va.  32GB for now. It consists of two 16GB spaces. */
36 #define NV_GMMU_VA_RANGE        35ULL
37 #define NV_GMMU_VA_IS_UPPER(x)  ((x) >= ((u64)0x1 << (NV_GMMU_VA_RANGE-1)))
38
39 struct mem_desc {
40         struct mem_handle *ref;
41         struct sg_table *sgt;
42         u32 size;
43 };
44
45 struct mem_desc_sub {
46         u32 offset;
47         u32 size;
48 };
49
50 struct gpfifo_desc {
51         struct mem_desc mem;
52         u32 entry_num;
53
54         u32 get;
55         u32 put;
56
57         bool wrap;
58
59         struct gpfifo *cpu_va;
60         u64 gpu_va;
61 };
62
63 struct mmu_desc {
64         struct mem_desc mem;
65         phys_addr_t cpu_pa;
66 };
67
68 struct inst_desc {
69         struct mem_desc mem;
70 };
71
72 struct userd_desc {
73         struct mem_desc mem;
74         void *cpu_va;
75         u64 cpu_pa;
76         u64 gpu_va;
77 };
78
79 struct patch_desc {
80         struct mem_desc mem;
81         void *cpu_va;
82         u64 gpu_va;
83         u32 data_count;
84 };
85
86 struct pmu_mem_desc {
87         struct mem_desc mem;
88         phys_addr_t cpu_pa;
89         u64 pmu_va;
90 };
91
92 struct zcull_ctx_desc {
93         struct mem_desc mem;
94         u64 gpu_va;
95         u32 ctx_attr;
96         u32 ctx_sw_mode;
97 };
98
99 struct pm_ctx_desc {
100         struct mem_desc mem;
101         u64 gpu_va;
102         u32 ctx_attr;
103         u32 ctx_sw_mode;
104 };
105
106 struct gr_ctx_desc {
107         struct mem_desc mem;
108         u64 gpu_va;
109 };
110
111 struct compbit_store_desc {
112         struct mem_desc mem;
113         u64 base_pa;
114         u32 alignment;
115 };
116
117 struct page_table_gk20a {
118         /* backing for */
119         /* Either a *page or a *mem_handle */
120         void *ref;
121         /* track mapping cnt on this page table */
122         u32 ref_cnt;
123         struct sg_table *sgt;
124 };
125
126 enum gmmu_pgsz_gk20a {
127         gmmu_page_size_small = 0,
128         gmmu_page_size_big   = 1,
129         gmmu_nr_page_sizes   = 2
130 };
131
132
133 struct page_directory_gk20a {
134         /* backing for */
135         u32 num_pdes;
136         void *kv;
137         /* Either a *page or a *mem_handle */
138         void *ref;
139         struct sg_table *sgt;
140         struct page_table_gk20a *ptes[gmmu_nr_page_sizes];
141 };
142
143 struct mapped_buffer_node {
144         struct vm_gk20a *vm;
145         struct rb_node node;
146         struct list_head unmap_list;
147         u64 addr;
148         u64 size;
149         struct mem_mgr *memmgr;
150         struct mem_handle *handle_ref;
151         struct sg_table *sgt;
152         struct kref ref;
153         u32 user_mapped;
154         bool own_mem_ref;
155         u32 pgsz_idx;
156         u32 ctag_offset;
157         u32 ctag_lines;
158         u32 flags;
159 };
160
161 struct vm_gk20a {
162         struct mm_gk20a *mm;
163         struct nvhost_as_share *as_share; /* as_share this represents */
164
165         u64 va_start;
166         u64 va_limit;
167
168         int num_user_mapped_buffers;
169
170         bool big_pages;   /* enable large page support */
171         bool enable_ctag;
172         bool tlb_dirty;
173         bool mapped;
174
175         struct mutex update_gmmu_lock;
176
177         struct page_directory_gk20a pdes;
178
179         struct nvhost_allocator vma[gmmu_nr_page_sizes];
180         struct rb_root mapped_buffers;
181
182         u64 (*alloc_va)(struct vm_gk20a *vm, u64 size,
183                         enum gmmu_pgsz_gk20a gmmu_pgsz_idx);
184
185         void (*free_va)(struct vm_gk20a *vm, u64 offset, u64 size,
186                         enum gmmu_pgsz_gk20a pgsz_idx);
187
188         u64 (*map)(struct vm_gk20a *vm,
189                    struct mem_mgr *memmgr,
190                    struct mem_handle *r,
191                    u64 offset_align,
192                    u32 flags /*NVHOST_MAP_BUFFER_FLAGS_*/,
193                    u32 kind,
194                    struct sg_table **sgt,
195                    bool user_mapped,
196                    int rw_flag);
197
198         /* unmap handle from kernel */
199         void (*unmap)(struct vm_gk20a *vm,
200                 u64 offset);
201
202         /* unmap handle from user */
203         void (*unmap_user)(struct vm_gk20a *vm, u64 offset);
204
205         /* get reference to all currently mapped buffers */
206         int (*get_buffers)(struct vm_gk20a *vm,
207                  struct mapped_buffer_node ***mapped_buffers,
208                  int *num_buffers);
209
210         /* put references on the given buffers */
211         void (*put_buffers)(struct vm_gk20a *vm,
212                  struct mapped_buffer_node **mapped_buffers,
213                  int num_buffers);
214
215         /* invalidate tlbs for the vm area */
216         void (*tlb_inval)(struct vm_gk20a *vm);
217
218         /* find buffer corresponding to va */
219         int (*find_buffer)(struct vm_gk20a *vm, u64 gpu_va,
220                         struct mem_mgr **memmgr, struct mem_handle **r,
221                         u64 *offset);
222
223         void (*remove_support)(struct vm_gk20a *vm);
224 };
225
226 struct gk20a;
227 struct channel_gk20a;
228
229 int gk20a_init_mm_support(struct gk20a *g);
230 int gk20a_init_mm_setup_sw(struct gk20a *g);
231 int gk20a_init_bar1_vm(struct mm_gk20a *mm);
232 int gk20a_init_pmu_vm(struct mm_gk20a *mm);
233
234 void gk20a_mm_fb_flush(struct gk20a *g);
235 void gk20a_mm_l2_flush(struct gk20a *g, bool invalidate);
236 void gk20a_mm_l2_invalidate(struct gk20a *g);
237
238 struct mm_gk20a {
239         struct gk20a *g;
240
241         u32 big_page_size;
242         u32 pde_stride;
243         u32 pde_stride_shift;
244
245         struct {
246                 u32 order;
247                 u32 num_ptes;
248         } page_table_sizing[gmmu_nr_page_sizes];
249
250
251         struct {
252                 u64 size;
253         } channel;
254
255         struct {
256                 u32 aperture_size;
257                 struct vm_gk20a vm;
258                 struct inst_desc inst_block;
259         } bar1;
260
261         struct {
262                 u32 aperture_size;
263                 struct vm_gk20a vm;
264                 struct inst_desc inst_block;
265         } pmu;
266
267         struct mutex tlb_lock;
268         struct mutex l2_op_lock;
269
270         void (*remove_support)(struct mm_gk20a *mm);
271         bool sw_ready;
272 #ifdef CONFIG_DEBUG_FS
273         u32 ltc_enabled;
274         u32 ltc_enabled_debug;
275 #endif
276 };
277
278 int gk20a_mm_init(struct mm_gk20a *mm);
279
280 #define gk20a_from_mm(mm) ((mm)->g)
281 #define gk20a_from_vm(vm) ((vm)->mm->g)
282
283 #define mem_mgr_from_mm(mm) (gk20a_from_mm(mm)->host->memmgr)
284 #define mem_mgr_from_vm(vm) (gk20a_from_vm(vm)->host->memmgr)
285 #define dev_from_vm(vm) dev_from_gk20a(vm->mm->g)
286
287 #define DEFAULT_ALLOC_FLAGS (mem_mgr_flag_uncacheable)
288 #define DEFAULT_ALLOC_ALIGNMENT (4*1024)
289
290 static inline int bar1_aperture_size_mb_gk20a(void)
291 {
292         return 128; /*TBD read this from fuses?*/
293 }
294 /* max address bits */
295 static inline int max_physaddr_bits_gk20a(void)
296 {
297         return 40;/*"old" sys physaddr, meaningful? */
298 }
299 static inline int max_vid_physaddr_bits_gk20a(void)
300 {
301         /* "vid phys" is asid/smmu phys?,
302          * i.e. is this the real sys physaddr? */
303         return 37;
304 }
305 static inline int max_vaddr_bits_gk20a(void)
306 {
307         return 40; /* chopped for area? */
308 }
309
310 #if 0 /*related to addr bits above, concern below TBD on which is accurate */
311 #define bar1_instance_block_shift_gk20a() (max_physaddr_bits_gk20a() -\
312                                            bus_bar1_block_ptr_s())
313 #else
314 #define bar1_instance_block_shift_gk20a() bus_bar1_block_ptr_shift_v()
315 #endif
316
317 void gk20a_mm_dump_vm(struct vm_gk20a *vm,
318                 u64 va_begin, u64 va_end, char *label);
319
320 int gk20a_mm_suspend(struct gk20a *g);
321
322 u64 gk20a_mm_iova_addr(struct scatterlist *sgl);
323
324 void gk20a_mm_ltc_isr(struct gk20a *g);
325
326 bool gk20a_mm_mmu_debug_mode_enabled(struct gk20a *g);
327
328 #endif /*_MM_GK20A_H_ */