rtc: tps80031: register as mfd sub device
[linux-2.6.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/clk.h>
20 #include <linux/err.h>
21 #include <linux/io.h>
22 #include <linux/module.h>
23
24 #include <mach/iomap.h>
25
26 #include "tegra2_emc.h"
27
28 #define TEGRA_MRR_DIVLD        (1<<20)
29 #define TEGRA_EMC_STATUS       0x02b4
30 #define TEGRA_EMC_MRR          0x00ec
31 static DEFINE_MUTEX(tegra_emc_mrr_lock);
32
33 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
34 static bool emc_enable = true;
35 #else
36 static bool emc_enable;
37 #endif
38 module_param(emc_enable, bool, 0644);
39
40 static void __iomem *emc = IO_ADDRESS(TEGRA_EMC_BASE);
41 static const struct tegra_emc_table *tegra_emc_table;
42 static int tegra_emc_table_size;
43
44 static unsigned long tegra_emc_max_bus_rate;  /* 2 * 1000 * maximum emc_clock rate */
45 static unsigned long tegra_emc_min_bus_rate;  /* 2 * 1000 * minimum emc_clock rate */
46
47 static inline void emc_writel(u32 val, unsigned long addr)
48 {
49         writel(val, emc + addr);
50 }
51
52 static inline u32 emc_readl(unsigned long addr)
53 {
54         return readl(emc + addr);
55 }
56
57 /* read LPDDR2 memory modes */
58 static int tegra_emc_read_mrr(unsigned long addr)
59 {
60         u32 value;
61         int count = 100;
62
63         mutex_lock(&tegra_emc_mrr_lock);
64         do {
65                 emc_readl(TEGRA_EMC_MRR);
66         } while (--count && (emc_readl(TEGRA_EMC_STATUS) & TEGRA_MRR_DIVLD));
67         if (count == 0) {
68                 pr_err("%s: Failed to read memory type\n", __func__);
69                 BUG();
70         }
71         value = (1 << 30) | (addr << 16);
72         emc_writel(value, TEGRA_EMC_MRR);
73
74         count = 100;
75         while (--count && !(emc_readl(TEGRA_EMC_STATUS) & TEGRA_MRR_DIVLD));
76         if (count == 0) {
77                 pr_err("%s: Failed to read memory type\n", __func__);
78                 BUG();
79         }
80         value = emc_readl(TEGRA_EMC_MRR) & 0xFFFF;
81         mutex_unlock(&tegra_emc_mrr_lock);
82
83         return value;
84 }
85
86 static const unsigned long emc_reg_addr[TEGRA_EMC_NUM_REGS] = {
87         0x2c,   /* RC */
88         0x30,   /* RFC */
89         0x34,   /* RAS */
90         0x38,   /* RP */
91         0x3c,   /* R2W */
92         0x40,   /* W2R */
93         0x44,   /* R2P */
94         0x48,   /* W2P */
95         0x4c,   /* RD_RCD */
96         0x50,   /* WR_RCD */
97         0x54,   /* RRD */
98         0x58,   /* REXT */
99         0x5c,   /* WDV */
100         0x60,   /* QUSE */
101         0x64,   /* QRST */
102         0x68,   /* QSAFE */
103         0x6c,   /* RDV */
104         0x70,   /* REFRESH */
105         0x74,   /* BURST_REFRESH_NUM */
106         0x78,   /* PDEX2WR */
107         0x7c,   /* PDEX2RD */
108         0x80,   /* PCHG2PDEN */
109         0x84,   /* ACT2PDEN */
110         0x88,   /* AR2PDEN */
111         0x8c,   /* RW2PDEN */
112         0x90,   /* TXSR */
113         0x94,   /* TCKE */
114         0x98,   /* TFAW */
115         0x9c,   /* TRPAB */
116         0xa0,   /* TCLKSTABLE */
117         0xa4,   /* TCLKSTOP */
118         0xa8,   /* TREFBW */
119         0xac,   /* QUSE_EXTRA */
120         0x114,  /* FBIO_CFG6 */
121         0xb0,   /* ODT_WRITE */
122         0xb4,   /* ODT_READ */
123         0x104,  /* FBIO_CFG5 */
124         0x2bc,  /* CFG_DIG_DLL */
125         0x2c0,  /* DLL_XFORM_DQS */
126         0x2c4,  /* DLL_XFORM_QUSE */
127         0x2e0,  /* ZCAL_REF_CNT */
128         0x2e4,  /* ZCAL_WAIT_CNT */
129         0x2a8,  /* AUTO_CAL_INTERVAL */
130         0x2d0,  /* CFG_CLKTRIM_0 */
131         0x2d4,  /* CFG_CLKTRIM_1 */
132         0x2d8,  /* CFG_CLKTRIM_2 */
133 };
134
135 /* Select the closest EMC rate that is higher than the requested rate */
136 long tegra_emc_round_rate(unsigned long rate)
137 {
138         int i;
139         int best = -1;
140         unsigned long distance = ULONG_MAX;
141
142         if (!tegra_emc_table)
143                 return -EINVAL;
144
145         if (!emc_enable)
146                 return -EINVAL;
147
148         if (rate >= tegra_emc_max_bus_rate) {
149                 best = tegra_emc_table_size - 1;
150                 goto round_out;
151         } else if (rate <= tegra_emc_min_bus_rate) {
152                 best = 0;
153                 goto round_out;
154         }
155
156         pr_debug("%s: %lu\n", __func__, rate);
157
158         /*
159          * The EMC clock rate is twice the bus rate, and the bus rate is
160          * measured in kHz
161          */
162         rate = rate / 2 / 1000;
163
164         for (i = 0; i < tegra_emc_table_size; i++) {
165                 if (tegra_emc_table[i].rate >= rate &&
166                     (tegra_emc_table[i].rate - rate) < distance) {
167                         distance = tegra_emc_table[i].rate - rate;
168                         best = i;
169                 }
170         }
171
172         if (best < 0)
173                 return -EINVAL;
174 round_out:
175         pr_debug("%s: using %lu\n", __func__, tegra_emc_table[best].rate);
176
177         return tegra_emc_table[best].rate * 2 * 1000;
178 }
179
180 /*
181  * The EMC registers have shadow registers.  When the EMC clock is updated
182  * in the clock controller, the shadow registers are copied to the active
183  * registers, allowing glitchless memory bus frequency changes.
184  * This function updates the shadow registers for a new clock frequency,
185  * and relies on the clock lock on the emc clock to avoid races between
186  * multiple frequency changes
187  */
188 int tegra_emc_set_rate(unsigned long rate)
189 {
190         int i;
191         int j;
192
193         if (!tegra_emc_table)
194                 return -EINVAL;
195
196         /*
197          * The EMC clock rate is twice the bus rate, and the bus rate is
198          * measured in kHz
199          */
200         rate = rate / 2 / 1000;
201
202         for (i = tegra_emc_table_size - 1; i >= 0; i--)
203                 if (tegra_emc_table[i].rate == rate)
204                         break;
205
206         if (i < 0)
207                 return -EINVAL;
208
209         pr_debug("%s: setting to %lu\n", __func__, rate);
210
211         for (j = 0; j < TEGRA_EMC_NUM_REGS; j++)
212                 emc_writel(tegra_emc_table[i].regs[j], emc_reg_addr[j]);
213
214         emc_readl(tegra_emc_table[i].regs[TEGRA_EMC_NUM_REGS - 1]);
215
216         return 0;
217 }
218
219 void tegra_init_emc(const struct tegra_emc_chip *chips, int chips_size)
220 {
221         int i;
222         int vid;
223         int rev_id1;
224         int rev_id2;
225         int pid;
226         int chip_matched = -1;
227
228         vid = tegra_emc_read_mrr(5);
229         rev_id1 = tegra_emc_read_mrr(6);
230         rev_id2 = tegra_emc_read_mrr(7);
231         pid = tegra_emc_read_mrr(8);
232
233         for (i = 0; i < chips_size; i++) {
234                 if (chips[i].mem_manufacturer_id >= 0) {
235                         if (chips[i].mem_manufacturer_id != vid)
236                                 continue;
237                 }
238                 if (chips[i].mem_revision_id1 >= 0) {
239                         if (chips[i].mem_revision_id1 != rev_id1)
240                                 continue;
241                 }
242                 if (chips[i].mem_revision_id2 >= 0) {
243                         if (chips[i].mem_revision_id2 != rev_id2)
244                                 continue;
245                 }
246                 if (chips[i].mem_pid >= 0) {
247                         if (chips[i].mem_pid != pid)
248                                 continue;
249                 }
250
251                 chip_matched = i;
252                 break;
253         }
254
255         if (chip_matched >= 0) {
256                 pr_info("%s: %s memory found\n", __func__,
257                         chips[chip_matched].description);
258                 tegra_emc_table = chips[chip_matched].table;
259                 tegra_emc_table_size = chips[chip_matched].table_size;
260
261                 tegra_emc_min_bus_rate = tegra_emc_table[0].rate * 2 * 1000;
262                 tegra_emc_max_bus_rate = tegra_emc_table[tegra_emc_table_size - 1].rate * 2 * 1000;
263
264         } else {
265                 pr_err("%s: Memory not recognized, memory scaling disabled\n",
266                         __func__);
267                 pr_info("%s: Memory vid     = 0x%04x", __func__, vid);
268                 pr_info("%s: Memory rev_id1 = 0x%04x", __func__, rev_id1);
269                 pr_info("%s: Memory rev_id2 = 0x%04x", __func__, rev_id2);
270                 pr_info("%s: Memory pid     = 0x%04x", __func__, pid);
271         }
272 }