ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[linux-3.10.git] / arch / arm / mach-tegra / include / mach / uncompress.h
1 /*
2 * arch/arm/mach-tegra/include/mach/uncompress.h
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Copyright (C) 2011 Google, Inc.
6  *
7  * Author:
8  *      Colin Cross <ccross@google.com>
9  *      Erik Gilling <konkers@google.com>
10  *      Doug Anderson <dianders@chromium.org>
11  *      Stephen Warren <swarren@nvidia.com>
12  *
13  * Copyright (C) 2011-2013 NVIDIA CORPORATION. All Rights Reserved.
14  *
15  * This software is licensed under the terms of the GNU General Public
16  * License version 2, as published by the Free Software Foundation, and
17  * may be copied, distributed, and modified under those terms.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  */
25
26 #ifndef __MACH_TEGRA_UNCOMPRESS_H
27 #define __MACH_TEGRA_UNCOMPRESS_H
28
29 #include <linux/types.h>
30 #include <linux/serial_reg.h>
31
32 #include "../../iomap.h"
33
34 #define BIT(x) (1 << (x))
35 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
36
37 #define DEBUG_UART_SHIFT 2
38
39 volatile u8 *uart;
40
41 #if defined(CONFIG_TEGRA_DEBUG_UARTA)
42 #define DEBUG_UART_CLK_SRC              (TEGRA_CLK_RESET_BASE + 0x178)
43 #define DEBUG_UART_CLK_ENB_SET_REG      (TEGRA_CLK_RESET_BASE + 0x320)
44 #define DEBUG_UART_CLK_ENB_SET_BIT      (1 << 6)
45 #define DEBUG_UART_RST_CLR_REG          (TEGRA_CLK_RESET_BASE + 0x304)
46 #define DEBUG_UART_RST_CLR_BIT          (1 << 6)
47 #elif defined(CONFIG_TEGRA_DEBUG_UARTB)
48 #define DEBUG_UART_CLK_SRC              (TEGRA_CLK_RESET_BASE + 0x17c)
49 #define DEBUG_UART_CLK_ENB_SET_REG      (TEGRA_CLK_RESET_BASE + 0x320)
50 #define DEBUG_UART_CLK_ENB_SET_BIT      (1 << 7)
51 #define DEBUG_UART_RST_CLR_REG          (TEGRA_CLK_RESET_BASE + 0x304)
52 #define DEBUG_UART_RST_CLR_BIT          (1 << 7)
53 #elif defined(CONFIG_TEGRA_DEBUG_UARTC)
54 #define DEBUG_UART_CLK_SRC              (TEGRA_CLK_RESET_BASE + 0x1a0)
55 #define DEBUG_UART_CLK_ENB_SET_REG      (TEGRA_CLK_RESET_BASE + 0x328)
56 #define DEBUG_UART_CLK_ENB_SET_BIT      (1 << 23)
57 #define DEBUG_UART_RST_CLR_REG          (TEGRA_CLK_RESET_BASE + 0x30C)
58 #define DEBUG_UART_RST_CLR_BIT          (1 << 23)
59 #elif defined(CONFIG_TEGRA_DEBUG_UARTD)
60 #define DEBUG_UART_CLK_SRC              (TEGRA_CLK_RESET_BASE + 0x1c0)
61 #define DEBUG_UART_CLK_ENB_SET_REG      (TEGRA_CLK_RESET_BASE + 0x330)
62 #define DEBUG_UART_CLK_ENB_SET_BIT      (1 << 1)
63 #define DEBUG_UART_RST_CLR_REG          (TEGRA_CLK_RESET_BASE + 0x314)
64 #define DEBUG_UART_RST_CLR_BIT          (1 << 1)
65 #elif defined(CONFIG_TEGRA_DEBUG_UARTE)
66 #define DEBUG_UART_CLK_SRC              (TEGRA_CLK_RESET_BASE + 0x1c4)
67 #define DEBUG_UART_CLK_ENB_SET_REG      (TEGRA_CLK_RESET_BASE + 0x330)
68 #define DEBUG_UART_CLK_ENB_SET_BIT      (1 << 2)
69 #define DEBUG_UART_RST_CLR_REG          (TEGRA_CLK_RESET_BASE + 0x314)
70 #define DEBUG_UART_RST_CLR_BIT          (1 << 2)
71 #else
72 #define DEBUG_UART_CLK_SRC              0
73 #define DEBUG_UART_CLK_ENB_SET_REG      0
74 #define DEBUG_UART_CLK_ENB_SET_BIT      0
75 #define DEBUG_UART_RST_CLR_REG          0
76 #define DEBUG_UART_RST_CLR_BIT          0
77 #endif
78 #define PLLP_BASE                       (TEGRA_CLK_RESET_BASE + 0x0a0)
79 #define PLLP_BASE_OVERRIDE              (1 << 28)
80 #define PLLP_BASE_DIVP_SHIFT            20
81 #define PLLP_BASE_DIVP_MASK             (0x7 << 20)
82 #define PLLP_BASE_DIVN_SHIFT            8
83 #define PLLP_BASE_DIVN_MASK             (0x3FF << 8)
84
85 #define DEBUG_UART_CLK_CLKM             0x6
86 #define DEBUG_UART_CLK_SHIFT            29
87
88 #define DEBUG_UART_DLL_216              0x75
89 #define DEBUG_UART_DLL_408              0xdd
90 #define DEBUG_UART_DLL_204              0x6f
91 #define DEBUG_UART_DLL_13               0x7
92 static void putc(int c)
93 {
94         if (uart == NULL)
95                 return;
96
97         while (!(uart[UART_LSR << DEBUG_UART_SHIFT] & UART_LSR_THRE))
98                 barrier();
99         uart[UART_TX << DEBUG_UART_SHIFT] = c;
100 }
101
102 static inline void flush(void)
103 {
104 }
105
106 static inline void konk_delay(int delay)
107 {
108         int i;
109
110         for (i = 0; i < (1000 * delay); i++) {
111                 barrier();
112         }
113 }
114
115 static const struct {
116         u32 base;
117         u32 reset_reg;
118         u32 clock_reg;
119         u32 bit;
120 } uarts[] = {
121         {
122                 TEGRA_UARTA_BASE,
123                 TEGRA_CLK_RESET_BASE + 0x04,
124                 TEGRA_CLK_RESET_BASE + 0x10,
125                 6,
126         },
127         {
128                 TEGRA_UARTB_BASE,
129                 TEGRA_CLK_RESET_BASE + 0x04,
130                 TEGRA_CLK_RESET_BASE + 0x10,
131                 7,
132         },
133         {
134                 TEGRA_UARTC_BASE,
135                 TEGRA_CLK_RESET_BASE + 0x08,
136                 TEGRA_CLK_RESET_BASE + 0x14,
137                 23,
138         },
139         {
140                 TEGRA_UARTD_BASE,
141                 TEGRA_CLK_RESET_BASE + 0x0c,
142                 TEGRA_CLK_RESET_BASE + 0x18,
143                 1,
144         },
145         {
146                 TEGRA_UARTE_BASE,
147                 TEGRA_CLK_RESET_BASE + 0x0c,
148                 TEGRA_CLK_RESET_BASE + 0x18,
149                 2,
150         },
151 };
152
153 static inline bool uart_clocked(int i)
154 {
155         if (*(u8 *)uarts[i].reset_reg & BIT(uarts[i].bit))
156                 return false;
157
158         if (!(*(u8 *)uarts[i].clock_reg & BIT(uarts[i].bit)))
159                 return false;
160
161         return true;
162 }
163
164 #ifdef CONFIG_TEGRA_DEBUG_UART_AUTO_ODMDATA
165 int auto_odmdata(void)
166 {
167         volatile u32 *pmc = (volatile u32 *)TEGRA_PMC_BASE;
168         u32 odmdata = pmc[0xa0 / 4];
169         u32 uart_port;
170
171         /*
172          * Bits 19:18 are the console type: 0=default, 1=none, 2==DCC, 3==UART
173          * Some boards apparently swap the last two values, but we don't have
174          * any way of catering for that here, so we just accept either. If this
175          * doesn't make sense for your board, just don't enable this feature.
176          *
177          * Bits 17:15 indicate the UART to use, 0/1/2/3/4 are UART A/B/C/D/E.
178          * 5 indicates that UART over uSD is enabled over UARTA
179          */
180
181         switch  ((odmdata >> 18) & 3) {
182         case 2:
183         case 3:
184                 break;
185         default:
186                 return -1;
187         }
188
189         uart_port = (odmdata >> 15) & 7;
190         if (uart_port == 5)
191                 uart_port = 0;
192         return uart_port;
193 }
194 #endif
195
196
197 static inline int tegra_platform_is_fpga(void)
198 {
199 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
200         u32 chip_id = *(volatile u32 *)(TEGRA_APB_MISC_BASE + 0x804);
201         u32 minor = chip_id >> 16 & 0xf;
202
203         return (minor == 1);
204 #else
205         return 0;
206 #endif
207 }
208
209 /*
210  * Setup before decompression.  This is where we do UART selection for
211  * earlyprintk and init the uart_base register.
212  */
213 static inline void arch_decomp_setup(void)
214 {
215         int uart_id = -1;
216         volatile u32 *addr;
217         u32 uart_dll = DEBUG_UART_DLL_216;
218         u32 val;
219
220 #if defined(CONFIG_TEGRA_DEBUG_UART_AUTO_ODMDATA)
221         uart_id = auto_odmdata();
222 #elif defined(CONFIG_TEGRA_DEBUG_UARTA)
223         uart_id = 0;
224 #elif defined(CONFIG_TEGRA_DEBUG_UARTB)
225         uart_id = 1;
226 #elif defined(CONFIG_TEGRA_DEBUG_UARTC)
227         uart_id = 2;
228 #elif defined(CONFIG_TEGRA_DEBUG_UARTD)
229         uart_id = 3;
230 #elif defined(CONFIG_TEGRA_DEBUG_UARTE)
231         uart_id = 4;
232 #endif
233
234         if (uart_id < 0 || uart_id >= ARRAY_SIZE(uarts) ||
235             !uart_clocked(uart_id))
236                 uart = NULL;
237         else
238                 uart = (volatile u8 *)uarts[uart_id].base;
239
240         if (uart == NULL)
241                 return;
242
243
244         addr = (volatile u32 *)DEBUG_UART_CLK_SRC;
245         if (tegra_platform_is_fpga())
246                 /* Debug UART clock source is clk_m on FGPA Platforms. */
247                 *addr = DEBUG_UART_CLK_CLKM << DEBUG_UART_CLK_SHIFT;
248         else
249                 /* Debug UART clock source is PLLP_OUT0. */
250                 *addr = 0;
251
252         /* Enable clock to debug UART. */
253         addr = (volatile u32 *)DEBUG_UART_CLK_ENB_SET_REG;
254         *addr = DEBUG_UART_CLK_ENB_SET_BIT;
255
256         konk_delay(5);
257
258         /* Deassert reset to debug UART. */
259         addr = (volatile u32 *)DEBUG_UART_RST_CLR_REG;
260         *addr = DEBUG_UART_RST_CLR_BIT;
261
262         konk_delay(5);
263
264         /*
265          * On Tegra2 platforms PLLP always run at 216MHz
266          * On Tegra3 platforms PLLP can run at 216MHz, 204MHz, or 408MHz
267          * Discrimantion algorithm below assumes that PLLP is configured
268          * according to h/w recomendations with update rate 1MHz or 1.2MHz
269          * depending on oscillator frequency
270          * clk_m runs at 13 Mhz
271          */
272         if (tegra_platform_is_fpga()) {
273                 (void) val;
274                 uart_dll = DEBUG_UART_DLL_13;
275         } else {
276                 #ifdef CONFIG_ARCH_TEGRA_14x_SOC
277                         uart_dll = DEBUG_UART_DLL_408;
278                 #else
279                 addr = (volatile u32 *)PLLP_BASE;
280                 val = *addr;
281                 if (val & PLLP_BASE_OVERRIDE) {
282                         u32 p = (val & PLLP_BASE_DIVP_MASK)
283                                          >> PLLP_BASE_DIVP_SHIFT;
284                         val = (val & PLLP_BASE_DIVN_MASK)
285                                          >> (PLLP_BASE_DIVN_SHIFT + p);
286                         switch (val) {
287                         case 170:
288                         case 204:
289                                 uart_dll = DEBUG_UART_DLL_204;
290                                 break;
291                         case 340:
292                         case 408:
293                                 uart_dll = DEBUG_UART_DLL_408;
294                                 break;
295                         case 180:
296                         case 216:
297                         default:
298                                 break;
299                         }
300                 }
301                 #endif
302         }
303         /* Set up debug UART. */
304         uart[UART_LCR << DEBUG_UART_SHIFT] |= UART_LCR_DLAB;
305         uart[UART_DLL << DEBUG_UART_SHIFT] = uart_dll;
306         uart[UART_DLM << DEBUG_UART_SHIFT] = 0x0;
307         uart[UART_LCR << DEBUG_UART_SHIFT] = 3;
308 }
309
310 #endif