Merge commit 'main-jb-2012.08.03-B4' into t114-0806
[linux-2.6.git] / arch / arm / mach-tegra / tegra_odm_fuses.c
1 /*
2  * arch/arm/mach-tegra/tegra_odm_fuses.c
3  *
4  * Copyright (c) 2010-2011, NVIDIA Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19  */
20
21 /*
22  * Fuses are one time programmable bits on the chip which are used by
23  * the chip manufacturer and device manufacturers to store chip/device
24  * configurations. The fuse bits are encapsulated in a 32 x 64 array.
25  * If a fuse bit is programmed to 1, it cannot be reverted to 0. Either
26  * another fuse bit has to be used for the same purpose or a new chip
27  * needs to be used.
28  *
29  * Each and every fuse word has its own shadow word which resides adjacent to
30  * a particular fuse word. e.g. Fuse words 0-1 form a fuse-shadow pair.
31  * So in theory we have only 32 fuse words to work with.
32  * The shadow fuse word is a mirror of the actual fuse word at all times
33  * and this is maintained while programming a particular fuse.
34  */
35
36 #include <linux/kernel.h>
37 #include <linux/io.h>
38 #include <linux/mutex.h>
39 #include <linux/err.h>
40 #include <linux/delay.h>
41 #include <linux/slab.h>
42 #include <linux/sysfs.h>
43 #include <linux/kobject.h>
44 #include <linux/regulator/consumer.h>
45 #include <linux/ctype.h>
46 #include <linux/wakelock.h>
47 #include <linux/clk.h>
48 #include <linux/export.h>
49
50 #include <mach/tegra_odm_fuses.h>
51 #include <mach/iomap.h>
52
53 #include "fuse.h"
54
55 #define NFUSES  64
56 #define STATE_IDLE      (0x4 << 16)
57 #define SENSE_DONE      (0x1 << 30)
58
59 /* since fuse burning is irreversible, use this for testing */
60 #define ENABLE_FUSE_BURNING 1
61
62 /* fuse registers */
63 #define FUSE_CTRL               0x000
64 #define FUSE_REG_ADDR           0x004
65 #define FUSE_REG_READ           0x008
66 #define FUSE_REG_WRITE          0x00C
67 #define FUSE_TIME_PGM           0x01C
68 #define FUSE_PRIV2INTFC         0x020
69 #define FUSE_DIS_PGM            0x02C
70 #define FUSE_WRITE_ACCESS       0x030
71 #define FUSE_PWR_GOOD_SW        0x034
72
73 static struct kobject *fuse_kobj;
74
75 static ssize_t fuse_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf);
76 static ssize_t fuse_store(struct kobject *kobj, struct kobj_attribute *attr,
77         const char *buf, size_t count);
78
79 static struct kobj_attribute devkey_attr =
80         __ATTR(device_key, 0440, fuse_show, fuse_store);
81
82 static struct kobj_attribute jtagdis_attr =
83         __ATTR(jtag_disable, 0440, fuse_show, fuse_store);
84
85 static struct kobj_attribute odm_prod_mode_attr =
86         __ATTR(odm_production_mode, 0444, fuse_show, fuse_store);
87
88 static struct kobj_attribute sec_boot_dev_cfg_attr =
89         __ATTR(sec_boot_dev_cfg, 0440, fuse_show, fuse_store);
90
91 static struct kobj_attribute sec_boot_dev_sel_attr =
92         __ATTR(sec_boot_dev_sel, 0440, fuse_show, fuse_store);
93
94 static struct kobj_attribute sbk_attr =
95         __ATTR(secure_boot_key, 0440, fuse_show, fuse_store);
96
97 static struct kobj_attribute sw_rsvd_attr =
98         __ATTR(sw_reserved, 0440, fuse_show, fuse_store);
99
100 static struct kobj_attribute ignore_dev_sel_straps_attr =
101         __ATTR(ignore_dev_sel_straps, 0440, fuse_show, fuse_store);
102
103 static struct kobj_attribute odm_rsvd_attr =
104         __ATTR(odm_reserved, 0440, fuse_show, fuse_store);
105
106 static u32 fuse_pgm_data[NFUSES / 2];
107 static u32 fuse_pgm_mask[NFUSES / 2];
108 static u32 tmp_fuse_pgm_data[NFUSES / 2];
109
110 DEFINE_MUTEX(fuse_lock);
111
112 static struct fuse_data fuse_info;
113 struct regulator *vdd_fuse;
114 struct clk *clk_fuse;
115
116 #define FUSE_NAME_LEN   30
117
118 struct param_info {
119         u32 *addr;
120         int sz;
121         u32 start_off;
122         int start_bit;
123         int nbits;
124         int data_offset;
125         char sysfs_name[FUSE_NAME_LEN];
126 };
127
128 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
129
130 /* private_key4 */
131 #define DEVKEY_START_OFFSET 0x12
132 #define DEVKEY_START_BIT    8
133
134 /* arm_debug_dis */
135 #define JTAG_START_OFFSET 0x0
136 #define JTAG_START_BIT    24
137
138 /* security_mode */
139 #define ODM_PROD_START_OFFSET 0x0
140 #define ODM_PROD_START_BIT    23
141
142 /* boot_device_info */
143 #define SB_DEVCFG_START_OFFSET 0x14
144 #define SB_DEVCFG_START_BIT    8
145
146 /* reserved_sw[2:0] */
147 #define SB_DEVSEL_START_OFFSET 0x14
148 #define SB_DEVSEL_START_BIT    24
149
150 /* private_key0 -> private_key3 */
151 #define SBK_START_OFFSET 0x0A
152 #define SBK_START_BIT    8
153
154 /* reserved_sw[7:4] */
155 #define SW_RESERVED_START_OFFSET 0x14
156 #define SW_RESERVED_START_BIT    28
157
158 /* reserved_sw[3] */
159 #define IGNORE_DEVSEL_START_OFFSET 0x14
160 #define IGNORE_DEVSEL_START_BIT    27
161
162 /* reserved_odm0 -> reserved_odm7 */
163 #define ODM_RESERVED_DEVSEL_START_OFFSET 0x16
164 #define ODM_RESERVED_START_BIT           4
165
166 #elif defined(CONFIG_ARCH_TEGRA_3x_SOC)
167
168 /* private_key4 */
169 #define DEVKEY_START_OFFSET 0x16
170 #define DEVKEY_START_BIT    22
171
172 /* arm_debug_dis */
173 #define JTAG_START_OFFSET 0x0
174 #define JTAG_START_BIT    24
175
176 /* security_mode */
177 #define ODM_PROD_START_OFFSET 0x0
178 #define ODM_PROD_START_BIT    23
179
180 /* boot_device_info */
181 #define SB_DEVCFG_START_OFFSET 0x18
182 #define SB_DEVCFG_START_BIT    22
183
184 /* reserved_sw[2:0] */
185 #define SB_DEVSEL_START_OFFSET 0x1A
186 #define SB_DEVSEL_START_BIT    6
187
188 /* private_key0 -> private_key3 */
189 #define SBK_START_OFFSET 0x0E
190 #define SBK_START_BIT    22
191
192 /* reserved_sw[7:4] */
193 #define SW_RESERVED_START_OFFSET 0x1A
194 #define SW_RESERVED_START_BIT    10
195
196 /* reserved_sw[3] */
197 #define IGNORE_DEVSEL_START_OFFSET 0x1A
198 #define IGNORE_DEVSEL_START_BIT    9
199
200 /* reserved_odm0 -> reserved_odm7 */
201 #define ODM_RESERVED_DEVSEL_START_OFFSET 0x1A
202 #define ODM_RESERVED_START_BIT    14
203
204 #else
205
206 #define DEVKEY_START_OFFSET 0x2C
207 #define DEVKEY_START_BIT    0x07
208
209 #define JTAG_START_OFFSET 0x0
210 #define JTAG_START_BIT    0x3
211
212 #define ODM_PROD_START_OFFSET 0x0
213 #define ODM_PROD_START_BIT    0x4
214
215 #define SB_DEVCFG_START_OFFSET 0x2E
216 #define SB_DEVCFG_START_BIT    0x07
217
218 #define SB_DEVSEL_START_OFFSET 0x2E
219 #define SB_DEVSEL_START_BIT    0x23
220
221 #define SBK_START_OFFSET 0x24
222 #define SBK_START_BIT    0x07
223
224 #define SW_RESERVED_START_OFFSET 0x2E
225 #define SW_RESERVED_START_BIT    0x07
226
227 #define IGNORE_DEVSEL_START_OFFSET 0x2E
228 #define IGNORE_DEVSEL_START_BIT    0x26
229
230 #define ODM_RESERVED_DEVSEL_START_OFFSET 0X30
231 #define ODM_RESERVED_START_BIT    0X0
232
233 #endif
234
235 static struct param_info fuse_info_tbl[] = {
236         [DEVKEY] = {
237                 .addr = &fuse_info.devkey,
238                 .sz = sizeof(fuse_info.devkey),
239                 .start_off = DEVKEY_START_OFFSET,
240                 .start_bit = DEVKEY_START_BIT,
241                 .nbits = 32,
242                 .data_offset = 0,
243                 .sysfs_name = "device_key",
244         },
245         [JTAG_DIS] = {
246                 .addr = &fuse_info.jtag_dis,
247                 .sz = sizeof(fuse_info.jtag_dis),
248                 .start_off = JTAG_START_OFFSET,
249                 .start_bit = JTAG_START_BIT,
250                 .nbits = 1,
251                 .data_offset = 1,
252                 .sysfs_name = "jtag_disable",
253         },
254         [ODM_PROD_MODE] = {
255                 .addr = &fuse_info.odm_prod_mode,
256                 .sz = sizeof(fuse_info.odm_prod_mode),
257                 .start_off = ODM_PROD_START_OFFSET,
258                 .start_bit = ODM_PROD_START_BIT,
259                 .nbits = 1,
260                 .data_offset = 2,
261                 .sysfs_name = "odm_production_mode",
262         },
263         [SEC_BOOT_DEV_CFG] = {
264                 .addr = &fuse_info.bootdev_cfg,
265                 .sz = sizeof(fuse_info.bootdev_cfg),
266                 .start_off = SB_DEVCFG_START_OFFSET,
267                 .start_bit = SB_DEVCFG_START_BIT,
268                 .nbits = 16,
269                 .data_offset = 3,
270                 .sysfs_name = "sec_boot_dev_cfg",
271         },
272         [SEC_BOOT_DEV_SEL] = {
273                 .addr = &fuse_info.bootdev_sel,
274                 .sz = sizeof(fuse_info.bootdev_sel),
275                 .start_off = SB_DEVSEL_START_OFFSET,
276                 .start_bit = SB_DEVSEL_START_BIT,
277                 .nbits = 3,
278                 .data_offset = 4,
279                 .sysfs_name = "sec_boot_dev_sel",
280         },
281         [SBK] = {
282                 .addr = fuse_info.sbk,
283                 .sz = sizeof(fuse_info.sbk),
284                 .start_off = SBK_START_OFFSET,
285                 .start_bit = SBK_START_BIT,
286                 .nbits = 128,
287                 .data_offset = 5,
288                 .sysfs_name = "secure_boot_key",
289         },
290         [SW_RSVD] = {
291                 .addr = &fuse_info.sw_rsvd,
292                 .sz = sizeof(fuse_info.sw_rsvd),
293                 .start_off = SW_RESERVED_START_OFFSET,
294                 .start_bit = SW_RESERVED_START_BIT,
295                 .nbits = 4,
296                 .data_offset = 9,
297                 .sysfs_name = "sw_reserved",
298         },
299         [IGNORE_DEV_SEL_STRAPS] = {
300                 .addr = &fuse_info.ignore_devsel_straps,
301                 .sz = sizeof(fuse_info.ignore_devsel_straps),
302                 .start_off = IGNORE_DEVSEL_START_OFFSET,
303                 .start_bit = IGNORE_DEVSEL_START_BIT,
304                 .nbits = 1,
305                 .data_offset = 10,
306                 .sysfs_name = "ignore_dev_sel_straps",
307         },
308         [ODM_RSVD] = {
309                 .addr = fuse_info.odm_rsvd,
310                 .sz = sizeof(fuse_info.odm_rsvd),
311                 .start_off = ODM_RESERVED_DEVSEL_START_OFFSET,
312                 .start_bit = ODM_RESERVED_START_BIT,
313                 .nbits = 256,
314                 .data_offset = 11,
315                 .sysfs_name = "odm_reserved",
316         },
317         [SBK_DEVKEY_STATUS] = {
318                 .sz = SBK_DEVKEY_STATUS_SZ,
319         },
320 };
321
322 static void wait_for_idle(void)
323 {
324         u32 reg;
325
326         do {
327                 udelay(1);
328                 reg = tegra_fuse_readl(FUSE_CTRL);
329         } while ((reg & (0xF << 16)) != STATE_IDLE);
330 }
331
332 #define FUSE_READ       0x1
333 #define FUSE_WRITE      0x2
334 #define FUSE_SENSE      0x3
335 #define FUSE_CMD_MASK   0x3
336
337 static u32 fuse_cmd_read(u32 addr)
338 {
339         u32 reg;
340
341         wait_for_idle();
342         tegra_fuse_writel(addr, FUSE_REG_ADDR);
343         reg = tegra_fuse_readl(FUSE_CTRL);
344         reg &= ~FUSE_CMD_MASK;
345         reg |= FUSE_READ;
346         tegra_fuse_writel(reg, FUSE_CTRL);
347         wait_for_idle();
348
349         reg = tegra_fuse_readl(FUSE_REG_READ);
350         return reg;
351 }
352
353 static void fuse_cmd_write(u32 value, u32 addr)
354 {
355         u32 reg;
356
357         wait_for_idle();
358         tegra_fuse_writel(addr, FUSE_REG_ADDR);
359         tegra_fuse_writel(value, FUSE_REG_WRITE);
360
361         reg = tegra_fuse_readl(FUSE_CTRL);
362         reg &= ~FUSE_CMD_MASK;
363         reg |= FUSE_WRITE;
364         tegra_fuse_writel(reg, FUSE_CTRL);
365         wait_for_idle();
366 }
367
368 static void fuse_cmd_sense(void)
369 {
370         u32 reg;
371
372         wait_for_idle();
373         reg = tegra_fuse_readl(FUSE_CTRL);
374         reg &= ~FUSE_CMD_MASK;
375         reg |= FUSE_SENSE;
376         tegra_fuse_writel(reg, FUSE_CTRL);
377         wait_for_idle();
378 }
379
380 static void get_fuse(enum fuse_io_param io_param, u32 *out)
381 {
382         int start_bit = fuse_info_tbl[io_param].start_bit;
383         int nbits = fuse_info_tbl[io_param].nbits;
384         int offset = fuse_info_tbl[io_param].start_off;
385         u32 *dst = fuse_info_tbl[io_param].addr;
386         int dst_bit = 0;
387         int i;
388         u32 val;
389         int loops;
390
391         if (out)
392                 dst = out;
393
394         do {
395                 val = fuse_cmd_read(offset);
396                 loops = min(nbits, 32 - start_bit);
397                 for (i = 0; i < loops; i++) {
398                         if (val & (BIT(start_bit + i)))
399                                 *dst |= BIT(dst_bit);
400                         else
401                                 *dst &= ~BIT(dst_bit);
402                         dst_bit++;
403                         if (dst_bit == 32) {
404                                 dst++;
405                                 dst_bit = 0;
406                         }
407                 }
408                 nbits -= loops;
409                 offset += 2;
410                 start_bit = 0;
411         } while (nbits > 0);
412 }
413
414 int tegra_fuse_read(enum fuse_io_param io_param, u32 *data, int size)
415 {
416         int nbits;
417         u32 sbk[4], devkey = 0;
418
419         if (IS_ERR_OR_NULL(clk_fuse)) {
420                 pr_err("fuse read disabled");
421                 return -ENODEV;
422         }
423
424         if (!data)
425                 return -EINVAL;
426
427         if (size != fuse_info_tbl[io_param].sz) {
428                 pr_err("%s: size mismatch(%d), %d vs %d\n", __func__,
429                         (int)io_param, size, fuse_info_tbl[io_param].sz);
430                 return -EINVAL;
431         }
432
433         mutex_lock(&fuse_lock);
434
435         clk_enable(clk_fuse);
436         fuse_cmd_sense();
437
438         if (io_param == SBK_DEVKEY_STATUS) {
439                 *data = 0;
440
441                 get_fuse(SBK, sbk);
442                 get_fuse(DEVKEY, &devkey);
443                 nbits = sizeof(sbk) * BITS_PER_BYTE;
444                 if (find_first_bit((unsigned long *)sbk, nbits) != nbits)
445                         *data = 1;
446                 else if (devkey)
447                         *data = 1;
448         } else {
449                 get_fuse(io_param, data);
450         }
451
452         clk_disable(clk_fuse);
453         mutex_unlock(&fuse_lock);
454
455         return 0;
456 }
457
458 static bool fuse_odm_prod_mode(void)
459 {
460         u32 odm_prod_mode = 0;
461
462         clk_enable(clk_fuse);
463         get_fuse(ODM_PROD_MODE, &odm_prod_mode);
464         clk_disable(clk_fuse);
465         return (odm_prod_mode ? true : false);
466 }
467
468 static void set_fuse(enum fuse_io_param io_param, u32 *data)
469 {
470         int i, start_bit = fuse_info_tbl[io_param].start_bit;
471         int nbits = fuse_info_tbl[io_param].nbits, loops;
472         int offset = fuse_info_tbl[io_param].start_off >> 1;
473         int src_bit = 0;
474         u32 val;
475
476         do {
477                 val = *data;
478                 loops = min(nbits, 32 - start_bit);
479                 for (i = 0; i < loops; i++) {
480                         fuse_pgm_mask[offset] |= BIT(start_bit + i);
481                         if (val & BIT(src_bit))
482                                 fuse_pgm_data[offset] |= BIT(start_bit + i);
483                         else
484                                 fuse_pgm_data[offset] &= ~BIT(start_bit + i);
485                         src_bit++;
486                         if (src_bit == 32) {
487                                 data++;
488                                 val = *data;
489                                 src_bit = 0;
490                         }
491                 }
492                 nbits -= loops;
493                 offset++;
494                 start_bit = 0;
495         } while (nbits > 0);
496 }
497
498 static void populate_fuse_arrs(struct fuse_data *info, u32 flags)
499 {
500         u32 *src = (u32 *)info;
501         int i;
502
503         memset(fuse_pgm_data, 0, sizeof(fuse_pgm_data));
504         memset(fuse_pgm_mask, 0, sizeof(fuse_pgm_mask));
505
506         if ((flags & FLAGS_ODMRSVD)) {
507                 set_fuse(ODM_RSVD, info->odm_rsvd);
508                 flags &= ~FLAGS_ODMRSVD;
509         }
510
511         /* do not burn any more if secure mode is set */
512         if (fuse_odm_prod_mode())
513                 goto out;
514
515         for_each_set_bit(i, (unsigned long *)&flags, MAX_PARAMS)
516                 set_fuse(i, src + fuse_info_tbl[i].data_offset);
517
518 out:
519         pr_debug("ready to program");
520 }
521
522 static void fuse_power_enable(void)
523 {
524 #if ENABLE_FUSE_BURNING
525         tegra_fuse_writel(0x1, FUSE_PWR_GOOD_SW);
526         udelay(1);
527 #endif
528 }
529
530 static void fuse_power_disable(void)
531 {
532 #if ENABLE_FUSE_BURNING
533         tegra_fuse_writel(0, FUSE_PWR_GOOD_SW);
534         udelay(1);
535 #endif
536 }
537
538 static void fuse_program_array(int pgm_cycles)
539 {
540         u32 reg, fuse_val[2];
541         u32 *data = tmp_fuse_pgm_data, addr = 0, *mask = fuse_pgm_mask;
542         int i = 0;
543
544         fuse_cmd_sense();
545
546         /* get the first 2 fuse bytes */
547         fuse_val[0] = fuse_cmd_read(0);
548         fuse_val[1] = fuse_cmd_read(1);
549
550         fuse_power_enable();
551
552         /*
553          * The fuse macro is a high density macro. Fuses are
554          * burned using an addressing mechanism, so no need to prepare
555          * the full list, but more write to control registers are needed.
556          * The only bit that can be written at first is bit 0, a special write
557          * protection bit by assumptions all other bits are at 0
558          *
559          * The programming pulse must have a precise width of
560          * [9000, 11000] ns.
561          */
562         if (pgm_cycles > 0) {
563                 reg = pgm_cycles;
564                 tegra_fuse_writel(reg, FUSE_TIME_PGM);
565         }
566         fuse_val[0] = (0x1 & ~fuse_val[0]);
567         fuse_val[1] = (0x1 & ~fuse_val[1]);
568         fuse_cmd_write(fuse_val[0], 0);
569         fuse_cmd_write(fuse_val[1], 1);
570
571         fuse_power_disable();
572
573         /*
574          * this will allow programming of other fuses
575          * and the reading of the existing fuse values
576          */
577         fuse_cmd_sense();
578
579         /* Clear out all bits that have already been burned or masked out */
580         memcpy(data, fuse_pgm_data, sizeof(fuse_pgm_data));
581
582         for (addr = 0; addr < NFUSES; addr += 2, data++, mask++) {
583                 reg = fuse_cmd_read(addr);
584                 pr_debug("%d: 0x%x 0x%x 0x%x\n", addr, (u32)(*data),
585                         ~reg, (u32)(*mask));
586                 *data = (*data & ~reg) & *mask;
587         }
588
589         fuse_power_enable();
590
591         /*
592          * Finally loop on all fuses, program the non zero ones.
593          * Words 0 and 1 are written last and they contain control fuses. We
594          * need to invalidate after writing to a control word (with the exception
595          * of the master enable). This is also the reason we write them last.
596          */
597         for (i = ARRAY_SIZE(fuse_pgm_data) - 1; i >= 0; i--) {
598                 if (tmp_fuse_pgm_data[i]) {
599                         fuse_cmd_write(tmp_fuse_pgm_data[i], i * 2);
600                         fuse_cmd_write(tmp_fuse_pgm_data[i], (i * 2) + 1);
601                 }
602
603                 if (i < 2) {
604                         wait_for_idle();
605                         fuse_power_disable();
606                         fuse_cmd_sense();
607                         fuse_power_enable();
608                 }
609         }
610
611         fuse_power_disable();
612
613         /*
614          * Wait until done (polling)
615          * this one needs to use fuse_sense done, the FSM follows a periodic
616          * sequence that includes idle
617          */
618         do {
619                 udelay(1);
620                 reg = tegra_fuse_readl(FUSE_CTRL);
621         } while ((reg & (0x1 << 30)) != SENSE_DONE);
622
623 }
624
625 static int fuse_set(enum fuse_io_param io_param, u32 *param, int size)
626 {
627         int i, nwords = size / sizeof(u32);
628         u32 *data;
629
630         if (io_param > MAX_PARAMS)
631                 return -EINVAL;
632
633         data = (u32*)kzalloc(size, GFP_KERNEL);
634         if (!data) {
635                 pr_err("failed to alloc %d bytes\n", size);
636                 return -ENOMEM;
637         }
638
639         get_fuse(io_param, data);
640
641         /* set only new fuse bits */
642         for (i = 0; i < nwords; i++) {
643                 param[i] = (~data[i] & param[i]);
644         }
645
646         kfree(data);
647         return 0;
648 }
649
650 /*
651  * Function pointer to optional board specific function
652  */
653 int (*tegra_fuse_regulator_en)(int);
654 EXPORT_SYMBOL(tegra_fuse_regulator_en);
655
656 #define CAR_OSC_CTRL            0x50
657 #define PMC_PLLP_OVERRIDE       0xF8
658 #define PMC_OSC_OVERRIDE        BIT(0)
659 #define PMC_OSC_FREQ_MASK       (BIT(2) | BIT(3))
660 #define PMC_OSC_FREQ_SHIFT      2
661 #define CAR_OSC_FREQ_SHIFT      30
662
663 #define FUSE_SENSE_DONE_BIT     BIT(30)
664 #define START_DATA              BIT(0)
665 #define SKIP_RAMREPAIR          BIT(1)
666 #define FUSE_PGM_TIMEOUT_MS     50
667
668 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
669 /* cycles corresponding to 13MHz, 19.2MHz, 12MHz, 26MHz */
670 static int fuse_pgm_cycles[] = {130, 192, 120, 260};
671 #else
672 /* cycles corresponding to 13MHz, 16.8MHz, 19.2MHz, 38.4MHz, 12MHz, 48MHz, 26MHz */
673 static int fuse_pgm_cycles[] = {130, 168, 0, 0, 192, 384, 0, 0, 120, 480, 0, 0, 260};
674 #endif
675
676 int tegra_fuse_program(struct fuse_data *pgm_data, u32 flags)
677 {
678         u32 reg;
679         int i = 0;
680         int index;
681         int ret;
682         int delay = FUSE_PGM_TIMEOUT_MS;
683
684         if (!pgm_data || !flags) {
685                 pr_err("invalid parameter");
686                 return -EINVAL;
687         }
688
689         if (IS_ERR_OR_NULL(clk_fuse) ||
690            (!tegra_fuse_regulator_en && IS_ERR_OR_NULL(vdd_fuse))) {
691                 pr_err("fuse write disabled");
692                 return -ENODEV;
693         }
694
695         if (fuse_odm_prod_mode() && (flags != FLAGS_ODMRSVD)) {
696                 pr_err("reserved odm fuses aren't allowed in secure mode");
697                 return -EPERM;
698         }
699
700         if ((flags & FLAGS_ODM_PROD_MODE) &&
701                 (flags & (FLAGS_SBK | FLAGS_DEVKEY))) {
702                 pr_err("odm production mode and sbk/devkey not allowed");
703                 return -EPERM;
704         }
705
706         clk_enable(clk_fuse);
707
708         /* check that fuse options write access hasn't been disabled */
709         mutex_lock(&fuse_lock);
710         reg = tegra_fuse_readl(FUSE_DIS_PGM);
711         mutex_unlock(&fuse_lock);
712         if (reg) {
713                 pr_err("fuse programming disabled");
714                 clk_disable(clk_fuse);
715                 return -EACCES;
716         }
717
718         /* enable software writes to the fuse registers */
719         tegra_fuse_writel(0, FUSE_WRITE_ACCESS);
720
721         mutex_lock(&fuse_lock);
722         memcpy(&fuse_info, pgm_data, sizeof(fuse_info));
723         for_each_set_bit(i, (unsigned long *)&flags, MAX_PARAMS) {
724                 fuse_set((u32)i, fuse_info_tbl[i].addr,
725                         fuse_info_tbl[i].sz);
726         }
727
728 #if ENABLE_FUSE_BURNING
729         if (tegra_fuse_regulator_en)
730                 ret = tegra_fuse_regulator_en(1);
731         else
732                 ret = regulator_enable(vdd_fuse);
733
734         if (ret)
735                 BUG_ON("regulator enable fail\n");
736
737         populate_fuse_arrs(&fuse_info, flags);
738
739         /* calculate the number of program cycles from the oscillator freq */
740         reg = readl(IO_ADDRESS(TEGRA_PMC_BASE) + PMC_PLLP_OVERRIDE);
741         if (reg & PMC_OSC_OVERRIDE) {
742                 index = (reg & PMC_OSC_FREQ_MASK) >> PMC_OSC_FREQ_SHIFT;
743         } else {
744                 reg = readl(IO_ADDRESS(TEGRA_CLK_RESET_BASE) + CAR_OSC_CTRL);
745                 index = reg >> CAR_OSC_FREQ_SHIFT;
746         }
747
748         pr_debug("%s: use %d programming cycles\n", __func__, fuse_pgm_cycles[index]);
749         fuse_program_array(fuse_pgm_cycles[index]);
750
751         memset(&fuse_info, 0, sizeof(fuse_info));
752
753         if (tegra_fuse_regulator_en)
754                 tegra_fuse_regulator_en(0);
755         else
756                 regulator_disable(vdd_fuse);
757 #endif
758
759         mutex_unlock(&fuse_lock);
760
761         /* disable software writes to the fuse registers */
762         tegra_fuse_writel(1, FUSE_WRITE_ACCESS);
763
764         /* apply the fuse values immediately instead of resetting the chip */
765         fuse_cmd_sense();
766
767         tegra_fuse_writel(START_DATA | SKIP_RAMREPAIR, FUSE_PRIV2INTFC);
768
769         /* check sense and shift done in addition to IDLE */
770         do {
771                 mdelay(1);
772                 reg = tegra_fuse_readl(FUSE_CTRL);
773                 reg &= (FUSE_SENSE_DONE_BIT | STATE_IDLE);
774         } while ((reg != (FUSE_SENSE_DONE_BIT | STATE_IDLE)) && (--delay > 0));
775
776         clk_disable(clk_fuse);
777
778         return ((delay > 0) ? 0 : -ETIMEDOUT);
779 }
780
781 static int fuse_name_to_param(const char *str)
782 {
783         int i;
784
785         for (i = DEVKEY; i < ARRAY_SIZE(fuse_info_tbl); i++) {
786                 if (!strcmp(str, fuse_info_tbl[i].sysfs_name))
787                         return i;
788         }
789
790         return -ENODATA;
791 }
792
793 static int char_to_xdigit(char c)
794 {
795         return (c>='0' && c<='9') ? c - '0' :
796                 (c>='a' && c<='f') ? c - 'a' + 10 :
797                 (c>='A' && c<='F') ? c - 'A' + 10 : -1;
798 }
799
800 #define CHK_ERR(x) \
801 { \
802         if (x) \
803         { \
804                 pr_err("%s: sysfs_create_file fail(%d)!", __func__, x); \
805                 return x; \
806         } \
807 }
808
809 static ssize_t fuse_store(struct kobject *kobj, struct kobj_attribute *attr,
810         const char *buf, size_t count)
811 {
812         enum fuse_io_param param = fuse_name_to_param(attr->attr.name);
813         int ret, i = 0;
814         int orig_count = count;
815         struct fuse_data data = {0};
816         u32 *raw_data = ((u32 *)&data) + fuse_info_tbl[param].data_offset;
817         u8 *raw_byte_data = (u8 *)raw_data;
818         struct wake_lock fuse_wk_lock;
819
820         if ((param == -1) || (param == -ENODATA)) {
821                 pr_err("%s: invalid fuse\n", __func__);
822                 return -EINVAL;
823         }
824
825         if (fuse_odm_prod_mode()) {
826                 pr_err("%s: device locked. odm fuse already blown\n", __func__);
827                 return -EPERM;
828         }
829
830         count--;
831         if (DIV_ROUND_UP(count, 2) > fuse_info_tbl[param].sz) {
832                 pr_err("%s: fuse parameter too long, should be %d character(s)\n",
833                         __func__, fuse_info_tbl[param].sz * 2);
834                 return -EINVAL;
835         }
836
837         /* see if the string has 0x/x at the start */
838         if (*buf == 'x') {
839                 count -= 1;
840                 buf++;
841         } else if (*(buf + 1) == 'x') {
842                 count -= 2;
843                 buf += 2;
844         }
845
846         /* wakelock to avoid device powering down while programming */
847         wake_lock_init(&fuse_wk_lock, WAKE_LOCK_SUSPEND, "fuse_wk_lock");
848         wake_lock(&fuse_wk_lock);
849
850         /* we need to fit each character into a single nibble */
851         raw_byte_data += DIV_ROUND_UP(count, 2) - 1;
852
853         /* in case of odd number of writes, write the first one here */
854         if (count & BIT(0)) {
855                 *raw_byte_data = char_to_xdigit(*buf);
856                 buf++;
857                 raw_byte_data--;
858                 count--;
859         }
860
861         for (i = 1; i <= count; i++, buf++) {
862                 if (i & BIT(0)) {
863                         *raw_byte_data = char_to_xdigit(*buf);
864                 } else {
865                         *raw_byte_data <<= 4;
866                         *raw_byte_data |= char_to_xdigit(*buf);
867                         raw_byte_data--;
868                 }
869         }
870
871         ret = tegra_fuse_program(&data, BIT(param));
872         if (ret) {
873                 pr_err("%s: fuse program fail(%d)\n", __func__, ret);
874                 orig_count = ret;
875                 goto done;
876         }
877
878         /* if odm prodn mode fuse is burnt, change file permissions to 0440 */
879         if (param == ODM_PROD_MODE) {
880                 CHK_ERR(sysfs_chmod_file(kobj, &attr->attr, 0440));
881                 CHK_ERR(sysfs_chmod_file(kobj, &devkey_attr.attr, 0440));
882                 CHK_ERR(sysfs_chmod_file(kobj, &jtagdis_attr.attr, 0440));
883                 CHK_ERR(sysfs_chmod_file(kobj, &sec_boot_dev_cfg_attr.attr, 0440));
884                 CHK_ERR(sysfs_chmod_file(kobj, &sec_boot_dev_sel_attr.attr, 0440));
885                 CHK_ERR(sysfs_chmod_file(kobj, &sbk_attr.attr, 0440));
886                 CHK_ERR(sysfs_chmod_file(kobj, &sw_rsvd_attr.attr, 0440));
887                 CHK_ERR(sysfs_chmod_file(kobj, &ignore_dev_sel_straps_attr.attr, 0440));
888                 CHK_ERR(sysfs_chmod_file(kobj, &odm_rsvd_attr.attr, 0440));
889         }
890
891 done:
892         wake_unlock(&fuse_wk_lock);
893         wake_lock_destroy(&fuse_wk_lock);
894         return orig_count;
895 }
896
897 static ssize_t fuse_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
898 {
899         enum fuse_io_param param = fuse_name_to_param(attr->attr.name);
900         u32 data[8];
901         char str[9]; /* extra byte for null character */
902         int ret, i;
903
904         if ((param == -1) || (param == -ENODATA)) {
905                 pr_err("%s: invalid fuse\n", __func__);
906                 return -EINVAL;
907         }
908
909         if ((param == SBK) && fuse_odm_prod_mode()) {
910                 pr_err("device locked. sbk read not allowed\n");
911                 return 0;
912         }
913
914         memset(data, 0, sizeof(data));
915         ret = tegra_fuse_read(param, data, fuse_info_tbl[param].sz);
916         if (ret) {
917                 pr_err("%s: read fail(%d)\n", __func__, ret);
918                 return ret;
919         }
920
921         strcpy(buf, "0x");
922         for (i = (fuse_info_tbl[param].sz/sizeof(u32)) - 1; i >= 0 ; i--) {
923                 sprintf(str, "%08x", data[i]);
924                 strcat(buf, str);
925         }
926
927         strcat(buf, "\n");
928         return strlen(buf);
929 }
930
931 static int __init tegra_fuse_program_init(void)
932 {
933         if (!tegra_fuse_regulator_en) {
934                 /* get vdd_fuse regulator */
935                 vdd_fuse = regulator_get(NULL, "vdd_fuse");
936                 if (IS_ERR_OR_NULL(vdd_fuse))
937                         pr_err("%s: no vdd_fuse. fuse write disabled\n", __func__);
938         }
939
940         clk_fuse = clk_get_sys("fuse-tegra", "fuse_burn");
941         if (IS_ERR_OR_NULL(clk_fuse)) {
942                 pr_err("%s: no clk_fuse. fuse read/write disabled\n", __func__);
943                 if (!IS_ERR_OR_NULL(vdd_fuse)) {
944                         regulator_put(vdd_fuse);
945                         vdd_fuse = NULL;
946                 }
947                 return -ENODEV;
948         }
949
950         fuse_kobj = kobject_create_and_add("fuse", firmware_kobj);
951         if (!fuse_kobj) {
952                 pr_err("%s: fuse_kobj create fail\n", __func__);
953                 regulator_put(vdd_fuse);
954                 clk_put(clk_fuse);
955                 return -ENODEV;
956         }
957
958         mutex_init(&fuse_lock);
959
960         /* change fuse file permissions, if ODM production fuse is not blown */
961         if (!fuse_odm_prod_mode())
962         {
963                 devkey_attr.attr.mode = 0640;
964                 jtagdis_attr.attr.mode = 0640;
965                 sec_boot_dev_cfg_attr.attr.mode = 0640;
966                 sec_boot_dev_sel_attr.attr.mode = 0640;
967                 sbk_attr.attr.mode = 0640;
968                 sw_rsvd_attr.attr.mode = 0640;
969                 ignore_dev_sel_straps_attr.attr.mode = 0640;
970                 odm_rsvd_attr.attr.mode = 0640;
971                 odm_prod_mode_attr.attr.mode = 0644;
972         }
973
974         CHK_ERR(sysfs_create_file(fuse_kobj, &odm_prod_mode_attr.attr));
975         CHK_ERR(sysfs_create_file(fuse_kobj, &devkey_attr.attr));
976         CHK_ERR(sysfs_create_file(fuse_kobj, &jtagdis_attr.attr));
977         CHK_ERR(sysfs_create_file(fuse_kobj, &sec_boot_dev_cfg_attr.attr));
978         CHK_ERR(sysfs_create_file(fuse_kobj, &sec_boot_dev_sel_attr.attr));
979         CHK_ERR(sysfs_create_file(fuse_kobj, &sbk_attr.attr));
980         CHK_ERR(sysfs_create_file(fuse_kobj, &sw_rsvd_attr.attr));
981         CHK_ERR(sysfs_create_file(fuse_kobj, &ignore_dev_sel_straps_attr.attr));
982         CHK_ERR(sysfs_create_file(fuse_kobj, &odm_rsvd_attr.attr));
983
984         return 0;
985 }
986
987 static void __exit tegra_fuse_program_exit(void)
988 {
989
990         fuse_power_disable();
991
992         if (!IS_ERR_OR_NULL(vdd_fuse))
993                 regulator_put(vdd_fuse);
994
995         if (!IS_ERR_OR_NULL(clk_fuse))
996                 clk_put(clk_fuse);
997
998         sysfs_remove_file(fuse_kobj, &odm_prod_mode_attr.attr);
999         sysfs_remove_file(fuse_kobj, &devkey_attr.attr);
1000         sysfs_remove_file(fuse_kobj, &jtagdis_attr.attr);
1001         sysfs_remove_file(fuse_kobj, &sec_boot_dev_cfg_attr.attr);
1002         sysfs_remove_file(fuse_kobj, &sec_boot_dev_sel_attr.attr);
1003         sysfs_remove_file(fuse_kobj, &sbk_attr.attr);
1004         sysfs_remove_file(fuse_kobj, &sw_rsvd_attr.attr);
1005         sysfs_remove_file(fuse_kobj, &ignore_dev_sel_straps_attr.attr);
1006         sysfs_remove_file(fuse_kobj, &odm_rsvd_attr.attr);
1007         kobject_del(fuse_kobj);
1008 }
1009
1010 late_initcall(tegra_fuse_program_init);
1011 module_exit(tegra_fuse_program_exit);