664b5ba941c2d24c0d0605a0d2bc38f4b7217d60
[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-2013, 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 #if defined(CONFIG_ARCH_TEGRA_12x_SOC) && defined(CONFIG_TEGRA_SIMULATION_PLATFORM)
26 #define CONFIG_GK20A_SIM 1
27 #else
28 #define CONFIG_GK20A_SIM 0
29 #endif
30
31 struct gk20a;
32 struct fifo_gk20a;
33 struct channel_gk20a;
34 struct gr_gk20a;
35 struct sim_gk20a;
36
37 #include <mach/hardware.h>
38 #include "clk_gk20a.h"
39 #include "fifo_gk20a.h"
40 #include "gr_gk20a.h"
41 #include "sim_gk20a.h"
42 #include "intr_gk20a.h"
43 #include "pmu_gk20a.h"
44 #include "priv_ring_gk20a.h"
45 #include "therm_gk20a.h"
46
47 #include "../../../../../../arch/arm/mach-tegra/iomap.h"
48
49 extern struct platform_device tegra_gk20a_device;
50
51 struct gk20a {
52         struct nvhost_master *host;
53         struct platform_device *dev;
54
55         struct resource *reg_mem;
56         void __iomem *regs;
57
58         struct resource *bar1_mem;
59         void __iomem *bar1;
60
61         bool power_on;
62         bool irq_requested;
63
64         struct clk_gk20a clk;
65         struct fifo_gk20a fifo;
66         struct gr_gk20a gr;
67         struct sim_gk20a sim;
68         struct mm_gk20a mm;
69         struct pmu_gk20a pmu;
70
71         /* Save pmu fw here so that it lives cross suspend/resume.
72            pmu suspend destroys all pmu sw/hw states. Loading pmu
73            fw in resume crashes when the resume is from sys_exit. */
74         const struct firmware *pmu_fw;
75
76         void (*remove_support)(struct platform_device *);
77 };
78
79 static inline struct gk20a *get_gk20a(struct platform_device *dev)
80 {
81         return (struct gk20a *)nvhost_get_private_data(dev);
82 }
83
84 enum BAR0_DEBUG_OPERATION {
85         BARO_ZERO_NOP = 0,
86         OP_END,
87         BAR0_READ32,
88         BAR0_WRITE32,
89 };
90
91 struct share_buffer_head {
92         enum BAR0_DEBUG_OPERATION operation;
93 /* size of the operation item */
94         u32 size;
95         u32 failed;
96         u32 completed;
97 };
98
99 struct gk20a_cyclestate_buffer_elem {
100         struct share_buffer_head        head;
101 /* IN */
102         u32                       offsetBAR0;
103         u16                       firstBit;
104         u16                       lastBit;
105 /* OUT */
106 /* keep 64 bits to be consistent */
107         u64                       data;
108 };
109
110 extern const struct nvhost_as_moduleops gk20a_as_moduleops;
111
112 /* register accessors */
113 static inline void gk20a_writel(struct gk20a *g, u32 r, u32 v)
114 {
115         nvhost_dbg(dbg_reg, " r=0x%x v=0x%x", r, v);
116         writel(v, g->regs + r);
117 }
118 static inline u32 gk20a_readl(struct gk20a *g, u32 r)
119 {
120         u32 v = readl(g->regs + r);
121         nvhost_dbg(dbg_reg, " r=0x%x v=0x%x", r, v);
122         return v;
123 }
124
125 static inline void gk20a_bar1_writel(struct gk20a *g, u32 b, u32 v)
126 {
127         nvhost_dbg(dbg_reg, " b=0x%x v=0x%x", b, v);
128         writel(v, g->bar1 + b);
129 }
130
131 static inline u32 gk20a_bar1_readl(struct gk20a *g, u32 b)
132 {
133         u32 v = readl(g->bar1 + b);
134         nvhost_dbg(dbg_reg, " b=0x%x v=0x%x", b, v);
135         return v;
136 }
137
138 /* convenience */
139 static inline struct device *dev_from_gk20a(struct gk20a *g)
140 {
141         return &g->dev->dev;
142 }
143 static inline struct nvhost_syncpt *syncpt_from_gk20a(struct gk20a* g)
144 {
145         return &(nvhost_get_host(g->dev)->syncpt);
146 }
147 static inline struct mem_mgr *mem_mgr_from_g(struct gk20a* g)
148 {
149         return nvhost_get_host(g->dev)->memmgr;
150 }
151
152 static inline u32 u64_hi32(u64 n)
153 {
154         return (u32)((n >> 32) & ~(u32)0);
155 }
156
157 static inline u32 u64_lo32(u64 n)
158 {
159         return (u32)(n & ~(u32)0);
160 }
161
162 static inline u32 set_field(u32 val, u32 mask, u32 field)
163 {
164         return ((val & ~mask) | field);
165 }
166
167 /* invalidate channel lookup tlb */
168 static inline void gk20a_gr_flush_channel_tlb(struct gr_gk20a *gr)
169 {
170         spin_lock(&gr->ch_tlb_lock);
171         memset(gr->chid_tlb, 0,
172                 sizeof(struct gr_channel_map_tlb_entry) *
173                 GR_CHANNEL_MAP_TLB_SIZE);
174         spin_unlock(&gr->ch_tlb_lock);
175 }
176
177 /* This function can be called from two places, whichever comes first.
178  * 1. nvhost calls this for gk20a driver init when client opens first gk20a channel.
179  * 2. client opens gk20a ctrl node.
180  */
181 int nvhost_gk20a_init(struct platform_device *dev);
182
183 /* classes that the device supports */
184 /* TBD: get these from an open-sourced SDK? */
185 enum {
186         KEPLER_C                  = 0xA297,
187         FERMI_TWOD_A              = 0x902D,
188         KEPLER_COMPUTE_A          = 0xA0C0,
189         KEPLER_INLINE_TO_MEMORY_A = 0xA040,
190         KEPLER_DMA_COPY_A         = 0xA0B5, /*not sure about this one*/
191 };
192
193 #if defined (CONFIG_TEGRA_GK20A_PMU)
194 static inline int support_gk20a_pmu(void)
195 {
196         return 1;
197 }
198 #else
199 static inline int support_gk20a_pmu(void){return 0;}
200 #endif
201
202
203 #endif /* _NVHOST_GK20A_H_ */