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