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