gpu: nvgpu: create new nvgpu ioctl header
[linux-3.10.git] / drivers / gpu / nvgpu / gk20a / channel_gk20a.h
1 /*
2  * GK20A graphics channel
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 CHANNEL_GK20A_H
19 #define CHANNEL_GK20A_H
20
21 #include <linux/log2.h>
22 #include <linux/slab.h>
23 #include <linux/wait.h>
24 #include <linux/mutex.h>
25 #include <uapi/linux/nvgpu.h>
26 #include <linux/poll.h>
27
28 struct gk20a;
29 struct gr_gk20a;
30 struct dbg_session_gk20a;
31 struct gk20a_fence;
32
33 #include "channel_sync_gk20a.h"
34
35 #include "mm_gk20a.h"
36 #include "gr_gk20a.h"
37 #include "fence_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 struct channel_gk20a_poll_events {
78         struct mutex lock;
79         bool events_enabled;
80         int num_pending_events;
81 };
82
83 /* this is the priv element of struct nvhost_channel */
84 struct channel_gk20a {
85         struct gk20a *g;
86         bool in_use;
87         int hw_chid;
88         bool bound;
89         bool first_init;
90         bool vpr;
91         pid_t pid;
92
93         int tsgid;
94         struct list_head ch_entry; /* channel's entry in TSG */
95
96         struct list_head jobs;
97         struct mutex jobs_lock;
98         struct mutex submit_lock;
99
100         struct vm_gk20a *vm;
101
102         struct gpfifo_desc gpfifo;
103
104         struct channel_ctx_gk20a ch_ctx;
105
106         struct inst_desc inst_block;
107         struct mem_desc_sub ramfc;
108
109         void *userd_cpu_va;
110         u64 userd_iova;
111         u64 userd_gpu_va;
112
113         s32 num_objects;
114         u32 obj_class;  /* we support only one obj per channel */
115
116         struct priv_cmd_queue priv_cmd_q;
117
118         wait_queue_head_t notifier_wq;
119         wait_queue_head_t semaphore_wq;
120         wait_queue_head_t submit_wq;
121
122         u32 timeout_accumulated_ms;
123         u32 timeout_gpfifo_get;
124
125         bool cmds_pending;
126         struct {
127                 /* These fences should be accessed with submit_lock held. */
128                 struct gk20a_fence *pre_fence;
129                 struct gk20a_fence *post_fence;
130         } last_submit;
131
132         void (*remove_support)(struct channel_gk20a *);
133 #if defined(CONFIG_GK20A_CYCLE_STATS)
134         struct {
135         void *cyclestate_buffer;
136         u32 cyclestate_buffer_size;
137         struct dma_buf *cyclestate_buffer_handler;
138         struct mutex cyclestate_buffer_mutex;
139         } cyclestate;
140 #endif
141         struct mutex dbg_s_lock;
142         struct list_head dbg_s_list;
143
144         bool has_timedout;
145         u32 timeout_ms_max;
146         bool timeout_debug_dump;
147
148         struct dma_buf *error_notifier_ref;
149         struct nvgpu_notification *error_notifier;
150         void *error_notifier_va;
151
152         struct gk20a_channel_sync *sync;
153
154 #ifdef CONFIG_TEGRA_GR_VIRTUALIZATION
155         u64 virt_ctx;
156 #endif
157
158         /* event support */
159         struct channel_gk20a_poll_events poll_events;
160 };
161
162 static inline bool gk20a_channel_as_bound(struct channel_gk20a *ch)
163 {
164         return !!ch->vm;
165 }
166 int channel_gk20a_commit_va(struct channel_gk20a *c);
167 int gk20a_init_channel_support(struct gk20a *, u32 chid);
168 void gk20a_free_channel(struct channel_gk20a *ch, bool finish);
169 bool gk20a_channel_update_and_check_timeout(struct channel_gk20a *ch,
170                                             u32 timeout_delta_ms);
171 void gk20a_disable_channel(struct channel_gk20a *ch,
172                            bool wait_for_finish,
173                            unsigned long finish_timeout);
174 void gk20a_channel_abort(struct channel_gk20a *ch);
175 int gk20a_channel_finish(struct channel_gk20a *ch, unsigned long timeout);
176 void gk20a_set_error_notifier(struct channel_gk20a *ch, __u32 error);
177 void gk20a_channel_semaphore_wakeup(struct gk20a *g);
178 int gk20a_channel_alloc_priv_cmdbuf(struct channel_gk20a *c, u32 size,
179                              struct priv_cmd_entry **entry);
180
181 int gk20a_channel_suspend(struct gk20a *g);
182 int gk20a_channel_resume(struct gk20a *g);
183
184 /* Channel file operations */
185 int gk20a_channel_open(struct inode *inode, struct file *filp);
186 long gk20a_channel_ioctl(struct file *filp,
187                          unsigned int cmd,
188                          unsigned long arg);
189 int gk20a_channel_release(struct inode *inode, struct file *filp);
190 struct channel_gk20a *gk20a_get_channel_from_file(int fd);
191 void gk20a_channel_update(struct channel_gk20a *c, int nr_completed);
192 unsigned int gk20a_channel_poll(struct file *filep, poll_table *wait);
193 void gk20a_channel_event(struct channel_gk20a *ch);
194
195 void gk20a_init_channel(struct gpu_ops *gops);
196
197 int gk20a_wait_channel_idle(struct channel_gk20a *ch);
198 struct channel_gk20a *gk20a_open_new_channel(struct gk20a *g);
199 void channel_gk20a_unbind(struct channel_gk20a *ch_gk20a);
200
201 int gk20a_submit_channel_gpfifo(struct channel_gk20a *c,
202                                 struct nvgpu_gpfifo *gpfifo,
203                                 u32 num_entries,
204                                 u32 flags,
205                                 struct nvgpu_fence *fence,
206                                 struct gk20a_fence **fence_out);
207
208 int gk20a_alloc_channel_gpfifo(struct channel_gk20a *c,
209                                struct nvgpu_alloc_gpfifo_args *args);
210
211 void channel_gk20a_unbind(struct channel_gk20a *ch_gk20a);
212 void channel_gk20a_disable(struct channel_gk20a *ch);
213 int channel_gk20a_alloc_inst(struct gk20a *g, struct channel_gk20a *ch);
214 void channel_gk20a_free_inst(struct gk20a *g, struct channel_gk20a *ch);
215 int channel_gk20a_setup_ramfc(struct channel_gk20a *c,
216                         u64 gpfifo_base, u32 gpfifo_entries);
217
218 #endif /* CHANNEL_GK20A_H */