acef9038c4cb7689d2bd04706abb010fae56d7a1
[linux-3.10.git] / drivers / video / tegra / host / gk20a / gk20a.h
1 /*
2  * drivers/video/tegra/host/gk20a/gk20a.h
3  *
4  * GK20A Graphics
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 _NVHOST_GK20A_H_
22 #define _NVHOST_GK20A_H_
23
24
25 struct gk20a;
26 struct fifo_gk20a;
27 struct channel_gk20a;
28 struct gr_gk20a;
29 struct sim_gk20a;
30
31 #include <linux/tegra-soc.h>
32 #include <linux/spinlock.h>
33 #include <linux/nvhost_gpu_ioctl.h>
34 #include "clk_gk20a.h"
35 #include "fifo_gk20a.h"
36 #include "gr_gk20a.h"
37 #include "sim_gk20a.h"
38 #include "intr_gk20a.h"
39 #include "pmu_gk20a.h"
40 #include "priv_ring_gk20a.h"
41 #include "therm_gk20a.h"
42
43 #include "../../../../../arch/arm/mach-tegra/iomap.h"
44
45 extern struct platform_device tegra_gk20a_device;
46 extern struct nvhost_device_data tegra_gk20a_info;
47
48 static inline bool is_gk20a_module(struct platform_device *dev)
49 {
50         return &tegra_gk20a_info == nvhost_get_devdata(dev);
51 }
52
53 struct cooling_device_gk20a {
54         struct thermal_cooling_device *gk20a_cooling_dev;
55         unsigned int gk20a_freq_state;
56         unsigned int gk20a_freq_table_size;
57         struct gk20a *g;
58 };
59
60 struct gk20a {
61         struct nvhost_master *host;
62         struct platform_device *dev;
63
64         struct resource *reg_mem;
65         void __iomem *regs;
66
67         struct resource *bar1_mem;
68         void __iomem *bar1;
69
70         bool power_on;
71         bool irq_requested;
72
73         struct clk_gk20a clk;
74         struct fifo_gk20a fifo;
75         struct gr_gk20a gr;
76         struct sim_gk20a sim;
77         struct mm_gk20a mm;
78         struct pmu_gk20a pmu;
79         struct cooling_device_gk20a gk20a_cdev;
80
81         /* Save pmu fw here so that it lives cross suspend/resume.
82            pmu suspend destroys all pmu sw/hw states. Loading pmu
83            fw in resume crashes when the resume is from sys_exit. */
84         const struct firmware *pmu_fw;
85
86         u32 gr_idle_timeout_default;
87         u32 timeouts_enabled;
88
89         bool slcg_enabled;
90         bool blcg_enabled;
91         bool elcg_enabled;
92         bool elpg_enabled;
93
94 #ifdef CONFIG_DEBUG_FS
95         spinlock_t debugfs_lock;
96         struct dentry *debugfs_ltc_enabled;
97         struct dentry *debugfs_timeouts_enabled;
98         struct dentry *debugfs_gr_idle_timeout_default;
99 #endif
100         struct gk20a_ctxsw_ucode_info ctxsw_ucode_info;
101
102         /* held while manipulating # of debug/profiler sessions present */
103         /* also prevents debug sessions from attaching until released */
104         struct mutex dbg_sessions_lock;
105         int dbg_sessions; /* number attached */
106         int dbg_powergating_disabled_refcount; /*refcount for pg disable */
107
108         void (*remove_support)(struct platform_device *);
109
110         struct notifier_block system_suspend_notifier;
111         u64 pg_ingating_time_us;
112         u64 pg_ungating_time_us;
113         u32 pg_gating_cnt;
114
115         spinlock_t mc_enable_lock;
116
117         struct nvhost_gpu_characteristics gpu_characteristics;
118 };
119
120 static inline unsigned long gk20a_get_gr_idle_timeout(struct gk20a *g)
121 {
122         return g->timeouts_enabled ?
123                 g->gr_idle_timeout_default : MAX_SCHEDULE_TIMEOUT;
124 }
125
126 static inline struct gk20a *get_gk20a(struct platform_device *dev)
127 {
128         return (struct gk20a *)nvhost_get_private_data(dev);
129 }
130
131 enum BAR0_DEBUG_OPERATION {
132         BARO_ZERO_NOP = 0,
133         OP_END = 'DONE',
134         BAR0_READ32 = '0R32',
135         BAR0_WRITE32 = '0W32',
136 };
137
138 struct share_buffer_head {
139         enum BAR0_DEBUG_OPERATION operation;
140 /* size of the operation item */
141         u32 size;
142         u32 completed;
143         u32 failed;
144         u64 context;
145         u64 completion_callback;
146 };
147
148 struct gk20a_cyclestate_buffer_elem {
149         struct share_buffer_head        head;
150 /* in */
151         u64 p_data;
152         u64 p_done;
153         u32 offset_bar0;
154         u16 first_bit;
155         u16 last_bit;
156 /* out */
157 /* keep 64 bits to be consistent */
158         u64 data;
159 };
160
161 extern const struct nvhost_as_moduleops tegra_gk20a_as_ops;
162
163 /* register accessors */
164 static inline void gk20a_writel(struct gk20a *g, u32 r, u32 v)
165 {
166         nvhost_dbg(dbg_reg, " r=0x%x v=0x%x", r, v);
167         writel(v, g->regs + r);
168 }
169 static inline u32 gk20a_readl(struct gk20a *g, u32 r)
170 {
171         u32 v = readl(g->regs + r);
172         nvhost_dbg(dbg_reg, " r=0x%x v=0x%x", r, v);
173         return v;
174 }
175
176 static inline void gk20a_bar1_writel(struct gk20a *g, u32 b, u32 v)
177 {
178         nvhost_dbg(dbg_reg, " b=0x%x v=0x%x", b, v);
179         writel(v, g->bar1 + b);
180 }
181
182 static inline u32 gk20a_bar1_readl(struct gk20a *g, u32 b)
183 {
184         u32 v = readl(g->bar1 + b);
185         nvhost_dbg(dbg_reg, " b=0x%x v=0x%x", b, v);
186         return v;
187 }
188
189 /* convenience */
190 static inline struct device *dev_from_gk20a(struct gk20a *g)
191 {
192         return &g->dev->dev;
193 }
194 static inline struct nvhost_syncpt *syncpt_from_gk20a(struct gk20a* g)
195 {
196         return &(nvhost_get_host(g->dev)->syncpt);
197 }
198 static inline struct mem_mgr *mem_mgr_from_g(struct gk20a* g)
199 {
200         return nvhost_get_host(g->dev)->memmgr;
201 }
202
203 static inline u32 u64_hi32(u64 n)
204 {
205         return (u32)((n >> 32) & ~(u32)0);
206 }
207
208 static inline u32 u64_lo32(u64 n)
209 {
210         return (u32)(n & ~(u32)0);
211 }
212
213 static inline u32 set_field(u32 val, u32 mask, u32 field)
214 {
215         return ((val & ~mask) | field);
216 }
217
218 /* invalidate channel lookup tlb */
219 static inline void gk20a_gr_flush_channel_tlb(struct gr_gk20a *gr)
220 {
221         spin_lock(&gr->ch_tlb_lock);
222         memset(gr->chid_tlb, 0,
223                 sizeof(struct gr_channel_map_tlb_entry) *
224                 GR_CHANNEL_MAP_TLB_SIZE);
225         spin_unlock(&gr->ch_tlb_lock);
226 }
227
228 /* This function can be called from two places, whichever comes first.
229  * 1. nvhost calls this for gk20a driver init when client opens first gk20a channel.
230  * 2. client opens gk20a ctrl node.
231  */
232 int nvhost_gk20a_init(struct platform_device *dev);
233 void nvhost_gk20a_deinit(struct platform_device *dev);
234
235 /* classes that the device supports */
236 /* TBD: get these from an open-sourced SDK? */
237 enum {
238         KEPLER_C                  = 0xA297,
239         FERMI_TWOD_A              = 0x902D,
240         KEPLER_COMPUTE_A          = 0xA0C0,
241         KEPLER_INLINE_TO_MEMORY_A = 0xA040,
242         KEPLER_DMA_COPY_A         = 0xA0B5, /*not sure about this one*/
243 };
244
245 #if defined (CONFIG_TEGRA_GK20A_PMU)
246 static inline int support_gk20a_pmu(void)
247 {
248         return 1;
249 }
250 #else
251 static inline int support_gk20a_pmu(void){return 0;}
252 #endif
253
254 int nvhost_gk20a_finalize_poweron(struct platform_device *dev);
255 int nvhost_gk20a_prepare_poweroff(struct platform_device *dev);
256 void nvhost_gk20a_scale_notify_idle(struct platform_device *pdev);
257 void nvhost_gk20a_scale_notify_busy(struct platform_device *pdev);
258 void nvhost_gk20a_scale_init(struct platform_device *pdev);
259 void nvhost_gk20a_scale_deinit(struct platform_device *pdev);
260
261 void gk20a_create_sysfs(struct platform_device *dev);
262
263 #ifdef CONFIG_DEBUG_FS
264 int clk_gk20a_debugfs_init(struct platform_device *dev);
265 #endif
266
267 extern const struct file_operations tegra_gk20a_ctrl_ops;
268 extern const struct file_operations tegra_gk20a_dbg_gpu_ops;
269 extern const struct file_operations tegra_gk20a_prof_gpu_ops;
270
271 struct nvhost_hwctx_handler *nvhost_gk20a_alloc_hwctx_handler(u32 syncpt,
272                 u32 waitbase, struct nvhost_channel *ch);
273
274 #define GK20A_BAR0_IORESOURCE_MEM 0
275 #define GK20A_BAR1_IORESOURCE_MEM 1
276 #define GK20A_SIM_IORESOURCE_MEM 2
277 #define TEGRA_GK20A_SIM_BASE 0x538F0000 /*tbd: get from iomap.h */
278 #define TEGRA_GK20A_SIM_SIZE 0x1000     /*tbd: this is a high-side guess */
279
280 void gk20a_busy(struct platform_device *pdev);
281 void gk20a_idle(struct platform_device *pdev);
282 void gk20a_disable(struct gk20a *g, u32 units);
283 void gk20a_enable(struct gk20a *g, u32 units);
284 void gk20a_reset(struct gk20a *g, u32 units);
285
286 #define NVHOST_GPU_ARCHITECTURE_SHIFT 4
287
288 /* constructs unique and compact GPUID from nvhost_gpu_characteristics
289  * arch/impl fields */
290 #define GK20A_GPUID(arch, impl) ((u32) ((arch) | (impl)))
291
292 #define GK20A_GPUID_GK20A \
293         GK20A_GPUID(NVHOST_GPU_ARCH_GK100, NVHOST_GPU_IMPL_GK20A)
294
295 int gk20a_init_gpu_characteristics(struct gk20a *g);
296
297 #endif /* _NVHOST_GK20A_H_ */