ARM: tegra: loki: fix build error due to warning
[linux-3.10.git] / arch / arm / mach-tegra / tegra2_emc.c
1 /*
2  * Copyright (C) 2011 Google, Inc.
3  *
4  * Author:
5  *      Colin Cross <ccross@android.com>
6  *
7  * This software is licensed under the terms of the GNU General Public
8  * License version 2, as published by the Free Software Foundation, and
9  * may be copied, distributed, and modified under those terms.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17
18 #include <linux/kernel.h>
19 #include <linux/device.h>
20 #include <linux/clk.h>
21 #include <linux/err.h>
22 #include <linux/io.h>
23 #include <linux/module.h>
24 #include <linux/of.h>
25 #include <linux/platform_device.h>
26 #include <linux/platform_data/tegra_emc.h>
27
28 #include "tegra2_emc.h"
29 #include "fuse.h"
30
31 #define TEGRA_MRR_DIVLD        (1<<20)
32 #define TEGRA_EMC_STATUS       0x02b4
33 #define TEGRA_EMC_MRR          0x00ec
34 static DEFINE_MUTEX(tegra_emc_mrr_lock);
35
36 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
37 static bool emc_enable = true;
38 #else
39 static bool emc_enable;
40 #endif
41 module_param(emc_enable, bool, 0644);
42
43 static struct platform_device *emc_pdev;
44 static void __iomem *emc_regbase;
45 static const struct tegra_emc_table *tegra_emc_table;
46 static int tegra_emc_table_size;
47
48 static unsigned long tegra_emc_max_bus_rate;  /* 2 * 1000 * maximum emc_clock rate */
49 static unsigned long tegra_emc_min_bus_rate;  /* 2 * 1000 * minimum emc_clock rate */
50
51 static inline void emc_writel(u32 val, unsigned long addr)
52 {
53         writel(val, emc_regbase + addr);
54 }
55
56 static inline u32 emc_readl(unsigned long addr)
57 {
58         return readl(emc_regbase + addr);
59 }
60
61 /* read LPDDR2 memory modes */
62 static int tegra_emc_read_mrr(unsigned long addr)
63 {
64         u32 value;
65         int count = 100;
66
67         mutex_lock(&tegra_emc_mrr_lock);
68         do {
69                 emc_readl(TEGRA_EMC_MRR);
70         } while (--count && (emc_readl(TEGRA_EMC_STATUS) & TEGRA_MRR_DIVLD));
71         if (count == 0) {
72                 pr_err("%s: Failed to read memory type\n", __func__);
73                 BUG();
74         }
75         value = (1 << 30) | (addr << 16);
76         emc_writel(value, TEGRA_EMC_MRR);
77
78         count = 100;
79         while (--count && !(emc_readl(TEGRA_EMC_STATUS) & TEGRA_MRR_DIVLD));
80         if (count == 0) {
81                 pr_err("%s: Failed to read memory type\n", __func__);
82                 BUG();
83         }
84         value = emc_readl(TEGRA_EMC_MRR) & 0xFFFF;
85         mutex_unlock(&tegra_emc_mrr_lock);
86
87         return value;
88 }
89
90 static const unsigned long emc_reg_addr[TEGRA_EMC_NUM_REGS] = {
91         0x2c,   /* RC */
92         0x30,   /* RFC */
93         0x34,   /* RAS */
94         0x38,   /* RP */
95         0x3c,   /* R2W */
96         0x40,   /* W2R */
97         0x44,   /* R2P */
98         0x48,   /* W2P */
99         0x4c,   /* RD_RCD */
100         0x50,   /* WR_RCD */
101         0x54,   /* RRD */
102         0x58,   /* REXT */
103         0x5c,   /* WDV */
104         0x60,   /* QUSE */
105         0x64,   /* QRST */
106         0x68,   /* QSAFE */
107         0x6c,   /* RDV */
108         0x70,   /* REFRESH */
109         0x74,   /* BURST_REFRESH_NUM */
110         0x78,   /* PDEX2WR */
111         0x7c,   /* PDEX2RD */
112         0x80,   /* PCHG2PDEN */
113         0x84,   /* ACT2PDEN */
114         0x88,   /* AR2PDEN */
115         0x8c,   /* RW2PDEN */
116         0x90,   /* TXSR */
117         0x94,   /* TCKE */
118         0x98,   /* TFAW */
119         0x9c,   /* TRPAB */
120         0xa0,   /* TCLKSTABLE */
121         0xa4,   /* TCLKSTOP */
122         0xa8,   /* TREFBW */
123         0xac,   /* QUSE_EXTRA */
124         0x114,  /* FBIO_CFG6 */
125         0xb0,   /* ODT_WRITE */
126         0xb4,   /* ODT_READ */
127         0x104,  /* FBIO_CFG5 */
128         0x2bc,  /* CFG_DIG_DLL */
129         0x2c0,  /* DLL_XFORM_DQS */
130         0x2c4,  /* DLL_XFORM_QUSE */
131         0x2e0,  /* ZCAL_REF_CNT */
132         0x2e4,  /* ZCAL_WAIT_CNT */
133         0x2a8,  /* AUTO_CAL_INTERVAL */
134         0x2d0,  /* CFG_CLKTRIM_0 */
135         0x2d4,  /* CFG_CLKTRIM_1 */
136         0x2d8,  /* CFG_CLKTRIM_2 */
137 };
138
139 /* Select the closest EMC rate that is higher than the requested rate */
140 long tegra_emc_round_rate(unsigned long rate)
141 {
142         struct tegra_emc_pdata *pdata;
143         int i;
144         int best = -1;
145         unsigned long distance = ULONG_MAX;
146
147         if (!emc_pdev)
148                 return -EINVAL;
149
150         pdata = emc_pdev->dev.platform_data;
151
152         if (rate >= tegra_emc_max_bus_rate) {
153                 best = tegra_emc_table_size - 1;
154                 goto round_out;
155         } else if (rate <= tegra_emc_min_bus_rate) {
156                 best = 0;
157                 goto round_out;
158         }
159
160         pr_debug("%s: %lu\n", __func__, rate);
161
162         /*
163          * The EMC clock rate is twice the bus rate, and the bus rate is
164          * measured in kHz
165          */
166         rate = rate / 2 / 1000;
167
168         for (i = 0; i < pdata->num_tables; i++) {
169                 if (pdata->tables[i].rate >= rate &&
170                     (pdata->tables[i].rate - rate) < distance) {
171                         distance = pdata->tables[i].rate - rate;
172                         best = i;
173                 }
174         }
175
176         if (best < 0)
177                 return -EINVAL;
178
179 round_out:
180         pr_debug("%s: using %lu\n", __func__, pdata->tables[best].rate);
181
182         return pdata->tables[best].rate * 2 * 1000;
183 }
184
185 /*
186  * The EMC registers have shadow registers.  When the EMC clock is updated
187  * in the clock controller, the shadow registers are copied to the active
188  * registers, allowing glitchless memory bus frequency changes.
189  * This function updates the shadow registers for a new clock frequency,
190  * and relies on the clock lock on the emc clock to avoid races between
191  * multiple frequency changes
192  */
193 int tegra_emc_set_rate(unsigned long rate)
194 {
195         struct tegra_emc_pdata *pdata;
196         int i;
197         int j;
198
199         if (!emc_pdev)
200                 return -EINVAL;
201
202         pdata = emc_pdev->dev.platform_data;
203
204         /*
205          * The EMC clock rate is twice the bus rate, and the bus rate is
206          * measured in kHz
207          */
208         rate = rate / 2 / 1000;
209
210         for (i = 0; i < pdata->num_tables; i++)
211                 if (pdata->tables[i].rate == rate)
212                         break;
213
214         if (i >= pdata->num_tables)
215                 return -EINVAL;
216
217         pr_debug("%s: setting to %lu\n", __func__, rate);
218
219         for (j = 0; j < TEGRA_EMC_NUM_REGS; j++)
220                 emc_writel(pdata->tables[i].regs[j], emc_reg_addr[j]);
221
222         emc_readl(pdata->tables[i].regs[TEGRA_EMC_NUM_REGS - 1]);
223
224         return 0;
225 }
226
227 static void tegra_emc_match_chip_data(struct platform_device *pdev)
228 {
229         int i;
230         int vid;
231         int rev_id1;
232         int rev_id2;
233         int pid;
234         struct tegra_emc_pdata *pchips = pdev->dev.platform_data;
235         int chips_size = pchips->num_tables;
236
237         vid = tegra_emc_read_mrr(5);
238         rev_id1 = tegra_emc_read_mrr(6);
239         rev_id2 = tegra_emc_read_mrr(7);
240         pid = tegra_emc_read_mrr(8);
241
242         for (i = 0; i < chips_size; i++) {
243                 if (pchips[i].mem_manufacturer_id >= 0) {
244                         if (pchips[i].mem_manufacturer_id != vid)
245                                 continue;
246                 }
247                 if (pchips[i].mem_revision_id1 >= 0) {
248                         if (pchips[i].mem_revision_id1 != rev_id1)
249                                 continue;
250                 }
251                 if (pchips[i].mem_revision_id2 >= 0) {
252                         if (pchips[i].mem_revision_id2 != rev_id2)
253                                 continue;
254                 }
255                 if (pchips[i].mem_pid >= 0) {
256                         if (pchips[i].mem_pid != pid)
257                                 continue;
258                 }
259
260                 pr_info("%s: %s memory found\n", __func__,
261                         pchips[i].description);
262                 tegra_emc_table = pchips[i].tables;
263                 tegra_emc_table_size = pchips[i].num_tables;
264
265                 tegra_emc_min_bus_rate = tegra_emc_table[0].rate * 2 * 1000;
266                 tegra_emc_max_bus_rate = tegra_emc_table[tegra_emc_table_size - 1].rate * 2 * 1000;
267                 goto out;
268         }
269
270         pr_err("%s: Memory not recognized, memory scaling disabled\n",
271                 __func__);
272 out:
273         pr_info("%s: Memory vid     = 0x%04x", __func__, vid);
274         pr_info("%s: Memory rev_id1 = 0x%04x", __func__, rev_id1);
275         pr_info("%s: Memory rev_id2 = 0x%04x", __func__, rev_id2);
276         pr_info("%s: Memory pid     = 0x%04x", __func__, pid);
277 }
278
279 #ifdef CONFIG_OF
280 static struct device_node *tegra_emc_ramcode_devnode(struct device_node *np)
281 {
282         struct device_node *iter;
283         u32 reg;
284
285         for_each_child_of_node(np, iter) {
286                 if (of_property_read_u32(np, "nvidia,ram-code", &reg))
287                         continue;
288                 if (reg == tegra_bct_strapping)
289                         return of_node_get(iter);
290         }
291
292         return NULL;
293 }
294
295 static struct tegra_emc_pdata *tegra_emc_dt_parse_pdata(
296                 struct platform_device *pdev)
297 {
298         struct device_node *np = pdev->dev.of_node;
299         struct device_node *tnp, *iter;
300         struct tegra_emc_pdata *pdata;
301         int ret, i, num_tables;
302
303         if (!np)
304                 return NULL;
305
306         if (of_find_property(np, "nvidia,use-ram-code", NULL)) {
307                 tnp = tegra_emc_ramcode_devnode(np);
308                 if (!tnp)
309                         dev_warn(&pdev->dev,
310                                  "can't find emc table for ram-code 0x%02x\n",
311                                  tegra_bct_strapping);
312         } else
313                 tnp = of_node_get(np);
314
315         if (!tnp)
316                 return NULL;
317
318         num_tables = 0;
319         for_each_child_of_node(tnp, iter)
320                 if (of_device_is_compatible(iter, "nvidia,tegra20-emc-table"))
321                         num_tables++;
322
323         if (!num_tables) {
324                 pdata = NULL;
325                 goto out;
326         }
327
328         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
329         pdata->tables = devm_kzalloc(&pdev->dev,
330                                      sizeof(*pdata->tables) * num_tables,
331                                      GFP_KERNEL);
332
333         i = 0;
334         for_each_child_of_node(tnp, iter) {
335                 u32 prop;
336
337                 ret = of_property_read_u32(iter, "clock-frequency", &prop);
338                 if (ret) {
339                         dev_err(&pdev->dev, "no clock-frequency in %s\n",
340                                 iter->full_name);
341                         continue;
342                 }
343                 pdata->tables[i].rate = prop;
344
345                 ret = of_property_read_u32_array(iter, "nvidia,emc-registers",
346                                                  pdata->tables[i].regs,
347                                                  TEGRA_EMC_NUM_REGS);
348                 if (ret) {
349                         dev_err(&pdev->dev,
350                                 "malformed emc-registers property in %s\n",
351                                 iter->full_name);
352                         continue;
353                 }
354
355                 i++;
356         }
357         pdata->num_tables = i;
358
359 out:
360         of_node_put(tnp);
361         return pdata;
362 }
363 #else
364 static struct tegra_emc_pdata *tegra_emc_dt_parse_pdata(
365                 struct platform_device *pdev)
366 {
367         return NULL;
368 }
369 #endif
370
371 static struct tegra_emc_pdata *tegra_emc_fill_pdata(struct platform_device *pdev)
372 {
373         struct clk *c = clk_get_sys(NULL, "emc");
374         struct tegra_emc_pdata *pdata;
375         unsigned long khz;
376         int i;
377
378         WARN_ON(pdev->dev.platform_data);
379         BUG_ON(IS_ERR(c));
380
381         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
382         pdata->tables = devm_kzalloc(&pdev->dev, sizeof(*pdata->tables),
383                                      GFP_KERNEL);
384
385         pdata->tables[0].rate = clk_get_rate(c) / 2 / 1000;
386
387         for (i = 0; i < TEGRA_EMC_NUM_REGS; i++)
388                 pdata->tables[0].regs[i] = emc_readl(emc_reg_addr[i]);
389
390         pdata->num_tables = 1;
391
392         khz = pdata->tables[0].rate;
393         dev_info(&pdev->dev, "no tables provided, using %ld kHz emc, "
394                  "%ld kHz mem\n", khz * 2, khz);
395
396         return pdata;
397 }
398
399 static int tegra_emc_probe(struct platform_device *pdev)
400 {
401         struct tegra_emc_pdata *pdata;
402         struct resource *res;
403
404         if (!emc_enable) {
405                 dev_err(&pdev->dev, "disabled per module parameter\n");
406                 return -ENODEV;
407         }
408
409         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
410         if (!res) {
411                 dev_err(&pdev->dev, "missing register base\n");
412                 return -ENOMEM;
413         }
414
415         emc_regbase = devm_request_and_ioremap(&pdev->dev, res);
416         if (!emc_regbase) {
417                 dev_err(&pdev->dev, "failed to remap registers\n");
418                 return -ENOMEM;
419         }
420
421         pdata = pdev->dev.platform_data;
422
423         if (pdata)
424                 tegra_emc_match_chip_data(pdev);
425
426         if (!pdata)
427                 pdata = tegra_emc_dt_parse_pdata(pdev);
428
429         if (!pdata)
430                 pdata = tegra_emc_fill_pdata(pdev);
431
432         pdev->dev.platform_data = pdata;
433
434         emc_pdev = pdev;
435
436         return 0;
437 }
438
439 static struct of_device_id tegra_emc_of_match[] = {
440         { .compatible = "nvidia,tegra20-emc", },
441         { },
442 };
443
444 static struct platform_driver tegra_emc_driver = {
445         .driver         = {
446                 .name   = "tegra-emc",
447                 .owner  = THIS_MODULE,
448                 .of_match_table = tegra_emc_of_match,
449         },
450         .probe          = tegra_emc_probe,
451 };
452
453 int __init tegra_emc_init(void)
454 {
455         return platform_driver_register(&tegra_emc_driver);
456 }