ARM: tegra: powermon: Fix copyrights from GPLv3 to GPLv2
[linux-3.10.git] / arch / arm / mach-tegra / tegra14x_fuse_offsets.h
1 /*
2  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
3  *
4  * this program is free software; you can redistribute it and/or modify
5  * it under the terms of the gnu general public license as published by
6  * the free software foundation; either version 2 of the license, or
7  * (at your option) any later version.
8  *
9  * this program is distributed in the hope that it will be useful, but without
10  * any warranty; without even the implied warranty of merchantability or
11  * fitness for a particular purpose.  see the gnu general public license for
12  * more details.
13  *
14  * you should have received a copy of the gnu general public license along
15  * with this program; if not, write to the free software foundation, inc.,
16  * 51 franklin street, fifth floor, boston, ma  02110-1301, usa.
17  */
18
19 #include <mach/tegra_fuse.h>
20 #include <mach/hardware.h>
21
22 #include "apbio.h"
23 #include "fuse.h"
24 #include "iomap.h"
25
26 #ifndef __TEGRA14x_FUSE_OFFSETS_H
27 #define __TEGRA14x_FUSE_OFFSETS_H
28
29 /* private_key4 */
30 #define DEVKEY_START_OFFSET             0x2C
31 #define DEVKEY_START_BIT                11
32
33 /* arm_debug_dis */
34 #define JTAG_START_OFFSET               0x0
35 #define JTAG_START_BIT                  3
36
37 /* security_mode */
38 #define ODM_PROD_START_OFFSET           0x0
39 #define ODM_PROD_START_BIT              11
40
41 /* boot_device_info */
42 #define SB_DEVCFG_START_OFFSET          0x2E
43 #define SB_DEVCFG_START_BIT             11
44
45 /* reserved_sw[2:0] */
46 #define SB_DEVSEL_START_OFFSET          0x2E
47 #define SB_DEVSEL_START_BIT             27
48
49 /* private_key0 -> private_key3 (SBK) */
50 #define SBK_START_OFFSET                0x24
51 #define SBK_START_BIT                   11
52
53 /* reserved_sw[7:4] */
54 #define SW_RESERVED_START_OFFSET        0x2E
55 #define SW_RESERVED_START_BIT           31
56
57 /* reserved_sw[3] */
58 #define IGNORE_DEVSEL_START_OFFSET      0x2E
59 #define IGNORE_DEVSEL_START_BIT         30
60
61 /* public key */
62 #define PUBLIC_KEY_START_OFFSET         0x0A
63 #define PUBLIC_KEY_START_BIT            29
64
65 /* pkc_disable */
66 #define PKC_DISABLE_START_OFFSET        0x5C
67 #define PKC_DISABLE_START_BIT           0
68
69 /* video vp8 enable */
70 #define VP8_ENABLE_START_OFFSET         0x30
71 #define VP8_ENABLE_START_BIT            3
72
73 /* odm lock */
74 #define ODM_LOCK_START_OFFSET           0x0
75 #define ODM_LOCK_START_BIT              6
76
77 /* reserved_odm0 -> reserved_odm7 */
78 #define ODM_RESERVED_DEVSEL_START_OFFSET        0x30
79 #define ODM_RESERVED_START_BIT                  4
80
81 #define FUSE_VENDOR_CODE        0x200
82 #define FUSE_VENDOR_CODE_MASK   0xf
83 #define FUSE_FAB_CODE           0x204
84 #define FUSE_FAB_CODE_MASK      0x3f
85 #define FUSE_LOT_CODE_0         0x208
86 #define FUSE_LOT_CODE_1         0x20c
87 #define FUSE_WAFER_ID           0x210
88 #define FUSE_WAFER_ID_MASK      0x3f
89 #define FUSE_X_COORDINATE       0x214
90 #define FUSE_X_COORDINATE_MASK  0x1ff
91 #define FUSE_Y_COORDINATE       0x218
92 #define FUSE_Y_COORDINATE_MASK  0x1ff
93 #define FUSE_GPU_INFO           0x390
94 #define FUSE_GPU_INFO_MASK      (1<<2)
95 #define FUSE_SPARE_BIT          0x2a0
96 /* fuse registers used in public fuse data read API */
97 #define FUSE_TEST_PROGRAM_REVISION_0    0x128
98 /* fuse spare bits are used to get Tj-ADT values */
99 #define NUM_TSENSOR_SPARE_BITS  28
100 /* tsensor calibration register */
101 #define FUSE_TSENSOR_CALIB_0    0x198
102 #define FUSE_VSENSOR_CALIB_0    0x18c
103
104 #define TEGRA_FUSE_SUPPLY       "vpp_fuse"
105
106 int fuse_pgm_cycles[] = {156, 202, 0, 0, 231, 461, 0, 0, 144, 576, 0, 0, 312};
107
108 #define CHK_ERR(x) \
109 { \
110         if (x) { \
111                 pr_err("%s: sysfs_create_file fail(%d)!", __func__, x); \
112                 return x; \
113         } \
114 }
115
116 DEVICE_ATTR(public_key, 0440, tegra_fuse_show, tegra_fuse_store);
117 DEVICE_ATTR(pkc_disable, 0440, tegra_fuse_show, tegra_fuse_store);
118 DEVICE_ATTR(vp8_enable, 0440, tegra_fuse_show, tegra_fuse_store);
119 DEVICE_ATTR(odm_lock, 0440, tegra_fuse_show, tegra_fuse_store);
120
121 int tegra_fuse_get_revision(u32 *rev)
122 {
123         /* fuse revision */
124         *rev = tegra_fuse_readl(FUSE_TEST_PROGRAM_REVISION_0);
125         return 0;
126 }
127
128 int tegra_fuse_get_tsensor_calibration_data(u32 *calib)
129 {
130         /* tsensor calibration fuse */
131         *calib = tegra_fuse_readl(FUSE_TSENSOR_CALIB_0);
132         return 0;
133 }
134
135 int tegra_fuse_get_tsensor_spare_bits(u32 *spare_bits)
136 {
137         u32 value;
138         int i;
139
140         BUG_ON(NUM_TSENSOR_SPARE_BITS > (sizeof(u32) * 8));
141         if (!spare_bits)
142                 return -ENOMEM;
143         *spare_bits = 0;
144         /* spare bits 0-27 */
145         for (i = 0; i < NUM_TSENSOR_SPARE_BITS; i++) {
146                 value = tegra_fuse_readl(FUSE_SPARE_BIT +
147                         (i << 2));
148                 if (value)
149                         *spare_bits |= BIT(i);
150         }
151         return 0;
152 }
153
154 unsigned long long tegra_chip_uid(void)
155 {
156
157         u64 uid = 0ull;
158         u32 reg;
159         u32 cid;
160         u32 vendor;
161         u32 fab;
162         u32 lot;
163         u32 wafer;
164         u32 x;
165         u32 y;
166         u32 i;
167
168         /* This used to be so much easier in prior chips. Unfortunately, there
169            is no one-stop shopping for the unique id anymore. It must be
170            constructed from various bits of information burned into the fuses
171            during the manufacturing process. The 64-bit unique id is formed
172            by concatenating several bit fields. The notation used for the
173            various fields is <fieldname:size_in_bits> with the UID composed
174            thusly:
175
176            <CID:4><VENDOR:4><FAB:6><LOT:26><WAFER:6><X:9><Y:9>
177
178            Where:
179
180                 Field    Bits  Position Data
181                 -------  ----  -------- ----------------------------------------
182                 CID        4     60     Chip id
183                 VENDOR     4     56     Vendor code
184                 FAB        6     50     FAB code
185                 LOT       26     24     Lot code (5-digit base-36-coded-decimal,
186                                         re-encoded to 26 bits binary)
187                 WAFER      6     18     Wafer id
188                 X          9      9     Wafer X-coordinate
189                 Y          9      0     Wafer Y-coordinate
190                 -------  ----
191                 Total     64
192         */
193
194         /* chip id is 2 for tegra 14x */
195         cid = 2;
196
197         vendor = tegra_fuse_readl(FUSE_VENDOR_CODE) & FUSE_VENDOR_CODE_MASK;
198         fab = tegra_fuse_readl(FUSE_FAB_CODE) & FUSE_FAB_CODE_MASK;
199
200         /* Lot code must be re-encoded from a 5 digit base-36 'BCD' number
201            to a binary number. */
202         lot = 0;
203         reg = tegra_fuse_readl(FUSE_LOT_CODE_0) << 2;
204
205         for (i = 0; i < 5; ++i) {
206                 u32 digit = (reg & 0xFC000000) >> 26;
207                 BUG_ON(digit >= 36);
208                 lot *= 36;
209                 lot += digit;
210                 reg <<= 6;
211         }
212
213         wafer = tegra_fuse_readl(FUSE_WAFER_ID) & FUSE_WAFER_ID_MASK;
214         x = tegra_fuse_readl(FUSE_X_COORDINATE) & FUSE_X_COORDINATE_MASK;
215         y = tegra_fuse_readl(FUSE_Y_COORDINATE) & FUSE_Y_COORDINATE_MASK;
216
217         uid = ((unsigned long long)cid  << 60ull)
218             | ((unsigned long long)vendor << 56ull)
219             | ((unsigned long long)fab << 50ull)
220             | ((unsigned long long)lot << 24ull)
221             | ((unsigned long long)wafer << 18ull)
222             | ((unsigned long long)x << 9ull)
223             | ((unsigned long long)y << 0ull);
224         return uid;
225 }
226
227 int tegra_fuse_get_vsensor_calib(u32 *calib)
228 {
229         *calib = tegra_fuse_readl(FUSE_VSENSOR_CALIB_0);
230         return 0;
231 }
232
233 static int tsensor_calib_offset[] = {
234         [0] = 0x198,
235         [1] = 0x184,
236         [2] = 0x188,
237         [3] = 0x22c,
238         [4] = 0x254,
239         [5] = 0x258,
240         [6] = 0x25c,
241         [7] = 0x260,
242 };
243
244 int tegra_fuse_get_tsensor_calib(int index, u32 *calib)
245 {
246         if (index < 0 || index > 7)
247                 return -EINVAL;
248         *calib = tegra_fuse_readl(tsensor_calib_offset[index]);
249         return 0;
250 }
251
252 int tegra_fuse_add_sysfs_variables(struct platform_device *pdev,
253                                         bool odm_security_mode)
254 {
255         dev_attr_odm_lock.attr.mode = 0640;
256         if (odm_security_mode) {
257                 dev_attr_public_key.attr.mode =  0440;
258                 dev_attr_pkc_disable.attr.mode = 0440;
259                 dev_attr_vp8_enable.attr.mode = 0440;
260         } else {
261                 dev_attr_public_key.attr.mode =  0640;
262                 dev_attr_pkc_disable.attr.mode = 0640;
263                 dev_attr_vp8_enable.attr.mode = 0640;
264         }
265         CHK_ERR(sysfs_create_file(&pdev->dev.kobj, &dev_attr_public_key.attr));
266         CHK_ERR(sysfs_create_file(&pdev->dev.kobj, &dev_attr_pkc_disable.attr));
267         CHK_ERR(sysfs_create_file(&pdev->dev.kobj, &dev_attr_vp8_enable.attr));
268         CHK_ERR(sysfs_create_file(&pdev->dev.kobj, &dev_attr_odm_lock.attr));
269
270         return 0;
271 }
272
273 int tegra_fuse_rm_sysfs_variables(struct platform_device *pdev)
274 {
275         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_public_key.attr);
276         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_pkc_disable.attr);
277         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_vp8_enable.attr);
278         sysfs_remove_file(&pdev->dev.kobj, &dev_attr_odm_lock.attr);
279
280         return 0;
281 }
282
283 int tegra_fuse_ch_sysfs_perm(struct kobject *kobj)
284 {
285         CHK_ERR(sysfs_chmod_file(kobj, &dev_attr_public_key.attr, 0440));
286         CHK_ERR(sysfs_chmod_file(kobj, &dev_attr_pkc_disable.attr, 0440));
287         CHK_ERR(sysfs_chmod_file(kobj, &dev_attr_vp8_enable.attr, 0440));
288
289         return 0;
290 }
291 #endif /* __TEGRA14x_FUSE_OFFSETS_H */