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