gpu: nvgpu: Add gk20a_fence type
[linux-3.10.git] / drivers / gpu / nvgpu / gk20a / channel_gk20a.h
1 /*
2  * drivers/video/tegra/host/gk20a/channel_gk20a.h
3  *
4  * GK20A graphics channel
5  *
6  * Copyright (c) 2011-2014, 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 dbg_session_gk20a;
32 struct gk20a_fence;
33
34 #include "channel_sync_gk20a.h"
35
36 #include "mm_gk20a.h"
37 #include "gr_gk20a.h"
38
39 struct gpfifo {
40         u32 entry0;
41         u32 entry1;
42 };
43
44 struct notification {
45         struct {
46                 u32 nanoseconds[2];
47         } timestamp;
48         u32 info32;
49         u16 info16;
50         u16 status;
51 };
52
53 struct fence {
54         u32 hw_chid;
55         u32 syncpt_val;
56 };
57
58 /* contexts associated with a channel */
59 struct channel_ctx_gk20a {
60         struct gr_ctx_desc      *gr_ctx;
61         struct pm_ctx_desc      pm_ctx;
62         struct patch_desc       patch_ctx;
63         struct zcull_ctx_desc   zcull_ctx;
64         u64     global_ctx_buffer_va[NR_GLOBAL_CTX_BUF_VA];
65         u64     global_ctx_buffer_size[NR_GLOBAL_CTX_BUF_VA];
66         bool    global_ctx_buffer_mapped;
67 };
68
69 struct channel_gk20a_job {
70         struct mapped_buffer_node **mapped_buffers;
71         int num_mapped_buffers;
72         struct gk20a_fence *pre_fence;
73         struct gk20a_fence *post_fence;
74         struct list_head list;
75 };
76
77 /* this is the priv element of struct nvhost_channel */
78 struct channel_gk20a {
79         struct gk20a *g;
80         bool in_use;
81         int hw_chid;
82         bool bound;
83         bool first_init;
84         bool vpr;
85         pid_t pid;
86
87         int tsgid;
88         struct list_head ch_entry; /* channel's entry in TSG */
89
90         struct list_head jobs;
91         struct mutex jobs_lock;
92         struct mutex submit_lock;
93
94         struct vm_gk20a *vm;
95
96         struct gpfifo_desc gpfifo;
97
98         struct channel_ctx_gk20a ch_ctx;
99
100         struct inst_desc inst_block;
101         struct mem_desc_sub ramfc;
102
103         void *userd_cpu_va;
104         u64 userd_iova;
105         u64 userd_gpu_va;
106
107         s32 num_objects;
108         u32 obj_class;  /* we support only one obj per channel */
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         u32 timeout_accumulated_ms;
117         u32 timeout_gpfifo_get;
118
119         bool cmds_pending;
120         struct {
121                 /* These fences should be accessed with submit_lock held. */
122                 struct gk20a_fence *pre_fence;
123                 struct gk20a_fence *post_fence;
124         } last_submit;
125
126         void (*remove_support)(struct channel_gk20a *);
127 #if defined(CONFIG_GK20A_CYCLE_STATS)
128         struct {
129         void *cyclestate_buffer;
130         u32 cyclestate_buffer_size;
131         struct dma_buf *cyclestate_buffer_handler;
132         struct mutex cyclestate_buffer_mutex;
133         } cyclestate;
134 #endif
135         struct mutex dbg_s_lock;
136         struct list_head dbg_s_list;
137
138         bool has_timedout;
139         u32 timeout_ms_max;
140         bool timeout_debug_dump;
141
142         struct dma_buf *error_notifier_ref;
143         struct nvhost_notification *error_notifier;
144         void *error_notifier_va;
145
146         struct gk20a_channel_sync *sync;
147 };
148
149 static inline bool gk20a_channel_as_bound(struct channel_gk20a *ch)
150 {
151         return !!ch->vm;
152 }
153 int channel_gk20a_commit_va(struct channel_gk20a *c);
154 int gk20a_init_channel_support(struct gk20a *, u32 chid);
155 void gk20a_free_channel(struct channel_gk20a *ch, bool finish);
156 bool gk20a_channel_update_and_check_timeout(struct channel_gk20a *ch,
157                                             u32 timeout_delta_ms);
158 void gk20a_disable_channel(struct channel_gk20a *ch,
159                            bool wait_for_finish,
160                            unsigned long finish_timeout);
161 void gk20a_channel_abort(struct channel_gk20a *ch);
162 int gk20a_channel_finish(struct channel_gk20a *ch, unsigned long timeout);
163 void gk20a_set_error_notifier(struct channel_gk20a *ch, __u32 error);
164 void gk20a_channel_semaphore_wakeup(struct gk20a *g);
165 int gk20a_channel_alloc_priv_cmdbuf(struct channel_gk20a *c, u32 size,
166                              struct priv_cmd_entry **entry);
167
168 int gk20a_channel_suspend(struct gk20a *g);
169 int gk20a_channel_resume(struct gk20a *g);
170
171 /* Channel file operations */
172 int gk20a_channel_open(struct inode *inode, struct file *filp);
173 long gk20a_channel_ioctl(struct file *filp,
174                          unsigned int cmd,
175                          unsigned long arg);
176 int gk20a_channel_release(struct inode *inode, struct file *filp);
177 struct channel_gk20a *gk20a_get_channel_from_file(int fd);
178 void gk20a_channel_update(struct channel_gk20a *c, int nr_completed);
179
180 void gk20a_init_channel(struct gpu_ops *gops);
181
182 int gk20a_wait_channel_idle(struct channel_gk20a *ch);
183 struct channel_gk20a *gk20a_open_new_channel(struct gk20a *g);
184 void channel_gk20a_unbind(struct channel_gk20a *ch_gk20a);
185
186 int gk20a_submit_channel_gpfifo(struct channel_gk20a *c,
187                                 struct nvhost_gpfifo *gpfifo,
188                                 u32 num_entries,
189                                 u32 flags,
190                                 struct nvhost_fence *fence,
191                                 struct gk20a_fence **fence_out);
192
193 int gk20a_alloc_channel_gpfifo(struct channel_gk20a *c,
194                                struct nvhost_alloc_gpfifo_args *args);
195
196 #endif /*__CHANNEL_GK20A_H__*/