Revert "Merge commit 'main-jb-2012.08.03-B4' into t114-0806"
[linux-2.6.git] / arch / arm / mach-tegra / fuse.c
1 /*
2  * arch/arm/mach-tegra/fuse.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Copyright (C) 2010-2012 NVIDIA Corp.
6  *
7  * Author:
8  *      Colin Cross <ccross@android.com>
9  *
10  * This software is licensed under the terms of the GNU General Public
11  * License version 2, as published by the Free Software Foundation, and
12  * may be copied, distributed, and modified under those terms.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/io.h>
23 #include <linux/init.h>
24 #include <linux/string.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/export.h>
28
29 #include <mach/iomap.h>
30 #include <mach/tegra_fuse.h>
31 #include <mach/hardware.h>
32
33 #include "fuse.h"
34 #include "apbio.h"
35
36 #define FUSE_SKU_INFO           0x110
37 #define FUSE_VP8_ENABLE_0       0x1c4
38 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
39 #define FUSE_UID_LOW            0x108
40 #define FUSE_UID_HIGH           0x10c
41 #define FUSE_SPARE_BIT          0x200
42 #else
43 #define FUSE_VENDOR_CODE        0x200
44 #define FUSE_VENDOR_CODE_MASK   0xf
45 #define FUSE_FAB_CODE           0x204
46 #define FUSE_FAB_CODE_MASK      0x3f
47 #define FUSE_LOT_CODE_0         0x208
48 #define FUSE_LOT_CODE_1         0x20c
49 #define FUSE_WAFER_ID           0x210
50 #define FUSE_WAFER_ID_MASK      0x3f
51 #define FUSE_X_COORDINATE       0x214
52 #define FUSE_X_COORDINATE_MASK  0x1ff
53 #define FUSE_Y_COORDINATE       0x218
54 #define FUSE_Y_COORDINATE_MASK  0x1ff
55 #define FUSE_GPU_INFO           0x390
56 #define FUSE_GPU_INFO_MASK      (1<<2)
57 #define FUSE_SPARE_BIT          0x244
58 /* fuse registers used in public fuse data read API */
59 #define FUSE_TEST_PROGRAM_REVISION_0    0x128
60 /* fuse spare bits are used to get Tj-ADT values */
61 #define FUSE_SPARE_BIT_0_0      0x244
62 #define NUM_TSENSOR_SPARE_BITS  28
63 /* tsensor calibration register */
64 #define FUSE_TSENSOR_CALIB_0    0x198
65 #define FUSE_IDDQ_CALIB_0       0x118
66
67 #endif
68
69 struct tegra_id {
70         enum tegra_chipid chipid;
71         unsigned int major, minor, netlist, patch;
72         enum tegra_revision revision;
73         char *priv;
74 };
75
76 static struct tegra_id tegra_id;
77
78 int tegra_sku_id;
79 int tegra_chip_id;
80 enum tegra_revision tegra_revision;
81 static unsigned int tegra_fuse_vp8_enable;
82
83 /* The BCT to use at boot is specified by board straps that can be read
84  * through a APB misc register and decoded. 2 bits, i.e. 4 possible BCTs.
85  */
86 int tegra_bct_strapping;
87
88 #define STRAP_OPT 0x008
89 #define GMI_AD0 (1 << 4)
90 #define GMI_AD1 (1 << 5)
91 #define RAM_ID_MASK (GMI_AD0 | GMI_AD1)
92 #define RAM_CODE_SHIFT 4
93
94 static const char *tegra_revision_name[TEGRA_REVISION_MAX] = {
95         [TEGRA_REVISION_UNKNOWN] = "unknown",
96         [TEGRA_REVISION_A01]     = "A01",
97         [TEGRA_REVISION_A02]     = "A02",
98         [TEGRA_REVISION_A03]     = "A03",
99         [TEGRA_REVISION_A03p]    = "A03 prime",
100         [TEGRA_REVISION_A04]     = "A04",
101         [TEGRA_REVISION_A04p]    = "A04 prime",
102         [TEGRA_REVISION_QT]      = "QT",
103 };
104
105 u32 tegra_fuse_readl(unsigned long offset)
106 {
107         return tegra_apb_readl(TEGRA_FUSE_BASE + offset);
108 }
109
110 void tegra_fuse_writel(u32 val, unsigned long offset)
111 {
112         tegra_apb_writel(val, TEGRA_FUSE_BASE + offset);
113 }
114
115 static inline bool get_spare_fuse(int bit)
116 {
117         return tegra_fuse_readl(FUSE_SPARE_BIT + bit * 4);
118 }
119
120 const char *tegra_get_revision_name(void)
121 {
122         return tegra_revision_name[tegra_revision];
123 }
124
125 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
126 int tegra_fuse_get_revision(u32 *rev)
127 {
128         return -ENOENT;
129 }
130 EXPORT_SYMBOL(tegra_fuse_get_revision);
131
132 int tegra_fuse_get_tsensor_calibration_data(u32 *calib)
133 {
134         return -ENOENT;
135 }
136 EXPORT_SYMBOL(tegra_fuse_get_tsensor_calibration_data);
137
138 int tegra_fuse_get_tsensor_spare_bits(u32 *spare_bits)
139 {
140         return -ENOENT;
141 }
142 EXPORT_SYMBOL(tegra_fuse_get_tsensor_spare_bits);
143
144 #else
145
146 int tegra_fuse_get_revision(u32 *rev)
147 {
148         /* fuse revision */
149         *rev = tegra_fuse_readl(FUSE_TEST_PROGRAM_REVISION_0);
150         return 0;
151 }
152 EXPORT_SYMBOL(tegra_fuse_get_revision);
153
154 int tegra_fuse_get_tsensor_calibration_data(u32 *calib)
155 {
156         /* tsensor calibration fuse */
157         *calib = tegra_fuse_readl(FUSE_TSENSOR_CALIB_0);
158         return 0;
159 }
160 EXPORT_SYMBOL(tegra_fuse_get_tsensor_calibration_data);
161
162 int tegra_fuse_get_tsensor_spare_bits(u32 *spare_bits)
163 {
164         u32 value;
165         int i;
166
167         BUG_ON(NUM_TSENSOR_SPARE_BITS > (sizeof(u32) * 8));
168         if (!spare_bits)
169                 return -ENOMEM;
170         *spare_bits = 0;
171         /* spare bits 0-27 */
172         for (i = 0; i < NUM_TSENSOR_SPARE_BITS; i++) {
173                 value = tegra_fuse_readl(FUSE_SPARE_BIT_0_0 +
174                         (i << 2));
175                 if (value)
176                         *spare_bits |= BIT(i);
177         }
178         return 0;
179 }
180 EXPORT_SYMBOL(tegra_fuse_get_tsensor_spare_bits);
181
182 int tegra_fuse_get_cpu_iddq_mA(u32 *iddq)
183 {
184         *iddq = tegra_fuse_readl(FUSE_IDDQ_CALIB_0);
185         *iddq = ((*iddq >> 5) & 0x3ff) * 8;
186         return 0;
187 }
188 #endif
189
190 unsigned long long tegra_chip_uid(void)
191 {
192 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
193         unsigned long long lo, hi;
194
195         lo = tegra_fuse_readl(FUSE_UID_LOW);
196         hi = tegra_fuse_readl(FUSE_UID_HIGH);
197         return (hi << 32ull) | lo;
198 #else
199         u64 uid = 0ull;
200         u32 reg;
201         u32 cid;
202         u32 vendor;
203         u32 fab;
204         u32 lot;
205         u32 wafer;
206         u32 x;
207         u32 y;
208         u32 i;
209
210         /* This used to be so much easier in prior chips. Unfortunately, there
211            is no one-stop shopping for the unique id anymore. It must be
212            constructed from various bits of information burned into the fuses
213            during the manufacturing process. The 64-bit unique id is formed
214            by concatenating several bit fields. The notation used for the
215            various fields is <fieldname:size_in_bits> with the UID composed
216            thusly:
217
218            <CID:4><VENDOR:4><FAB:6><LOT:26><WAFER:6><X:9><Y:9>
219
220            Where:
221
222                 Field    Bits  Position Data
223                 -------  ----  -------- ----------------------------------------
224                 CID        4     60     Chip id
225                 VENDOR     4     56     Vendor code
226                 FAB        6     50     FAB code
227                 LOT       26     24     Lot code (5-digit base-36-coded-decimal,
228                                         re-encoded to 26 bits binary)
229                 WAFER      6     18     Wafer id
230                 X          9      9     Wafer X-coordinate
231                 Y          9      0     Wafer Y-coordinate
232                 -------  ----
233                 Total     64
234         */
235
236         /* Get the chip id and encode each chip variant as a unique value. */
237         reg = readl(IO_TO_VIRT(TEGRA_APB_MISC_BASE + 0x804));
238         reg = (reg & 0xFF00) >> 8;
239
240         switch (reg) {
241         case TEGRA_CHIPID_TEGRA3:
242                 cid = 0;
243                 break;
244
245         case TEGRA_CHIPID_TEGRA11:
246                 cid = 1;
247                 break;
248
249         default:
250                 BUG();
251                 break;
252         }
253
254         vendor = tegra_fuse_readl(FUSE_VENDOR_CODE) & FUSE_VENDOR_CODE_MASK;
255         fab = tegra_fuse_readl(FUSE_FAB_CODE) & FUSE_FAB_CODE_MASK;
256
257         /* Lot code must be re-encoded from a 5 digit base-36 'BCD' number
258            to a binary number. */
259         lot = 0;
260         reg = tegra_fuse_readl(FUSE_LOT_CODE_0) << 2;
261
262         for (i = 0; i < 5; ++i) {
263                 u32 digit = (reg & 0xFC000000) >> 26;
264                 BUG_ON(digit >= 36);
265                 lot *= 36;
266                 lot += digit;
267                 reg <<= 6;
268         }
269
270         wafer = tegra_fuse_readl(FUSE_WAFER_ID) & FUSE_WAFER_ID_MASK;
271         x = tegra_fuse_readl(FUSE_X_COORDINATE) & FUSE_X_COORDINATE_MASK;
272         y = tegra_fuse_readl(FUSE_Y_COORDINATE) & FUSE_Y_COORDINATE_MASK;
273
274         uid = ((unsigned long long)cid  << 60ull)
275             | ((unsigned long long)vendor << 56ull)
276             | ((unsigned long long)fab << 50ull)
277             | ((unsigned long long)lot << 24ull)
278             | ((unsigned long long)wafer << 18ull)
279             | ((unsigned long long)x << 9ull)
280             | ((unsigned long long)y << 0ull);
281         return uid;
282 #endif
283 }
284
285 unsigned int tegra_spare_fuse(int bit)
286 {
287         BUG_ON(bit < 0 || bit > 61);
288         return tegra_fuse_readl(FUSE_SPARE_BIT + bit * 4);
289 }
290
291 int tegra_gpu_register_sets(void)
292 {
293 #ifdef CONFIG_ARCH_TEGRA_HAS_DUAL_3D
294         u32 reg = readl(IO_TO_VIRT(TEGRA_CLK_RESET_BASE + FUSE_GPU_INFO));
295         if (reg & FUSE_GPU_INFO_MASK)
296                 return 1;
297         else
298                 return 2;
299 #else
300         return 1;
301 #endif
302 }
303
304 #if defined(CONFIG_TEGRA_SILICON_PLATFORM)
305 struct chip_revision {
306         enum tegra_chipid       chipid;
307         unsigned int            major;
308         unsigned int            minor;
309         char                    prime;
310         enum tegra_revision     revision;
311 };
312
313 #define CHIP_REVISION(id, m, n, p, rev) {       \
314         .chipid = TEGRA_CHIPID_##id,            \
315         .major = m,                             \
316         .minor = n,                             \
317         .prime = p,                             \
318         .revision = TEGRA_REVISION_##rev }
319
320 static struct chip_revision tegra_chip_revisions[] = {
321         CHIP_REVISION(TEGRA2,  1, 2, 0,   A02),
322         CHIP_REVISION(TEGRA2,  1, 3, 0,   A03),
323         CHIP_REVISION(TEGRA2,  1, 3, 'p', A03p),
324         CHIP_REVISION(TEGRA2,  1, 4, 0,   A04),
325         CHIP_REVISION(TEGRA2,  1, 4, 'p', A04p),
326         CHIP_REVISION(TEGRA3,  1, 1, 0,   A01),
327         CHIP_REVISION(TEGRA3,  1, 2, 0,   A02),
328         CHIP_REVISION(TEGRA3,  1, 3, 0,   A03),
329         CHIP_REVISION(TEGRA11, 1, 0, 0,   A01),
330 };
331 #endif
332
333 static enum tegra_revision tegra_decode_revision(const struct tegra_id *id)
334 {
335         enum tegra_revision revision = TEGRA_REVISION_UNKNOWN;
336
337 #if defined(CONFIG_TEGRA_SILICON_PLATFORM)
338         int i ;
339         char prime;
340
341         if (id->priv == NULL)
342                 prime = 0;
343         else
344                 prime = *(id->priv);
345
346         for (i = 0; i < ARRAY_SIZE(tegra_chip_revisions); i++) {
347                 if ((id->chipid != tegra_chip_revisions[i].chipid) ||
348                     (id->minor != tegra_chip_revisions[i].minor) ||
349                     (id->major != tegra_chip_revisions[i].major) ||
350                     (prime != tegra_chip_revisions[i].prime))
351                         continue;
352
353                 revision = tegra_chip_revisions[i].revision;
354                 break;
355         }
356
357 #elif defined(CONFIG_TEGRA_FPGA_PLATFORM)
358         if (id->major == 0) {
359                 if (id->minor == 1)
360                         revision = TEGRA_REVISION_A01;
361                 else
362                         revision = TEGRA_REVISION_QT;
363         }
364 #elif defined(CONFIG_TEGRA_SIMULATION_PLATFORM)
365         if ((id->chipid & 0xff) == TEGRA_CHIPID_TEGRA11)
366                 revision = TEGRA_REVISION_A01;
367 #endif
368
369         return revision;
370 }
371
372 static void tegra_set_tegraid(u32 chipid,
373                                         u32 major, u32 minor,
374                                         u32 nlist, u32 patch, const char *priv)
375 {
376         tegra_id.chipid  = (enum tegra_chipid) chipid;
377         tegra_id.major   = major;
378         tegra_id.minor   = minor;
379         tegra_id.netlist = nlist;
380         tegra_id.patch   = patch;
381         tegra_id.priv    = (char *)priv;
382         tegra_id.revision = tegra_decode_revision(&tegra_id);
383 }
384
385 static void tegra_get_tegraid_from_hw(void)
386 {
387         void __iomem *chip_id = IO_ADDRESS(TEGRA_APB_MISC_BASE) + 0x804;
388         void __iomem *netlist = IO_ADDRESS(TEGRA_APB_MISC_BASE) + 0x860;
389         u32 cid = readl(chip_id);
390         u32 nlist = readl(netlist);
391         char *priv = NULL;
392
393 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
394         if (get_spare_fuse(18) || get_spare_fuse(19))
395                 priv = "p";
396 #endif
397         tegra_set_tegraid((cid >> 8) & 0xff,
398                           (cid >> 4) & 0xf,
399                           (cid >> 16) & 0xf,
400                           (nlist >> 0) & 0xffff,
401                           (nlist >> 16) & 0xffff,
402                           priv);
403 }
404
405 enum tegra_chipid tegra_get_chipid(void)
406 {
407         if (tegra_id.chipid == TEGRA_CHIPID_UNKNOWN)
408                 tegra_get_tegraid_from_hw();
409
410         return tegra_id.chipid;
411 }
412
413 enum tegra_revision tegra_get_revision(void)
414 {
415         if (tegra_id.chipid == TEGRA_CHIPID_UNKNOWN)
416                 tegra_get_tegraid_from_hw();
417
418         return tegra_id.revision;
419 }
420
421 #ifndef CONFIG_TEGRA_SILICON_PLATFORM
422 void tegra_get_netlist_revision(u32 *netlist, u32* patchid)
423 {
424         if (tegra_id.chipid == TEGRA_CHIPID_UNKNOWN) {
425                 /* Boot loader did not pass a valid chip ID.
426                  * Get it from hardware */
427                 tegra_get_tegraid_from_hw();
428         }
429         *netlist = tegra_id.netlist;
430         *patchid = tegra_id.patch & 0xF;
431 }
432 #endif
433
434 static int get_chip_id(char *val, const struct kernel_param *kp)
435 {
436         return param_get_uint(val, kp);
437 }
438
439 static int get_revision(char *val, const struct kernel_param *kp)
440 {
441         return param_get_uint(val, kp);
442 }
443
444 static struct kernel_param_ops tegra_chip_id_ops = {
445         .get = get_chip_id,
446 };
447
448 static struct kernel_param_ops tegra_revision_ops = {
449         .get = get_revision,
450 };
451
452 module_param_cb(tegra_chip_id, &tegra_chip_id_ops, &tegra_id.chipid, 0444);
453 module_param_cb(tegra_chip_rev, &tegra_revision_ops, &tegra_id.revision, 0444);
454
455 void tegra_init_fuse(void)
456 {
457         u32 id;
458
459         u32 reg = readl(IO_TO_VIRT(TEGRA_CLK_RESET_BASE + 0x48));
460         reg |= 1 << 28;
461         writel(reg, IO_TO_VIRT(TEGRA_CLK_RESET_BASE + 0x48));
462
463         reg = tegra_fuse_readl(FUSE_SKU_INFO);
464         tegra_sku_id = reg & 0xFF;
465
466         reg = tegra_apb_readl(TEGRA_APB_MISC_BASE + STRAP_OPT);
467         tegra_bct_strapping = (reg & RAM_ID_MASK) >> RAM_CODE_SHIFT;
468
469         id = readl_relaxed(IO_ADDRESS(TEGRA_APB_MISC_BASE) + 0x804);
470         tegra_chip_id = (id >> 8) & 0xff;
471
472         tegra_revision = tegra_get_revision();
473
474         tegra_init_speedo_data();
475
476         pr_info("Tegra Revision: %s SKU: 0x%x CPU Process: %d Core Process: %d\n",
477                 tegra_revision_name[tegra_revision],
478                 tegra_sku_id, tegra_cpu_process_id(),
479                 tegra_core_process_id());
480 }
481
482 static unsigned int get_fuse_vp8_enable(char *val, struct kernel_param *kp)
483 {
484         if (tegra_get_chipid() == TEGRA_CHIPID_TEGRA2 ||
485                  tegra_get_chipid() == TEGRA_CHIPID_TEGRA3)
486                 tegra_fuse_vp8_enable = 0;
487         else
488                 tegra_fuse_vp8_enable =  tegra_fuse_readl(FUSE_VP8_ENABLE_0);
489
490         return param_get_uint(val, kp);
491 }
492
493 module_param_call(tegra_fuse_vp8_enable, NULL, get_fuse_vp8_enable,
494                 &tegra_fuse_vp8_enable, 0444);
495 __MODULE_PARM_TYPE(tegra_fuse_vp8_enable, "uint");