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