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 #define TEGRA_AGE_0_6 0x2cc /*Spare bit 34*/
70 #define TEGRA_AGE_1_6 0x308 /*Spare bit 49*/
71 #define TEGRA_AGE_0_5 0x2c8 /*Spare bit 33*/
72 #define TEGRA_AGE_1_5 0x304 /*Spare bit 48*/
73 #define TEGRA_AGE_0_4 0x2c4 /*Spare bit 32*/
74 #define TEGRA_AGE_1_4 0x300 /*Spare bit 47*/
75 #define TEGRA_AGE_0_3 0x2c0 /*Spare bit 31*/
76 #define TEGRA_AGE_1_3 0x2fc /*Spare bit 46*/
77 #define TEGRA_AGE_0_2 0x2bc /*Spare bit 30*/
78 #define TEGRA_AGE_1_2 0x2f8 /*Spare bit 45*/
79 #define TEGRA_AGE_0_1 0x2b8 /*Spare bit 29*/
80 #define TEGRA_AGE_1_1 0x2f4 /*Spare bit 44*/
81 #define TEGRA_AGE_0_0 0x2b4 /*Spare bit 28*/
82 #define TEGRA_AGE_1_0 0x2f0 /*Spare bit 43*/
83
84 struct tegra_id {
85         enum tegra_chipid chipid;
86         unsigned int major, minor, netlist, patch;
87         enum tegra_revision revision;
88         char *priv;
89 };
90
91 static struct tegra_id tegra_id;
92
93 int tegra_sku_id;
94 int tegra_chip_id;
95 enum tegra_revision tegra_revision;
96 static unsigned int tegra_fuse_vp8_enable;
97
98 /* The BCT to use at boot is specified by board straps that can be read
99  * through a APB misc register and decoded. 2 bits, i.e. 4 possible BCTs.
100  */
101 int tegra_bct_strapping;
102
103 #define STRAP_OPT 0x008
104 #define GMI_AD0 (1 << 4)
105 #define GMI_AD1 (1 << 5)
106 #define RAM_ID_MASK (GMI_AD0 | GMI_AD1)
107 #define RAM_CODE_SHIFT 4
108
109 static const char *tegra_revision_name[TEGRA_REVISION_MAX] = {
110         [TEGRA_REVISION_UNKNOWN] = "unknown",
111         [TEGRA_REVISION_A01]     = "A01",
112         [TEGRA_REVISION_A02]     = "A02",
113         [TEGRA_REVISION_A03]     = "A03",
114         [TEGRA_REVISION_A03p]    = "A03 prime",
115         [TEGRA_REVISION_A04]     = "A04",
116         [TEGRA_REVISION_A04p]    = "A04 prime",
117         [TEGRA_REVISION_QT]      = "QT",
118 };
119
120 u32 tegra_fuse_readl(unsigned long offset)
121 {
122         return tegra_apb_readl(TEGRA_FUSE_BASE + offset);
123 }
124
125 void tegra_fuse_writel(u32 val, unsigned long offset)
126 {
127         tegra_apb_writel(val, TEGRA_FUSE_BASE + offset);
128 }
129
130 static inline bool get_spare_fuse(int bit)
131 {
132         return tegra_fuse_readl(FUSE_SPARE_BIT + bit * 4);
133 }
134
135 const char *tegra_get_revision_name(void)
136 {
137         return tegra_revision_name[tegra_revision];
138 }
139
140 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
141 int tegra_fuse_get_revision(u32 *rev)
142 {
143         return -ENOENT;
144 }
145 EXPORT_SYMBOL(tegra_fuse_get_revision);
146
147 int tegra_fuse_get_tsensor_calibration_data(u32 *calib)
148 {
149         return -ENOENT;
150 }
151 EXPORT_SYMBOL(tegra_fuse_get_tsensor_calibration_data);
152
153 int tegra_fuse_get_tsensor_spare_bits(u32 *spare_bits)
154 {
155         return -ENOENT;
156 }
157 EXPORT_SYMBOL(tegra_fuse_get_tsensor_spare_bits);
158
159 #else
160
161 int tegra_fuse_get_revision(u32 *rev)
162 {
163         /* fuse revision */
164         *rev = tegra_fuse_readl(FUSE_TEST_PROGRAM_REVISION_0);
165         return 0;
166 }
167 EXPORT_SYMBOL(tegra_fuse_get_revision);
168
169 int tegra_fuse_get_tsensor_calibration_data(u32 *calib)
170 {
171         /* tsensor calibration fuse */
172         *calib = tegra_fuse_readl(FUSE_TSENSOR_CALIB_0);
173         return 0;
174 }
175 EXPORT_SYMBOL(tegra_fuse_get_tsensor_calibration_data);
176
177 int tegra_fuse_get_tsensor_spare_bits(u32 *spare_bits)
178 {
179         u32 value;
180         int i;
181
182         BUG_ON(NUM_TSENSOR_SPARE_BITS > (sizeof(u32) * 8));
183         if (!spare_bits)
184                 return -ENOMEM;
185         *spare_bits = 0;
186         /* spare bits 0-27 */
187         for (i = 0; i < NUM_TSENSOR_SPARE_BITS; i++) {
188                 value = tegra_fuse_readl(FUSE_SPARE_BIT_0_0 +
189                         (i << 2));
190                 if (value)
191                         *spare_bits |= BIT(i);
192         }
193         return 0;
194 }
195 EXPORT_SYMBOL(tegra_fuse_get_tsensor_spare_bits);
196
197 int tegra_fuse_get_cpu_iddq_mA(u32 *iddq)
198 {
199         *iddq = tegra_fuse_readl(FUSE_IDDQ_CALIB_0);
200         *iddq = ((*iddq >> 5) & 0x3ff) * 8;
201         return 0;
202 }
203 #endif
204
205 #define TEGRA_READ_AGE_BIT(n, bit, age) {\
206         bit = tegra_fuse_readl(TEGRA_AGE_0_##n);\
207         bit |= tegra_fuse_readl(TEGRA_AGE_1_##n);\
208         bit = bit << n;\
209         age |= bit;\
210 }
211
212 int tegra_get_age(void)
213 {
214         int linear_age, age_bit;
215         linear_age = age_bit = 0;
216
217         TEGRA_READ_AGE_BIT(6, age_bit, linear_age);
218         TEGRA_READ_AGE_BIT(5, age_bit, linear_age);
219         TEGRA_READ_AGE_BIT(4, age_bit, linear_age);
220         TEGRA_READ_AGE_BIT(3, age_bit, linear_age);
221         TEGRA_READ_AGE_BIT(2, age_bit, linear_age);
222         TEGRA_READ_AGE_BIT(1, age_bit, linear_age);
223         TEGRA_READ_AGE_BIT(0, age_bit, linear_age);
224
225         /*Default Aug, 2012*/
226         if (linear_age <= 0)
227                 linear_age = 8;
228
229         pr_info("TEGRA: Linear age: %d\n", linear_age);
230
231         return linear_age;
232 }
233
234 unsigned long long tegra_chip_uid(void)
235 {
236 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
237         unsigned long long lo, hi;
238
239         lo = tegra_fuse_readl(FUSE_UID_LOW);
240         hi = tegra_fuse_readl(FUSE_UID_HIGH);
241         return (hi << 32ull) | lo;
242 #else
243         u64 uid = 0ull;
244         u32 reg;
245         u32 cid;
246         u32 vendor;
247         u32 fab;
248         u32 lot;
249         u32 wafer;
250         u32 x;
251         u32 y;
252         u32 i;
253
254         /* This used to be so much easier in prior chips. Unfortunately, there
255            is no one-stop shopping for the unique id anymore. It must be
256            constructed from various bits of information burned into the fuses
257            during the manufacturing process. The 64-bit unique id is formed
258            by concatenating several bit fields. The notation used for the
259            various fields is <fieldname:size_in_bits> with the UID composed
260            thusly:
261
262            <CID:4><VENDOR:4><FAB:6><LOT:26><WAFER:6><X:9><Y:9>
263
264            Where:
265
266                 Field    Bits  Position Data
267                 -------  ----  -------- ----------------------------------------
268                 CID        4     60     Chip id
269                 VENDOR     4     56     Vendor code
270                 FAB        6     50     FAB code
271                 LOT       26     24     Lot code (5-digit base-36-coded-decimal,
272                                         re-encoded to 26 bits binary)
273                 WAFER      6     18     Wafer id
274                 X          9      9     Wafer X-coordinate
275                 Y          9      0     Wafer Y-coordinate
276                 -------  ----
277                 Total     64
278         */
279
280         /* Get the chip id and encode each chip variant as a unique value. */
281         reg = readl(IO_TO_VIRT(TEGRA_APB_MISC_BASE + 0x804));
282         reg = (reg & 0xFF00) >> 8;
283
284         switch (reg) {
285         case TEGRA_CHIPID_TEGRA3:
286                 cid = 0;
287                 break;
288
289         case TEGRA_CHIPID_TEGRA11:
290                 cid = 1;
291                 break;
292
293         default:
294                 BUG();
295                 break;
296         }
297
298         vendor = tegra_fuse_readl(FUSE_VENDOR_CODE) & FUSE_VENDOR_CODE_MASK;
299         fab = tegra_fuse_readl(FUSE_FAB_CODE) & FUSE_FAB_CODE_MASK;
300
301         /* Lot code must be re-encoded from a 5 digit base-36 'BCD' number
302            to a binary number. */
303         lot = 0;
304         reg = tegra_fuse_readl(FUSE_LOT_CODE_0) << 2;
305
306         for (i = 0; i < 5; ++i) {
307                 u32 digit = (reg & 0xFC000000) >> 26;
308                 BUG_ON(digit >= 36);
309                 lot *= 36;
310                 lot += digit;
311                 reg <<= 6;
312         }
313
314         wafer = tegra_fuse_readl(FUSE_WAFER_ID) & FUSE_WAFER_ID_MASK;
315         x = tegra_fuse_readl(FUSE_X_COORDINATE) & FUSE_X_COORDINATE_MASK;
316         y = tegra_fuse_readl(FUSE_Y_COORDINATE) & FUSE_Y_COORDINATE_MASK;
317
318         uid = ((unsigned long long)cid  << 60ull)
319             | ((unsigned long long)vendor << 56ull)
320             | ((unsigned long long)fab << 50ull)
321             | ((unsigned long long)lot << 24ull)
322             | ((unsigned long long)wafer << 18ull)
323             | ((unsigned long long)x << 9ull)
324             | ((unsigned long long)y << 0ull);
325         return uid;
326 #endif
327 }
328
329 unsigned int tegra_spare_fuse(int bit)
330 {
331         BUG_ON(bit < 0 || bit > 61);
332         return tegra_fuse_readl(FUSE_SPARE_BIT + bit * 4);
333 }
334
335 int tegra_gpu_register_sets(void)
336 {
337 #ifdef CONFIG_ARCH_TEGRA_HAS_DUAL_3D
338         u32 reg = readl(IO_TO_VIRT(TEGRA_CLK_RESET_BASE + FUSE_GPU_INFO));
339         if (reg & FUSE_GPU_INFO_MASK)
340                 return 1;
341         else
342                 return 2;
343 #else
344         return 1;
345 #endif
346 }
347
348 #if defined(CONFIG_TEGRA_SILICON_PLATFORM)
349 struct chip_revision {
350         enum tegra_chipid       chipid;
351         unsigned int            major;
352         unsigned int            minor;
353         char                    prime;
354         enum tegra_revision     revision;
355 };
356
357 #define CHIP_REVISION(id, m, n, p, rev) {       \
358         .chipid = TEGRA_CHIPID_##id,            \
359         .major = m,                             \
360         .minor = n,                             \
361         .prime = p,                             \
362         .revision = TEGRA_REVISION_##rev }
363
364 static struct chip_revision tegra_chip_revisions[] = {
365         CHIP_REVISION(TEGRA2,  1, 2, 0,   A02),
366         CHIP_REVISION(TEGRA2,  1, 3, 0,   A03),
367         CHIP_REVISION(TEGRA2,  1, 3, 'p', A03p),
368         CHIP_REVISION(TEGRA2,  1, 4, 0,   A04),
369         CHIP_REVISION(TEGRA2,  1, 4, 'p', A04p),
370         CHIP_REVISION(TEGRA3,  1, 1, 0,   A01),
371         CHIP_REVISION(TEGRA3,  1, 2, 0,   A02),
372         CHIP_REVISION(TEGRA3,  1, 3, 0,   A03),
373         CHIP_REVISION(TEGRA11, 1, 0, 0,   A01),
374 };
375 #endif
376
377 static enum tegra_revision tegra_decode_revision(const struct tegra_id *id)
378 {
379         enum tegra_revision revision = TEGRA_REVISION_UNKNOWN;
380
381 #if defined(CONFIG_TEGRA_SILICON_PLATFORM)
382         int i ;
383         char prime;
384
385         if (id->priv == NULL)
386                 prime = 0;
387         else
388                 prime = *(id->priv);
389
390         for (i = 0; i < ARRAY_SIZE(tegra_chip_revisions); i++) {
391                 if ((id->chipid != tegra_chip_revisions[i].chipid) ||
392                     (id->minor != tegra_chip_revisions[i].minor) ||
393                     (id->major != tegra_chip_revisions[i].major) ||
394                     (prime != tegra_chip_revisions[i].prime))
395                         continue;
396
397                 revision = tegra_chip_revisions[i].revision;
398                 break;
399         }
400
401 #elif defined(CONFIG_TEGRA_FPGA_PLATFORM)
402         if (id->major == 0) {
403                 if (id->minor == 1)
404                         revision = TEGRA_REVISION_A01;
405                 else
406                         revision = TEGRA_REVISION_QT;
407         }
408 #elif defined(CONFIG_TEGRA_SIMULATION_PLATFORM)
409         if ((id->chipid & 0xff) == TEGRA_CHIPID_TEGRA11)
410                 revision = TEGRA_REVISION_A01;
411 #endif
412
413         return revision;
414 }
415
416 static void tegra_set_tegraid(u32 chipid,
417                                         u32 major, u32 minor,
418                                         u32 nlist, u32 patch, const char *priv)
419 {
420         tegra_id.chipid  = (enum tegra_chipid) chipid;
421         tegra_id.major   = major;
422         tegra_id.minor   = minor;
423         tegra_id.netlist = nlist;
424         tegra_id.patch   = patch;
425         tegra_id.priv    = (char *)priv;
426         tegra_id.revision = tegra_decode_revision(&tegra_id);
427 }
428
429 static void tegra_get_tegraid_from_hw(void)
430 {
431         void __iomem *chip_id = IO_ADDRESS(TEGRA_APB_MISC_BASE) + 0x804;
432         void __iomem *netlist = IO_ADDRESS(TEGRA_APB_MISC_BASE) + 0x860;
433         u32 cid = readl(chip_id);
434         u32 nlist = readl(netlist);
435         char *priv = NULL;
436
437 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
438         if (get_spare_fuse(18) || get_spare_fuse(19))
439                 priv = "p";
440 #endif
441         tegra_set_tegraid((cid >> 8) & 0xff,
442                           (cid >> 4) & 0xf,
443                           (cid >> 16) & 0xf,
444                           (nlist >> 0) & 0xffff,
445                           (nlist >> 16) & 0xffff,
446                           priv);
447 }
448
449 enum tegra_chipid tegra_get_chipid(void)
450 {
451         if (tegra_id.chipid == TEGRA_CHIPID_UNKNOWN)
452                 tegra_get_tegraid_from_hw();
453
454         return tegra_id.chipid;
455 }
456
457 enum tegra_revision tegra_get_revision(void)
458 {
459         if (tegra_id.chipid == TEGRA_CHIPID_UNKNOWN)
460                 tegra_get_tegraid_from_hw();
461
462         return tegra_id.revision;
463 }
464
465 #ifndef CONFIG_TEGRA_SILICON_PLATFORM
466 void tegra_get_netlist_revision(u32 *netlist, u32* patchid)
467 {
468         if (tegra_id.chipid == TEGRA_CHIPID_UNKNOWN) {
469                 /* Boot loader did not pass a valid chip ID.
470                  * Get it from hardware */
471                 tegra_get_tegraid_from_hw();
472         }
473         *netlist = tegra_id.netlist;
474         *patchid = tegra_id.patch & 0xF;
475 }
476 #endif
477
478 static int get_chip_id(char *val, const struct kernel_param *kp)
479 {
480         return param_get_uint(val, kp);
481 }
482
483 static int get_revision(char *val, const struct kernel_param *kp)
484 {
485         return param_get_uint(val, kp);
486 }
487
488 static struct kernel_param_ops tegra_chip_id_ops = {
489         .get = get_chip_id,
490 };
491
492 static struct kernel_param_ops tegra_revision_ops = {
493         .get = get_revision,
494 };
495
496 module_param_cb(tegra_chip_id, &tegra_chip_id_ops, &tegra_id.chipid, 0444);
497 module_param_cb(tegra_chip_rev, &tegra_revision_ops, &tegra_id.revision, 0444);
498
499 void tegra_init_fuse(void)
500 {
501         u32 id;
502
503         u32 reg = readl(IO_TO_VIRT(TEGRA_CLK_RESET_BASE + 0x48));
504         reg |= 1 << 28;
505         writel(reg, IO_TO_VIRT(TEGRA_CLK_RESET_BASE + 0x48));
506
507         reg = tegra_fuse_readl(FUSE_SKU_INFO);
508         tegra_sku_id = reg & 0xFF;
509
510         reg = tegra_apb_readl(TEGRA_APB_MISC_BASE + STRAP_OPT);
511         tegra_bct_strapping = (reg & RAM_ID_MASK) >> RAM_CODE_SHIFT;
512
513         id = readl_relaxed(IO_ADDRESS(TEGRA_APB_MISC_BASE) + 0x804);
514         tegra_chip_id = (id >> 8) & 0xff;
515
516         tegra_revision = tegra_get_revision();
517
518         tegra_init_speedo_data();
519
520         pr_info("Tegra Revision: %s SKU: 0x%x CPU Process: %d Core Process: %d\n",
521                 tegra_revision_name[tegra_revision],
522                 tegra_sku_id, tegra_cpu_process_id(),
523                 tegra_core_process_id());
524 }
525
526 static unsigned int get_fuse_vp8_enable(char *val, struct kernel_param *kp)
527 {
528         if (tegra_get_chipid() == TEGRA_CHIPID_TEGRA2 ||
529                  tegra_get_chipid() == TEGRA_CHIPID_TEGRA3)
530                 tegra_fuse_vp8_enable = 0;
531         else
532                 tegra_fuse_vp8_enable =  tegra_fuse_readl(FUSE_VP8_ENABLE_0);
533
534         return param_get_uint(val, kp);
535 }
536
537 module_param_call(tegra_fuse_vp8_enable, NULL, get_fuse_vp8_enable,
538                 &tegra_fuse_vp8_enable, 0444);
539 __MODULE_PARM_TYPE(tegra_fuse_vp8_enable, "uint");