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