40b04107e0922d15196fb634e28786545ca5ba6f
[linux-3.10.git] / drivers / video / tegra / host / gk20a / channel_gk20a.h
1 /*
2  * drivers/video/tegra/host/gk20a/channel_gk20a.h
3  *
4  * GK20A graphics channel
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 __CHANNEL_GK20A_H__
22 #define __CHANNEL_GK20A_H__
23
24 #include <linux/log2.h>
25 #include <linux/slab.h>
26 #include <linux/wait.h>
27 #include <linux/mutex.h>
28 #include <linux/nvhost_ioctl.h>
29 struct gk20a;
30 struct gr_gk20a;
31 struct mem_mgr;
32 struct mem_handle;
33 struct dbg_session_gk20a;
34
35 #include "nvhost_channel.h"
36 #include "nvhost_hwctx.h"
37
38 #include "cdma_gk20a.h"
39 #include "mm_gk20a.h"
40 #include "gr_gk20a.h"
41
42 struct gpfifo {
43         u32 entry0;
44         u32 entry1;
45 };
46
47 struct notification {
48         struct {
49                 u32 nanoseconds[2];
50         } timestamp;
51         u32 info32;
52         u16 info16;
53         u16 status;
54 };
55
56 struct fence {
57         u32 hw_chid;
58         u32 syncpt_val;
59 };
60
61 /* contexts associated with a channel */
62 struct channel_ctx_gk20a {
63         struct gr_ctx_desc      gr_ctx;
64         struct pm_ctx_desc      pm_ctx;
65         struct patch_desc       patch_ctx;
66         struct zcull_ctx_desc   zcull_ctx;
67         u64     global_ctx_buffer_va[NR_GLOBAL_CTX_BUF_VA];
68         bool    global_ctx_buffer_mapped;
69 };
70
71 struct channel_gk20a_job {
72         struct mapped_buffer_node **mapped_buffers;
73         int num_mapped_buffers;
74         struct nvhost_fence fence;
75         struct list_head list;
76 };
77
78 /* this is the priv element of struct nvhost_channel */
79 struct channel_gk20a {
80         struct gk20a *g;
81         bool in_use;
82         int hw_chid;
83         bool bound;
84         bool first_init;
85         bool vpr;
86         pid_t pid;
87
88         struct mem_mgr *memmgr;
89         struct nvhost_channel *ch;
90         struct nvhost_hwctx *hwctx;
91
92         struct list_head jobs;
93         struct mutex jobs_lock;
94
95         struct vm_gk20a *vm;
96
97         struct gpfifo_desc gpfifo;
98
99         struct channel_ctx_gk20a ch_ctx;
100
101         struct inst_desc inst_block;
102         struct mem_desc_sub ramfc;
103
104         void *userd_cpu_va;
105         u64 userd_iova;
106         u64 userd_gpu_va;
107
108         s32 num_objects;
109
110         struct priv_cmd_queue priv_cmd_q;
111
112         wait_queue_head_t notifier_wq;
113         wait_queue_head_t semaphore_wq;
114         wait_queue_head_t submit_wq;
115
116         bool cmds_pending;
117         struct {
118                 bool valid;
119                 bool wfi; /* was issued with preceding wfi */
120                 u32 syncpt_value;
121                 u32 syncpt_id;
122         } last_submit_fence;
123
124         void (*remove_support)(struct channel_gk20a *);
125 #if defined(CONFIG_TEGRA_GPU_CYCLE_STATS)
126         struct {
127         void *cyclestate_buffer;
128         u32 cyclestate_buffer_size;
129         struct mem_handle *cyclestate_buffer_handler;
130         struct mutex cyclestate_buffer_mutex;
131         } cyclestate;
132 #endif
133         struct mutex dbg_s_lock;
134         struct list_head dbg_s_list;
135 };
136
137 static inline bool gk20a_channel_as_bound(struct channel_gk20a *ch)
138 {
139         return !!ch->hwctx->as_share;
140 }
141 int channel_gk20a_commit_va(struct channel_gk20a *c);
142
143 struct nvhost_unmap_buffer_args;
144 struct nvhost_zbc_query_table_args;
145 struct nvhost_fence;
146 struct nvhost_alloc_gpfifo_args;
147 struct nvhost_map_buffer_args;
148 struct nvhost_wait_args;
149 struct nvhost_zcull_bind_args;
150 struct nvhost_gpfifo;
151 struct nvhost_zbc_set_table_args;
152 struct nvhost_cycle_stats_args;
153 struct nvhost_set_priority_args;
154
155 #if defined(CONFIG_TEGRA_GK20A)
156 void gk20a_channel_update(struct channel_gk20a *c);
157 #else
158 static inline void gk20a_channel_update(struct channel_gk20a *c)
159 {
160 }
161 #endif
162
163 int gk20a_init_channel_support(struct gk20a *, u32 chid);
164 int gk20a_channel_init(struct nvhost_channel *ch, struct nvhost_master *host,
165                        int index);
166 int gk20a_channel_alloc_obj(struct nvhost_channel *channel,
167                         u32 class_num, u32 *obj_id, u32 vaspace_share);
168 int gk20a_channel_free_obj(struct nvhost_channel *channel,
169                         u32 obj_id);
170 struct nvhost_hwctx *gk20a_open_channel(struct nvhost_channel *ch,
171                         struct nvhost_hwctx *ctx);
172 int gk20a_alloc_channel_gpfifo(struct channel_gk20a *c,
173                         struct nvhost_alloc_gpfifo_args *args);
174 int gk20a_submit_channel_gpfifo(struct channel_gk20a *c,
175                         struct nvhost_gpfifo *gpfifo, u32 num_entries,
176                         struct nvhost_fence *fence, u32 flags);
177 void gk20a_free_channel(struct nvhost_hwctx *ctx, bool finish);
178 int gk20a_init_error_notifier(struct nvhost_hwctx *ctx, u32 memhandle,
179                         u64 offset);
180 void gk20a_free_error_notifiers(struct nvhost_hwctx *ctx);
181 void gk20a_disable_channel(struct channel_gk20a *ch,
182                            bool wait_for_finish,
183                            unsigned long finish_timeout);
184 void gk20a_disable_channel_no_update(struct channel_gk20a *ch);
185 int gk20a_channel_finish(struct channel_gk20a *ch, unsigned long timeout);
186 void gk20a_set_error_notifier(struct nvhost_hwctx *ctx, __u32 error);
187 int gk20a_channel_wait(struct channel_gk20a *ch,
188                        struct nvhost_wait_args *args);
189 void gk20a_channel_semaphore_wakeup(struct gk20a *g);
190 int gk20a_channel_zcull_bind(struct channel_gk20a *ch,
191                             struct nvhost_zcull_bind_args *args);
192 int gk20a_channel_zbc_set_table(struct channel_gk20a *ch,
193                             struct nvhost_zbc_set_table_args *args);
194 int gk20a_channel_zbc_query_table(struct channel_gk20a *ch,
195                             struct nvhost_zbc_query_table_args *args);
196 int gk20a_channel_set_priority(struct channel_gk20a *ch,
197                        u32 priority);
198 #if defined(CONFIG_TEGRA_GPU_CYCLE_STATS)
199 int gk20a_channel_cycle_stats(struct channel_gk20a *ch,
200                         struct nvhost_cycle_stats_args *args);
201 #endif
202
203 int gk20a_channel_suspend(struct gk20a *g);
204 int gk20a_channel_resume(struct gk20a *g);
205
206 static inline
207 struct mem_mgr *gk20a_channel_mem_mgr(struct channel_gk20a *ch)
208 {
209         return ch->hwctx->memmgr;
210 }
211
212 static inline
213 struct nvhost_master *host_from_gk20a_channel(struct channel_gk20a *ch)
214 {
215         return nvhost_get_host(ch->ch->dev);
216 }
217
218 #endif /*__CHANNEL_GK20A_H__*/