gpu: nvgpu: create sync_fence only if needed
[linux-3.10.git] / drivers / gpu / nvgpu / gk20a / channel_gk20a.h
1 /*
2  * GK20A graphics channel
3  *
4  * Copyright (c) 2011-2015, 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 CHANNEL_GK20A_H
19 #define CHANNEL_GK20A_H
20
21 #include <linux/log2.h>
22 #include <linux/mutex.h>
23 #include <linux/poll.h>
24 #include <linux/semaphore.h>
25 #include <linux/slab.h>
26 #include <linux/spinlock.h>
27 #include <linux/wait.h>
28 #include <uapi/linux/nvgpu.h>
29
30 struct gk20a;
31 struct gr_gk20a;
32 struct dbg_session_gk20a;
33 struct gk20a_fence;
34
35 #include "channel_sync_gk20a.h"
36
37 #include "mm_gk20a.h"
38 #include "gr_gk20a.h"
39 #include "fence_gk20a.h"
40
41 struct gpfifo {
42         u32 entry0;
43         u32 entry1;
44 };
45
46 struct notification {
47         struct {
48                 u32 nanoseconds[2];
49         } timestamp;
50         u32 info32;
51         u16 info16;
52         u16 status;
53 };
54
55 struct fence {
56         u32 hw_chid;
57         u32 syncpt_val;
58 };
59
60 /* contexts associated with a channel */
61 struct channel_ctx_gk20a {
62         struct gr_ctx_desc      *gr_ctx;
63         struct patch_desc       patch_ctx;
64         struct zcull_ctx_desc   zcull_ctx;
65         u64     global_ctx_buffer_va[NR_GLOBAL_CTX_BUF_VA];
66         u64     global_ctx_buffer_size[NR_GLOBAL_CTX_BUF_VA];
67         bool    global_ctx_buffer_mapped;
68 };
69
70 struct channel_gk20a_job {
71         struct mapped_buffer_node **mapped_buffers;
72         int num_mapped_buffers;
73         struct gk20a_fence *pre_fence;
74         struct gk20a_fence *post_fence;
75         struct priv_cmd_entry *wait_cmd;
76         struct priv_cmd_entry *incr_cmd;
77         struct list_head list;
78 };
79
80 struct channel_gk20a_poll_events {
81         struct mutex lock;
82         bool events_enabled;
83         int num_pending_events;
84 };
85
86 /* this is the priv element of struct nvhost_channel */
87 struct channel_gk20a {
88         struct gk20a *g; /* set only when channel is active */
89
90         struct list_head free_chs;
91
92         spinlock_t ref_obtain_lock;
93         bool referenceable;
94         atomic_t ref_count;
95         wait_queue_head_t ref_count_dec_wq;
96
97         int hw_chid;
98         bool bound;
99         bool first_init;
100         bool vpr;
101         bool cde;
102         pid_t pid;
103         struct mutex ioctl_lock;
104
105         int tsgid;
106         struct list_head ch_entry; /* channel's entry in TSG */
107
108         struct list_head jobs;
109         struct mutex jobs_lock;
110         struct mutex submit_lock;
111
112         struct vm_gk20a *vm;
113
114         struct gpfifo_desc gpfifo;
115
116         struct channel_ctx_gk20a ch_ctx;
117
118         struct mem_desc inst_block;
119         struct mem_desc_sub ramfc;
120
121         void *userd_cpu_va;
122         u64 userd_iova;
123         u64 userd_gpu_va;
124
125         s32 num_objects;
126         u32 obj_class;  /* we support only one obj per channel */
127
128         struct priv_cmd_queue priv_cmd_q;
129
130         wait_queue_head_t notifier_wq;
131         wait_queue_head_t semaphore_wq;
132         wait_queue_head_t submit_wq;
133
134         u32 timeout_accumulated_ms;
135         u32 timeout_gpfifo_get;
136
137         bool cmds_pending;
138         struct {
139                 /* These fences should be accessed with submit_lock held. */
140                 struct gk20a_fence *pre_fence;
141                 struct gk20a_fence *post_fence;
142         } last_submit;
143
144         void (*remove_support)(struct channel_gk20a *);
145 #if defined(CONFIG_GK20A_CYCLE_STATS)
146         struct {
147         void *cyclestate_buffer;
148         u32 cyclestate_buffer_size;
149         struct dma_buf *cyclestate_buffer_handler;
150         struct mutex cyclestate_buffer_mutex;
151         } cyclestate;
152
153         struct mutex cs_client_mutex;
154         struct gk20a_cs_snapshot_client *cs_client;
155 #endif
156         struct mutex dbg_s_lock;
157         struct list_head dbg_s_list;
158
159         bool has_timedout;
160         u32 timeout_ms_max;
161         bool timeout_debug_dump;
162
163         struct dma_buf *error_notifier_ref;
164         struct nvgpu_notification *error_notifier;
165         void *error_notifier_va;
166
167         struct gk20a_channel_sync *sync;
168
169 #ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
170         u64 virt_ctx;
171 #endif
172
173         /* event support */
174         struct channel_gk20a_poll_events poll_events;
175
176         /* signal channel owner via a callback, if set, in gk20a_channel_update
177          * via schedule_work */
178         void (*update_fn)(struct channel_gk20a *, void *);
179         void *update_fn_data;
180         spinlock_t update_fn_lock; /* make access to the two above atomic */
181         struct work_struct update_fn_work;
182 };
183
184 static inline bool gk20a_channel_as_bound(struct channel_gk20a *ch)
185 {
186         return !!ch->vm;
187 }
188 int channel_gk20a_commit_va(struct channel_gk20a *c);
189 int gk20a_init_channel_support(struct gk20a *, u32 chid);
190
191 /* must be inside gk20a_busy()..gk20a_idle() */
192 void gk20a_channel_close(struct channel_gk20a *ch);
193
194 bool gk20a_channel_update_and_check_timeout(struct channel_gk20a *ch,
195                                             u32 timeout_delta_ms);
196 void gk20a_disable_channel(struct channel_gk20a *ch,
197                            bool wait_for_finish,
198                            unsigned long finish_timeout);
199 void gk20a_channel_abort(struct channel_gk20a *ch);
200 int gk20a_channel_finish(struct channel_gk20a *ch, unsigned long timeout);
201 void gk20a_set_error_notifier(struct channel_gk20a *ch, __u32 error);
202 void gk20a_channel_semaphore_wakeup(struct gk20a *g);
203 int gk20a_channel_alloc_priv_cmdbuf(struct channel_gk20a *c, u32 size,
204                              struct priv_cmd_entry **entry);
205
206 int gk20a_channel_suspend(struct gk20a *g);
207 int gk20a_channel_resume(struct gk20a *g);
208
209 /* Channel file operations */
210 int gk20a_channel_open(struct inode *inode, struct file *filp);
211 int gk20a_channel_open_ioctl(struct gk20a *g,
212                 struct nvgpu_channel_open_args *args);
213 long gk20a_channel_ioctl(struct file *filp,
214                          unsigned int cmd,
215                          unsigned long arg);
216 int gk20a_channel_release(struct inode *inode, struct file *filp);
217 struct channel_gk20a *gk20a_get_channel_from_file(int fd);
218 void gk20a_channel_update(struct channel_gk20a *c, int nr_completed);
219 unsigned int gk20a_channel_poll(struct file *filep, poll_table *wait);
220 void gk20a_channel_event(struct channel_gk20a *ch);
221
222 void gk20a_init_channel(struct gpu_ops *gops);
223
224 /* returns ch if reference was obtained */
225 struct channel_gk20a *__must_check _gk20a_channel_get(struct channel_gk20a *ch,
226                                                       const char *caller);
227 #define gk20a_channel_get(ch) _gk20a_channel_get(ch, __func__)
228
229
230 void _gk20a_channel_put(struct channel_gk20a *ch, const char *caller);
231 #define gk20a_channel_put(ch) _gk20a_channel_put(ch, __func__)
232
233 int gk20a_wait_channel_idle(struct channel_gk20a *ch);
234 struct channel_gk20a *gk20a_open_new_channel(struct gk20a *g);
235 struct channel_gk20a *gk20a_open_new_channel_with_cb(struct gk20a *g,
236                 void (*update_fn)(struct channel_gk20a *, void *),
237                 void *update_fn_data);
238 void channel_gk20a_unbind(struct channel_gk20a *ch_gk20a);
239
240 int gk20a_submit_channel_gpfifo(struct channel_gk20a *c,
241                                 struct nvgpu_gpfifo *gpfifo,
242                                 struct nvgpu_submit_gpfifo_args *args,
243                                 u32 num_entries,
244                                 u32 flags,
245                                 struct nvgpu_fence *fence,
246                                 struct gk20a_fence **fence_out,
247                                 bool force_need_sync_fence);
248
249 int gk20a_alloc_channel_gpfifo(struct channel_gk20a *c,
250                                struct nvgpu_alloc_gpfifo_args *args);
251
252 void channel_gk20a_unbind(struct channel_gk20a *ch_gk20a);
253 void channel_gk20a_disable(struct channel_gk20a *ch);
254 int channel_gk20a_alloc_inst(struct gk20a *g, struct channel_gk20a *ch);
255 void channel_gk20a_free_inst(struct gk20a *g, struct channel_gk20a *ch);
256 int channel_gk20a_setup_ramfc(struct channel_gk20a *c,
257                         u64 gpfifo_base, u32 gpfifo_entries, u32 flags);
258 void channel_gk20a_enable(struct channel_gk20a *ch);
259 #endif /* CHANNEL_GK20A_H */