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