ARM: tegra: loki: fix build error due to warning
[linux-3.10.git] / arch / arm / mach-tegra / tegra3_la.c
1 /*
2  * arch/arm/mach-tegra/tegra3_la.c
3  *
4  * Copyright (C) 2012-2013, NVIDIA CORPORATION. All rights reserved.
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/err.h>
20 #include <linux/stringify.h>
21 #include <linux/clk.h>
22 #include <linux/clk/tegra.h>
23 #include <linux/tegra-soc.h>
24 #include <asm/io.h>
25 #include <mach/latency_allowance.h>
26
27 #include "iomap.h"
28 #include "la_priv.h"
29
30 #define T3_MC_LA_AFI_0          0x2e0
31 #define T3_MC_LA_AVPC_ARM7_0    0x2e4
32 #define T3_MC_LA_DC_0           0x2e8
33 #define T3_MC_LA_DC_1           0x2ec
34 #define T3_MC_LA_DC_2           0x2f0
35 #define T3_MC_LA_DCB_0          0x2f4
36 #define T3_MC_LA_DCB_1          0x2f8
37 #define T3_MC_LA_DCB_2          0x2fc
38 #define T3_MC_LA_EPP_0          0x300
39 #define T3_MC_LA_EPP_1          0x304
40 #define T3_MC_LA_G2_0           0x308
41 #define T3_MC_LA_G2_1           0x30c
42 #define T3_MC_LA_HC_0           0x310
43 #define T3_MC_LA_HC_1           0x314
44 #define T3_MC_LA_HDA_0          0x318
45 #define T3_MC_LA_ISP_0          0x31C
46 #define T3_MC_LA_MPCORE_0               0x320
47 #define T3_MC_LA_MPCORELP_0     0x324
48 #define T3_MC_LA_MPE_0          0x328
49 #define T3_MC_LA_MPE_1          0x32c
50 #define T3_MC_LA_MPE_2          0x330
51 #define T3_MC_LA_NV_0           0x334
52 #define T3_MC_LA_NV_1           0x338
53 #define T3_MC_LA_NV2_0          0x33c
54 #define T3_MC_LA_NV2_1          0x340
55 #define T3_MC_LA_PPCS_0         0x344
56 #define T3_MC_LA_PPCS_1         0x348
57 #define T3_MC_LA_PTC_0          0x34c
58 #define T3_MC_LA_SATA_0         0x350
59 #define T3_MC_LA_VDE_0          0x354
60 #define T3_MC_LA_VDE_1          0x358
61 #define T3_MC_LA_VDE_2          0x35c
62 #define T3_MC_LA_VDE_3          0x360
63 #define T3_MC_LA_VI_0           0x364
64 #define T3_MC_LA_VI_1           0x368
65 #define T3_MC_LA_VI_2           0x36c
66
67 #define T3_MC_ARB_OVERRIDE              0xe8
68 #define GLOBAL_LATENCY_SCALING_ENABLE_BIT 7
69
70 #define DS_DISP_MCCIF_DISPLAY0A_HYST (0x481 * 4)
71 #define DS_DISP_MCCIF_DISPLAY0B_HYST (0x482 * 4)
72 #define DS_DISP_MCCIF_DISPLAY0C_HYST (0x483 * 4)
73 #define DS_DISP_MCCIF_DISPLAY1B_HYST (0x484 * 4)
74
75 #define DS_DISP_MCCIF_DISPLAY0AB_HYST (0x481 * 4)
76 #define DS_DISP_MCCIF_DISPLAY0BB_HYST (0x482 * 4)
77 #define DS_DISP_MCCIF_DISPLAY0CB_HYST (0x483 * 4)
78 #define DS_DISP_MCCIF_DISPLAY1BB_HYST (0x484 * 4)
79
80 #define VI_MCCIF_VIWSB_HYST     (0x9a * 4)
81 #define VI_MCCIF_VIWU_HYST      (0x9b * 4)
82 #define VI_MCCIF_VIWV_HYST      (0x9c * 4)
83 #define VI_MCCIF_VIWY_HYST      (0x9d * 4)
84
85 #define VI_TIMEOUT_WOCAL_VI     (0x70 * 4)
86 #define VI_RESERVE_3            (0x97 * 4)
87 #define VI_RESERVE_4            (0x98 * 4)
88
89 /* maximum valid value for latency allowance */
90 #define T3_MC_LA_MAX_VALUE              255
91
92 #define T3_MC_RA(r) \
93         (IO_ADDRESS(TEGRA_MC_BASE) + (T3_MC_##r))
94 #define T3_RA(r) \
95         (IO_ADDRESS(TEGRA_MC_BASE) + (T3_MC_LA_##r))
96
97 #define T3_LA(f, e, a, r, i, ss, la) \
98 { \
99         .fifo_size_in_atoms = f, \
100         .expiration_in_ns = e, \
101         .reg_addr = T3_RA(a), \
102         .mask = MASK(r), \
103         .shift = SHIFT(r), \
104         .id = ID(i), \
105         .name = __stringify(i), \
106         .scaling_supported = ss, \
107         .init_la = la, \
108 }
109
110 /*
111  * The consensus for getting the fifo_size_in_atoms is:
112  * 1.If REORDER_DEPTH exists, use it(default is overridden).
113  * 2.Else if (write_client) use RFIFO_DEPTH.
114  * 3.Else (read client) use RDFIFO_DEPTH.
115  * Multiply the value by 2 for wide clients.
116  * A client is wide, if CMW is larger than MW.
117  * Refer to project.h file.
118  */
119 struct la_client_info t3_la_info_array[] = {
120         T3_LA(32,       150,    AFI_0,  7 : 0,          AFIR,           false,  0),
121         T3_LA(32,       150,    AFI_0,  23 : 16,        AFIW,           false,  0),
122         T3_LA(2,        150,    AVPC_ARM7_0, 7 : 0,     AVPC_ARM7R,     false,  0),
123         T3_LA(2,        150,    AVPC_ARM7_0, 23 : 16,   AVPC_ARM7W,     false,  0),
124         T3_LA(128,      1050,   DC_0,   7 : 0,          DISPLAY_0A,     true,   0),
125         T3_LA(64,       1050,   DC_0,   23 : 16,        DISPLAY_0B,     true,   0),
126         T3_LA(128,      1050,   DC_1,   7 : 0,          DISPLAY_0C,     true,   0),
127         T3_LA(64,       1050,   DC_1,   23 : 16,        DISPLAY_1B,     true,   0),
128         T3_LA(2,        1050,   DC_2,   7 : 0,          DISPLAY_HC,     false,  0),
129         T3_LA(128,      1050,   DCB_0,  7 : 0,          DISPLAY_0AB,    true,   0),
130         T3_LA(64,       1050,   DCB_0,  23 : 16,        DISPLAY_0BB,    true,   0),
131         T3_LA(128,      1050,   DCB_1,  7 : 0,          DISPLAY_0CB,    true,   0),
132         T3_LA(64,       1050,   DCB_1,  23 : 16,        DISPLAY_1BB,    true,   0),
133         T3_LA(2,        1050,   DCB_2,  7 : 0,          DISPLAY_HCB,    false,  0),
134         T3_LA(8,        150,    EPP_0,  7 : 0,          EPPUP,          false,  0),
135         T3_LA(64,       150,    EPP_0,  23 : 16,        EPPU,           false,  0),
136         T3_LA(64,       150,    EPP_1,  7 : 0,          EPPV,           false,  0),
137         T3_LA(64,       150,    EPP_1,  23 : 16,        EPPY,           false,  0),
138         T3_LA(64,       150,    G2_0,   7 : 0,          G2PR,           false,  0),
139         T3_LA(64,       150,    G2_0,   23 : 16,        G2SR,           false,  0),
140         T3_LA(48,       150,    G2_1,   7 : 0,          G2DR,           false,  0),
141         T3_LA(128,      150,    G2_1,   23 : 16,        G2DW,           false,  0),
142         T3_LA(16,       150,    HC_0,   7 : 0,          HOST1X_DMAR,    false,  0),
143         T3_LA(8,        150,    HC_0,   23 : 16,        HOST1XR,        false,  0),
144         T3_LA(32,       150,    HC_1,   7 : 0,          HOST1XW,        false,  0),
145         T3_LA(16,       150,    HDA_0,  7 : 0,          HDAR,           false,  0),
146         T3_LA(16,       150,    HDA_0,  23 : 16,        HDAW,           false,  0),
147         T3_LA(64,       150,    ISP_0,  7 : 0,          ISPW,           false,  0),
148         T3_LA(14,       150,    MPCORE_0, 7 : 0,        MPCORER,        false,  0),
149         T3_LA(24,       150,    MPCORE_0, 23 : 16,      MPCOREW,        false,  0),
150         T3_LA(14,       150,    MPCORELP_0, 7 : 0,      MPCORE_LPR,     false,  0),
151         T3_LA(24,       150,    MPCORELP_0, 23 : 16,    MPCORE_LPW,     false,  0),
152         T3_LA(8,        150,    MPE_0,  7 : 0,          MPE_UNIFBR,     false,  0),
153         T3_LA(2,        150,    MPE_0,  23 : 16,        MPE_IPRED,      false,  0),
154         T3_LA(64,       150,    MPE_1,  7 : 0,          MPE_AMEMRD,     false,  0),
155         T3_LA(8,        150,    MPE_1,  23 : 16,        MPE_CSRD,       false,  0),
156         T3_LA(8,        150,    MPE_2,  7 : 0,          MPE_UNIFBW,     false,  0),
157         T3_LA(8,        150,    MPE_2,  23 : 16,        MPE_CSWR,       false,  0),
158         T3_LA(96,       150,    NV_0,   7 : 0,          FDCDRD,         false,  0),
159         T3_LA(64,       150,    NV_0,   23 : 16,        IDXSRD,         false,  0),
160         T3_LA(64,       150,    NV_1,   7 : 0,          TEXSRD,         false,  0),
161         T3_LA(96,       150,    NV_1,   23 : 16,        FDCDWR,         false,  0),
162         T3_LA(96,       150,    NV2_0,  7 : 0,          FDCDRD2,        false,  0),
163         T3_LA(64,       150,    NV2_0,  23 : 16,        IDXSRD2,        false,  0),
164         T3_LA(64,       150,    NV2_1,  7 : 0,          TEXSRD2,        false,  0),
165         T3_LA(96,       150,    NV2_1,  23 : 16,        FDCDWR2,        false,  0),
166         T3_LA(2,        150,    PPCS_0, 7 : 0,          PPCS_AHBDMAR,   false,  0),
167         T3_LA(8,        150,    PPCS_0, 23 : 16,        PPCS_AHBSLVR,   false,  0),
168         T3_LA(2,        150,    PPCS_1, 7 : 0,          PPCS_AHBDMAW,   false,  0),
169         T3_LA(4,        150,    PPCS_1, 23 : 16,        PPCS_AHBSLVW,   false,  0),
170         T3_LA(2,        150,    PTC_0,  7 : 0,          PTCR,           false,  0),
171         T3_LA(32,       150,    SATA_0, 7 : 0,          SATAR,          false,  0),
172         T3_LA(32,       150,    SATA_0, 23 : 16,        SATAW,          false,  0),
173         T3_LA(8,        150,    VDE_0,  7 : 0,          VDE_BSEVR,      false,  0),
174         T3_LA(4,        150,    VDE_0,  23 : 16,        VDE_MBER,       false,  0),
175         T3_LA(16,       150,    VDE_1,  7 : 0,          VDE_MCER,       false,  0),
176         T3_LA(16,       150,    VDE_1,  23 : 16,        VDE_TPER,       false,  0),
177         T3_LA(4,        150,    VDE_2,  7 : 0,          VDE_BSEVW,      false,  0),
178         T3_LA(16,       150,    VDE_2,  23 : 16,        VDE_DBGW,       false,  0),
179         T3_LA(2,        150,    VDE_3,  7 : 0,          VDE_MBEW,       false,  0),
180         T3_LA(16,       150,    VDE_3,  23 : 16,        VDE_TPMW,       false,  0),
181         T3_LA(8,        1050,   VI_0,   7 : 0,          VI_RUV,         false,  0),
182         T3_LA(64,       1050,   VI_0,   23 : 16,        VI_WSB,         true,   0),
183         T3_LA(64,       1050,   VI_1,   7 : 0,          VI_WU,          true,   0),
184         T3_LA(64,       1050,   VI_1,   23 : 16,        VI_WV,          true,   0),
185         T3_LA(64,       1050,   VI_2,   7 : 0,          VI_WY,          true,   0),
186
187 /* end of list. */
188         T3_LA(0,        0,      AFI_0,  0 : 0,          MAX_ID,         false,  0)
189 };
190
191 #define DISP1_RA(r) \
192         (IO_ADDRESS(TEGRA_DISPLAY_BASE) + DS_DISP_MCCIF_##r##_HYST)
193 #define DISP2_RA(r) \
194         (IO_ADDRESS(TEGRA_DISPLAY2_BASE) + DS_DISP_MCCIF_##r##_HYST)
195
196 #define DISP_SCALING_REG_INFO(id, r, ra) \
197         { \
198                 ID(id), \
199                 ra(r), MASK(15 : 8), SHIFT(15 : 8), \
200                 ra(r), MASK(23 : 16), SHIFT(15 : 8), \
201                 ra(r), MASK(7 : 0), SHIFT(15 : 8) \
202         }
203
204 struct la_scaling_reg_info disp_info[] = {
205         DISP_SCALING_REG_INFO(DISPLAY_0A, DISPLAY0A, DISP1_RA),
206         DISP_SCALING_REG_INFO(DISPLAY_0B, DISPLAY0B, DISP1_RA),
207         DISP_SCALING_REG_INFO(DISPLAY_0C, DISPLAY0C, DISP1_RA),
208         DISP_SCALING_REG_INFO(DISPLAY_1B, DISPLAY1B, DISP1_RA),
209         DISP_SCALING_REG_INFO(MAX_ID,     DISPLAY1B, DISP1_RA), /*dummy entry*/
210         DISP_SCALING_REG_INFO(DISPLAY_0AB, DISPLAY0AB, DISP2_RA),
211         DISP_SCALING_REG_INFO(DISPLAY_0BB, DISPLAY0BB, DISP2_RA),
212         DISP_SCALING_REG_INFO(DISPLAY_0CB, DISPLAY0CB, DISP2_RA),
213         DISP_SCALING_REG_INFO(DISPLAY_1BB, DISPLAY1BB, DISP2_RA),
214 };
215
216 #define VI_TH_RA(r) \
217         (IO_ADDRESS(TEGRA_VI_BASE) + VI_MCCIF_##r##_HYST)
218 #define VI_TM_RA(r) \
219         (IO_ADDRESS(TEGRA_VI_BASE) + VI_TIMEOUT_WOCAL_VI)
220 #define VI_TL_RA(r) \
221         (IO_ADDRESS(TEGRA_VI_BASE) + VI_RESERVE_##r)
222
223 struct la_scaling_reg_info vi_info[] = {
224         {
225                 ID(VI_WSB),
226                 VI_TL_RA(4), MASK(7 : 0), SHIFT(7 : 0),
227                 VI_TM_RA(0), MASK(7 : 0), SHIFT(7 : 0),
228                 VI_TH_RA(VIWSB), MASK(7 : 0), SHIFT(7 : 0)
229         },
230         {
231                 ID(VI_WU),
232                 VI_TL_RA(3), MASK(15 : 8), SHIFT(15 : 8),
233                 VI_TM_RA(0), MASK(15 : 8), SHIFT(15 : 8),
234                 VI_TH_RA(VIWU), MASK(7 : 0), SHIFT(7 : 0)
235         },
236         {
237                 ID(VI_WV),
238                 VI_TL_RA(3), MASK(7 : 0), SHIFT(7 : 0),
239                 VI_TM_RA(0), MASK(23 : 16), SHIFT(23 : 16),
240                 VI_TH_RA(VIWV), MASK(7 : 0), SHIFT(7 : 0)
241         },
242         {
243                 ID(VI_WY),
244                 VI_TL_RA(4), MASK(15 : 8), SHIFT(15 : 8),
245                 VI_TM_RA(0), MASK(31 : 24), SHIFT(31 : 24),
246                 VI_TH_RA(VIWY), MASK(7 : 0), SHIFT(7 : 0)
247         }
248 };
249
250 static struct la_chip_specific *cs;
251
252 static void set_thresholds(struct la_scaling_reg_info *info,
253                             enum tegra_la_id id)
254 {
255         unsigned long reg_read;
256         unsigned long reg_write;
257         unsigned int thresh_low;
258         unsigned int thresh_mid;
259         unsigned int thresh_high;
260         int la_set;
261         int idx = cs->id_to_index[id];
262
263         reg_read = readl(cs->la_info_array[idx].reg_addr);
264         la_set = (reg_read & cs->la_info_array[idx].mask) >>
265                  cs->la_info_array[idx].shift;
266         /* la should be set before enabling scaling. */
267         BUG_ON(la_set != cs->scaling_info[idx].la_set);
268
269         thresh_low = (cs->scaling_info[idx].threshold_low * la_set) / 100;
270         thresh_mid = (cs->scaling_info[idx].threshold_mid * la_set) / 100;
271         thresh_high = (cs->scaling_info[idx].threshold_high * la_set) / 100;
272         la_debug("%s: la_set=%d, thresh_low=%d(%d%%), thresh_mid=%d(%d%%),"
273                 " thresh_high=%d(%d%%) ", __func__, la_set,
274                 thresh_low, cs->scaling_info[idx].threshold_low,
275                 thresh_mid, cs->scaling_info[idx].threshold_mid,
276                 thresh_high, cs->scaling_info[idx].threshold_high);
277
278         reg_read = readl(info->tl_reg_addr);
279         reg_write = (reg_read & ~info->tl_mask) |
280                 (thresh_low << info->tl_shift);
281         writel(reg_write, info->tl_reg_addr);
282         la_debug("reg_addr=0x%x, read=0x%x, write=0x%x",
283                 (u32)info->tl_reg_addr, (u32)reg_read, (u32)reg_write);
284
285         reg_read = readl(info->tm_reg_addr);
286         reg_write = (reg_read & ~info->tm_mask) |
287                 (thresh_mid << info->tm_shift);
288         writel(reg_write, info->tm_reg_addr);
289         la_debug("reg_addr=0x%x, read=0x%x, write=0x%x",
290                 (u32)info->tm_reg_addr, (u32)reg_read, (u32)reg_write);
291
292         reg_read = readl(info->th_reg_addr);
293         reg_write = (reg_read & ~info->th_mask) |
294                 (thresh_high << info->th_shift);
295         writel(reg_write, info->th_reg_addr);
296         la_debug("reg_addr=0x%x, read=0x%x, write=0x%x",
297                 (u32)info->th_reg_addr, (u32)reg_read, (u32)reg_write);
298 }
299
300 static void set_disp_latency_thresholds(enum tegra_la_id id)
301 {
302         set_thresholds(&disp_info[id - ID(DISPLAY_0A)], id);
303 }
304
305 static void set_vi_latency_thresholds(enum tegra_la_id id)
306 {
307         set_thresholds(&vi_info[id - ID(VI_WSB)], id);
308 }
309
310 /* Thresholds for scaling are specified in % of fifo freeness.
311  * If threshold_low is specified as 20%, it means when the fifo free
312  * between 0 to 20%, use la as programmed_la.
313  * If threshold_mid is specified as 50%, it means when the fifo free
314  * between 20 to 50%, use la as programmed_la/2 .
315  * If threshold_high is specified as 80%, it means when the fifo free
316  * between 50 to 80%, use la as programmed_la/4.
317  * When the fifo is free between 80 to 100%, use la as 0(highest priority).
318  */
319 int t3_enable_la_scaling(enum tegra_la_id id,
320                                     unsigned int threshold_low,
321                                     unsigned int threshold_mid,
322                                     unsigned int threshold_high)
323 {
324         unsigned long reg;
325         void __iomem *scaling_enable_reg =
326                                 (void __iomem *)(T3_MC_RA(ARB_OVERRIDE));
327         int idx = cs->id_to_index[id];
328
329         VALIDATE_ID(id, cs);
330         VALIDATE_THRESHOLDS(threshold_low, threshold_mid, threshold_high);
331
332         if (cs->la_info_array[idx].scaling_supported == false)
333                 goto exit;
334
335         spin_lock(&cs->lock);
336
337         la_debug("\n%s: id=%d, tl=%d, tm=%d, th=%d", __func__,
338                 id, threshold_low, threshold_mid, threshold_high);
339         cs->scaling_info[idx].threshold_low = threshold_low;
340         cs->scaling_info[idx].threshold_mid = threshold_mid;
341         cs->scaling_info[idx].threshold_high = threshold_high;
342         cs->scaling_info[idx].scaling_ref_count++;
343
344         if (id >= ID(DISPLAY_0A) && id <= ID(DISPLAY_1BB))
345                 set_disp_latency_thresholds(id);
346         else if (id >= ID(VI_WSB) && id <= ID(VI_WY))
347                 set_vi_latency_thresholds(id);
348         if (!cs->la_scaling_enable_count++) {
349                 reg = readl(scaling_enable_reg);
350                 reg |= (1 << GLOBAL_LATENCY_SCALING_ENABLE_BIT);
351                 writel(reg,  scaling_enable_reg);
352                 la_debug("enabled scaling.");
353         }
354         spin_unlock(&cs->lock);
355 exit:
356         return 0;
357 }
358
359 void t3_disable_la_scaling(enum tegra_la_id id)
360 {
361         unsigned long reg;
362         void __iomem *scaling_enable_reg =
363                                 (void __iomem *)(T3_MC_RA(ARB_OVERRIDE));
364         int idx;
365
366         BUG_ON(id >= TEGRA_LA_MAX_ID);
367         idx = cs->id_to_index[id];
368         BUG_ON(cs->la_info_array[idx].id != id);
369
370         if (cs->la_info_array[idx].scaling_supported == false)
371                 return;
372         spin_lock(&cs->lock);
373         la_debug("\n%s: id=%d", __func__, id);
374         cs->scaling_info[idx].scaling_ref_count--;
375         BUG_ON(cs->scaling_info[idx].scaling_ref_count < 0);
376
377         if (!--cs->la_scaling_enable_count) {
378                 reg = readl(scaling_enable_reg);
379                 reg = reg & ~(1 << GLOBAL_LATENCY_SCALING_ENABLE_BIT);
380                 writel(reg, scaling_enable_reg);
381                 la_debug("disabled scaling.");
382         }
383         spin_unlock(&cs->lock);
384 }
385
386 void tegra_la_get_t3_specific(struct la_chip_specific *cs_la)
387 {
388         cs_la->ns_per_tick = 30;
389         cs_la->atom_size = 16;
390         cs_la->la_max_value = T3_MC_LA_MAX_VALUE;
391         cs_la->la_info_array = t3_la_info_array;
392         cs_la->la_info_array_size = ARRAY_SIZE(t3_la_info_array);
393         cs_la->enable_la_scaling = t3_enable_la_scaling;
394         cs_la->disable_la_scaling = t3_disable_la_scaling;
395         cs = cs_la;
396 }