6a7dc608add6a9372c87c767d67ee1a53e3c7ef6
[linux-3.10.git] / drivers / platform / tegra / mc / mc.c
1 /*
2  * arch/arm/mach-tegra/mc.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Copyright (C) 2011-2014, NVIDIA Corporation.  All rights reserved.
6  *
7  * Author:
8  *      Erik Gilling <konkers@google.com>
9  *
10  * This software is licensed under the terms of the GNU General Public
11  * License version 2, as published by the Free Software Foundation, and
12  * may be copied, distributed, and modified under those terms.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/export.h>
24 #include <linux/spinlock.h>
25 #include <linux/delay.h>
26 #include <linux/debugfs.h>
27 #include <linux/tegra-soc.h>
28 #include <linux/of_device.h>
29 #include <linux/of_address.h>
30 #include <linux/platform_device.h>
31
32 #include <mach/mc.h>
33 #include <mach/mcerr.h>
34
35 #include "../../../../arch/arm/mach-tegra/iomap.h"
36
37 #define MC_CLIENT_HOTRESET_CTRL         0x200
38 #define MC_CLIENT_HOTRESET_STAT         0x204
39 #define MC_CLIENT_HOTRESET_CTRL_1       0x970
40 #define MC_CLIENT_HOTRESET_STAT_1       0x974
41
42 #define MC_TIMING_REG_NUM1                                      \
43         ((MC_EMEM_ARB_TIMING_W2R - MC_EMEM_ARB_CFG) / 4 + 1)
44 #define MC_TIMING_REG_NUM2                                      \
45         ((MC_EMEM_ARB_MISC1 - MC_EMEM_ARB_DA_TURNS) / 4 + 1)
46 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
47 #define MC_TIMING_REG_NUM3      T12X_MC_LATENCY_ALLOWANCE_NUM_REGS
48 #elif defined(CONFIG_ARCH_TEGRA_21x_SOC)
49 #define MC_TIMING_REG_NUM3      T21X_MC_LATENCY_ALLOWANCE_NUM_REGS
50 #else
51 #define MC_TIMING_REG_NUM3                                              \
52         ((MC_LATENCY_ALLOWANCE_VI_2 - MC_LATENCY_ALLOWANCE_BASE) / 4 + 1)
53 #endif
54
55 static DEFINE_SPINLOCK(tegra_mc_lock);
56 int mc_channels;
57 void __iomem *mc;
58
59 /* Only populated if there are 2 channels. */
60 void __iomem *mc0;
61 void __iomem *mc1;
62
63 int mc_intr_count;
64
65 #ifdef CONFIG_PM_SLEEP
66 static u32 mc_boot_timing[MC_TIMING_REG_NUM1 + MC_TIMING_REG_NUM2
67                           + MC_TIMING_REG_NUM3 + 4];
68
69 static void tegra_mc_timing_save(void)
70 {
71         u32 off;
72         u32 *ctx = mc_boot_timing;
73
74         for (off = MC_EMEM_ARB_CFG; off <= MC_EMEM_ARB_TIMING_W2R; off += 4)
75                 *ctx++ = mc_readl(off);
76
77         for (off = MC_EMEM_ARB_DA_TURNS; off <= MC_EMEM_ARB_MISC1; off += 4)
78                 *ctx++ = mc_readl(off);
79
80         *ctx++ = mc_readl(MC_EMEM_ARB_RING3_THROTTLE);
81         *ctx++ = mc_readl(MC_EMEM_ARB_OVERRIDE);
82         *ctx++ = mc_readl(MC_RESERVED_RSV);
83
84 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
85         tegra12_mc_latency_allowance_save(&ctx);
86 #elif defined(CONFIG_ARCH_TEGRA_21x_SOC)
87         if (tegra_get_chipid() == TEGRA_CHIPID_TEGRA21)
88                 tegra21_mc_latency_allowance_save(&ctx);
89 #else
90         for (off = MC_LATENCY_ALLOWANCE_BASE; off <= MC_LATENCY_ALLOWANCE_VI_2;
91                 off += 4)
92                 *ctx++ = mc_readl(off);
93 #endif
94
95         *ctx++ = mc_readl(MC_INT_MASK);
96 }
97
98 void tegra_mc_timing_restore(void)
99 {
100         u32 off;
101         u32 *ctx = mc_boot_timing;
102
103         for (off = MC_EMEM_ARB_CFG; off <= MC_EMEM_ARB_TIMING_W2R; off += 4)
104                 __mc_raw_writel(0, *ctx++, off);
105
106         for (off = MC_EMEM_ARB_DA_TURNS; off <= MC_EMEM_ARB_MISC1; off += 4)
107                 __mc_raw_writel(0, *ctx++, off);
108
109         __mc_raw_writel(0, *ctx++, MC_EMEM_ARB_RING3_THROTTLE);
110         __mc_raw_writel(0, *ctx++, MC_EMEM_ARB_OVERRIDE);
111         __mc_raw_writel(0, *ctx++, MC_RESERVED_RSV);
112
113 #if defined(CONFIG_ARCH_TEGRA_12x_SOC)
114         tegra12_mc_latency_allowance_restore(&ctx);
115 #elif defined(CONFIG_ARCH_TEGRA_21x_SOC)
116         tegra21_mc_latency_allowance_restore(&ctx);
117 #else
118         for (off = MC_LATENCY_ALLOWANCE_BASE; off <= MC_LATENCY_ALLOWANCE_VI_2;
119                 off += 4)
120                 __mc_raw_writel(0, *ctx++, off);
121 #endif
122
123         mc_writel(*ctx++, MC_INT_MASK);
124         off = mc_readl(MC_INT_MASK);
125
126         mc_writel(0x1, MC_TIMING_CONTROL);
127         off = mc_readl(MC_TIMING_CONTROL);
128 }
129 #else
130 #define tegra_mc_timing_save()
131 #endif
132
133 /*
134  * If using T30/DDR3, the 2nd 16 bytes part of DDR3 atom is 2nd line and is
135  * discarded in tiling mode.
136  */
137 int tegra_mc_get_tiled_memory_bandwidth_multiplier(void)
138 {
139         int type;
140
141         type = tegra_emc_get_dram_type();
142
143         if (type == DRAM_TYPE_DDR3)
144                 return 2;
145         else
146                 return 1;
147 }
148
149 /* API to get EMC freq to be requested, for Bandwidth.
150  * bw_kbps: BandWidth passed is in KBps.
151  * returns freq in KHz
152  */
153 unsigned int tegra_emc_bw_to_freq_req(unsigned int bw_kbps)
154 {
155         unsigned int freq;
156         unsigned int bytes_per_emc_clk;
157
158         bytes_per_emc_clk = tegra_mc_get_effective_bytes_width() * 2;
159         freq = (bw_kbps + bytes_per_emc_clk - 1) / bytes_per_emc_clk *
160                 CONFIG_TEGRA_EMC_TO_DDR_CLOCK;
161         return freq;
162 }
163 EXPORT_SYMBOL_GPL(tegra_emc_bw_to_freq_req);
164
165 /* API to get EMC bandwidth, for freq that can be requested.
166  * freq_khz: Frequency passed is in KHz.
167  * returns bandwidth in KBps
168  */
169 unsigned int tegra_emc_freq_req_to_bw(unsigned int freq_khz)
170 {
171         unsigned int bw;
172         unsigned int bytes_per_emc_clk;
173
174         bytes_per_emc_clk = tegra_mc_get_effective_bytes_width() * 2;
175         bw = freq_khz * bytes_per_emc_clk / CONFIG_TEGRA_EMC_TO_DDR_CLOCK;
176         return bw;
177 }
178 EXPORT_SYMBOL_GPL(tegra_emc_freq_req_to_bw);
179
180 #define HOTRESET_READ_COUNT     5
181 static bool tegra_stable_hotreset_check(u32 stat_reg, u32 *stat)
182 {
183         int i;
184         u32 cur_stat;
185         u32 prv_stat;
186         unsigned long flags;
187
188         spin_lock_irqsave(&tegra_mc_lock, flags);
189         prv_stat = mc_readl(stat_reg);
190         for (i = 0; i < HOTRESET_READ_COUNT; i++) {
191                 cur_stat = mc_readl(stat_reg);
192                 if (cur_stat != prv_stat) {
193                         spin_unlock_irqrestore(&tegra_mc_lock, flags);
194                         return false;
195                 }
196         }
197         *stat = cur_stat;
198         spin_unlock_irqrestore(&tegra_mc_lock, flags);
199         return true;
200 }
201
202 int tegra_mc_flush(int id)
203 {
204         u32 rst_ctrl, rst_stat;
205         u32 rst_ctrl_reg, rst_stat_reg;
206         unsigned long flags;
207         unsigned int timeout;
208         bool ret;
209
210         if (!mc)
211                 return 0;
212
213         if (id < 32) {
214                 rst_ctrl_reg = MC_CLIENT_HOTRESET_CTRL;
215                 rst_stat_reg = MC_CLIENT_HOTRESET_STAT;
216         } else {
217                 id %= 32;
218                 rst_ctrl_reg = MC_CLIENT_HOTRESET_CTRL_1;
219                 rst_stat_reg = MC_CLIENT_HOTRESET_STAT_1;
220         }
221
222         spin_lock_irqsave(&tegra_mc_lock, flags);
223
224         rst_ctrl = mc_readl(rst_ctrl_reg);
225         rst_ctrl |= (1 << id);
226         mc_writel(rst_ctrl, rst_ctrl_reg);
227
228         spin_unlock_irqrestore(&tegra_mc_lock, flags);
229
230         timeout = 0;
231         do {
232                 udelay(10);
233                 rst_stat = 0;
234                 ret = tegra_stable_hotreset_check(rst_stat_reg, &rst_stat);
235                 if ((timeout++ > 100) && (tegra_platform_is_qt() ||
236                         tegra_platform_is_fpga())) {
237                         pr_warn("%s flush %d timeout\n", __func__, id);
238                         break;
239                 }
240                 if (!ret)
241                         continue;
242         } while (!(rst_stat & (1 << id)));
243
244         return 0;
245 }
246 EXPORT_SYMBOL(tegra_mc_flush);
247
248 int tegra_mc_flush_done(int id)
249 {
250         u32 rst_ctrl;
251         u32 rst_ctrl_reg, rst_stat_reg;
252         unsigned long flags;
253
254         if (!mc)
255                 return 0;
256
257         if (id < 32) {
258                 rst_ctrl_reg = MC_CLIENT_HOTRESET_CTRL;
259                 rst_stat_reg = MC_CLIENT_HOTRESET_STAT;
260         } else {
261                 id %= 32;
262                 rst_ctrl_reg = MC_CLIENT_HOTRESET_CTRL_1;
263                 rst_stat_reg = MC_CLIENT_HOTRESET_STAT_1;
264         }
265
266         spin_lock_irqsave(&tegra_mc_lock, flags);
267
268         rst_ctrl = mc_readl(rst_ctrl_reg);
269         rst_ctrl &= ~(1 << id);
270         mc_writel(rst_ctrl, rst_ctrl_reg);
271
272         spin_unlock_irqrestore(&tegra_mc_lock, flags);
273         return 0;
274 }
275 EXPORT_SYMBOL(tegra_mc_flush_done);
276
277 /*
278  * Map an MC register space. Each MC has a set of register ranges which must
279  * be parsed. The first starting address in the set of ranges is returned as
280  * it is expected that the DT file has the register ranges in ascending
281  * order.
282  *
283  * device 0 = global channel.
284  * device n = specific channel device-1, e.g device = 1 ==> channel 0.
285  */
286 static void __iomem *tegra_mc_map_regs(struct platform_device *pdev, int device)
287 {
288         const void *prop;
289         void __iomem *regs;
290         void __iomem *regs_start = NULL;
291         u32 reg_ranges;
292         int i, start;
293
294         prop = of_get_property(pdev->dev.of_node, "reg-ranges", NULL);
295         if (!prop) {
296                 pr_err("Failed to get MC MMIO region\n");
297                 pr_err("  device = %d: missing reg-ranges\n", device);
298                 return NULL;
299         }
300
301         reg_ranges = be32_to_cpup(prop);
302         start = device * reg_ranges;
303
304         for (i = 0; i < reg_ranges; i++) {
305                 regs = of_iomap(pdev->dev.of_node, start + i);
306                 if (!regs) {
307                         pr_err("Failed to get MC MMIO region\n");
308                         pr_err("  device = %d, range = %u\n", device, i);
309                         return NULL;
310                 }
311
312                 if (i == 0)
313                         regs_start = regs;
314         }
315
316         return regs_start;
317 }
318
319 static const struct of_device_id mc_of_ids[] = {
320         { .compatible = "nvidia,tegra-mc" },
321         { }
322 };
323
324 /*
325  * MC driver init.
326  */
327 static int tegra_mc_probe(struct platform_device *pdev)
328 {
329
330 #if defined(CONFIG_TEGRA_MC_EARLY_ACK)
331         u32 reg;
332 #endif
333         const void *prop;
334         struct dentry *mc_debugfs_dir;
335         const struct of_device_id *match;
336
337         if (!pdev->dev.of_node)
338                 return -EINVAL;
339
340         match = of_match_device(mc_of_ids, &pdev->dev);
341         if (!match) {
342                 pr_err("Missing DT entry!\n");
343                 return -EINVAL;
344         }
345
346         /*
347          * Channel count.
348          */
349         prop = of_get_property(pdev->dev.of_node, "channels", NULL);
350         if (!prop)
351                 mc_channels = 1;
352         else
353                 mc_channels = be32_to_cpup(prop);
354
355         if (mc_channels != 1 && mc_channels != 2) {
356                 pr_err("Invalid number of memory channels: %d\n", mc_channels);
357                 return -EINVAL;
358         }
359
360         /*
361          * IO mem.
362          */
363         mc = tegra_mc_map_regs(pdev, 0);
364         if (!mc)
365                 return -ENOMEM;
366         pr_info("MC mapped MMIO address: 0x%p\n", mc);
367
368         if (mc_dual_channel()) {
369                 mc0 = tegra_mc_map_regs(pdev, 1);
370                 if (!mc0) {
371                         pr_err("Failed to make channel 0\n");
372                         return -ENOMEM;
373                 }
374                 pr_info("MC0 mapped MMIO address: 0x%p\n", mc0);
375                 mc1 = tegra_mc_map_regs(pdev, 2);
376                 if (!mc1) {
377                         pr_err("Failed to make channel 0\n");
378                         return -ENOMEM;
379                 }
380                 pr_info("MC1 mapped MMIO address: 0x%p\n", mc1);
381         }
382
383         tegra_mc_timing_save();
384
385 #if defined(CONFIG_TEGRA_MC_EARLY_ACK)
386         reg = mc_readl(MC_EMEM_ARB_OVERRIDE);
387         reg |= 3;
388 #if defined(CONFIG_TEGRA_ERRATA_1157520)
389         if (tegra_revision == TEGRA_REVISION_A01)
390                 reg &= ~2;
391 #endif
392         mc_writel(reg, MC_EMEM_ARB_OVERRIDE);
393 #endif
394
395         mc_debugfs_dir = debugfs_create_dir("mc", NULL);
396         if (mc_debugfs_dir == NULL) {
397                 pr_err("Failed to make debugfs node: %ld\n",
398                        PTR_ERR(mc_debugfs_dir));
399                 return PTR_ERR(mc_debugfs_dir);
400         }
401
402         tegra_mcerr_init(mc_debugfs_dir, pdev);
403
404         return 0;
405 }
406
407 static int tegra_mc_remove(struct platform_device *pdev)
408 {
409         return 0;
410 }
411
412 static struct platform_driver mc_driver = {
413         .driver = {
414                 .name   = "tegra-mc",
415                 .of_match_table = mc_of_ids,
416                 .owner  = THIS_MODULE,
417         },
418
419         .probe          = tegra_mc_probe,
420         .remove         = tegra_mc_remove,
421 };
422
423 static int __init tegra_mc_init(void)
424 {
425         int ret;
426
427         ret = platform_driver_register(&mc_driver);
428         if (ret)
429                 return ret;
430
431         return 0;
432 }
433 arch_initcall(tegra_mc_init);
434
435 static void __exit tegra_mc_fini(void)
436 {
437 }
438 module_exit(tegra_mc_fini);