/* * cmd_otp.c - interface to Blackfin on-chip One-Time-Programmable memory * * Copyright (c) 2007-2008 Analog Devices Inc. * * Licensed under the GPL-2 or later. */ /* There are 512 128-bit "pages" (0x000 through 0x1FF). * The pages are accessable as 64-bit "halfpages" (an upper and lower half). * The pages are not part of the memory map. There is an OTP controller which * handles scanning in/out of bits. While access is done through OTP MMRs, * the bootrom provides C-callable helper functions to handle the interaction. */ #include <config.h> #include <common.h> #include <command.h> #include <console.h> #include <asm/blackfin.h> #include <asm/clock.h> #include <asm/mach-common/bits/otp.h> static const char *otp_strerror(uint32_t err) { switch (err) { case 0: return "no error"; case OTP_WRITE_ERROR: return "OTP fuse write error"; case OTP_READ_ERROR: return "OTP fuse read error"; case OTP_ACC_VIO_ERROR: return "invalid OTP address"; case OTP_DATA_MULT_ERROR: return "multiple bad bits detected"; case OTP_ECC_MULT_ERROR: return "error in ECC bits"; case OTP_PREV_WR_ERROR: return "space already written"; case OTP_DATA_SB_WARN: return "single bad bit in half page"; case OTP_ECC_SB_WARN: return "single bad bit in ECC"; default: return "unknown error"; } } #define lowup(x) ((x) % 2 ? "upper" : "lower") static int check_voltage(void) { /* Make sure voltage limits are within datasheet spec */ uint16_t vr_ctl = bfin_read_VR_CTL(); #ifdef __ADSPBF54x__ /* 0.9V <= VDDINT <= 1.1V */ if ((vr_ctl & 0xc) && (vr_ctl & 0xc0) == 0xc0) return 1; #else /* for the parts w/out qualification yet */ (void)vr_ctl; #endif return 0; } static void set_otp_timing(bool write) { static uint32_t timing; if (!timing) { uint32_t tp1, tp2, tp3; /* OTP_TP1 = 1000 / sclk_period (in nanoseconds) * OTP_TP1 = 1000 / (1 / get_sclk() * 10^9) * OTP_TP1 = (1000 * get_sclk()) / 10^9 * OTP_TP1 = get_sclk() / 10^6 */ tp1 = get_sclk() / 1000000; /* OTP_TP2 = 400 / (2 * sclk_period) * OTP_TP2 = 400 / (2 * 1 / get_sclk() * 10^9) * OTP_TP2 = (400 * get_sclk()) / (2 * 10^9) * OTP_TP2 = (2 * get_sclk()) / 10^7 */ tp2 = (2 * get_sclk() / 10000000) << 8; /* OTP_TP3 = magic constant */ tp3 = (0x1401) << 15; timing = tp1 | tp2 | tp3; } bfrom_OtpCommand(OTP_INIT, write ? timing : timing & ~(-1 << 15)); } int do_otp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *cmd; uint32_t ret, base_flags; bool prompt_user, force_read; uint32_t (*otp_func)(uint32_t page, uint32_t flags, uint64_t *page_content); if (argc < 4) { usage: return CMD_RET_USAGE; } prompt_user = false; base_flags = 0; cmd = argv[1]; if (!strcmp(cmd, "read")) otp_func = bfrom_OtpRead; else if (!strcmp(cmd, "dump")) { otp_func = bfrom_OtpRead; force_read = true; } else if (!strcmp(cmd, "write")) { otp_func = bfrom_OtpWrite; base_flags = OTP_CHECK_FOR_PREV_WRITE; if (!strcmp(argv[2], "--force")) { argv++; --argc; } else prompt_user = false; } else if (!strcmp(cmd, "lock")) { if (argc != 4) goto usage; otp_func = bfrom_OtpWrite; base_flags = OTP_LOCK; } else goto usage; uint64_t *addr = (uint64_t *)simple_strtoul(argv[2], NULL, 16); uint32_t page = simple_strtoul(argv[3], NULL, 16); uint32_t flags; size_t i, count; ulong half; if (argc > 4) count = simple_strtoul(argv[4], NULL, 16); else count = 2; if (argc > 5) { half = simple_strtoul(argv[5], NULL, 16); if (half != 0 && half != 1) { puts("Error: 'half' can only be '0' or '1'\n"); goto usage; } } else half = 0; /* "otp lock" has slightly different semantics */ if (base_flags & OTP_LOCK) { count = page; page = (uint32_t)addr; addr = NULL; } /* do to the nature of OTP, make sure users are sure */ if (prompt_user) { printf( "Writing one time programmable memory\n" "Make sure your operating voltages and temperature are within spec\n" " source address: 0x%p\n" " OTP destination: %s page 0x%03X - %s page 0x%03lX\n" " number to write: %lu halfpages\n" " type \"YES\" (no quotes) to confirm: ", addr, lowup(half), page, lowup(half + count - 1), page + (half + count - 1) / 2, half + count ); if (!confirm_yesno()) { printf(" Aborting\n"); return 1; } } printf("OTP memory %s: addr 0x%p page 0x%03X count %zu ... ", cmd, addr, page, count); set_otp_timing(otp_func == bfrom_OtpWrite); if (otp_func == bfrom_OtpWrite && check_voltage()) { puts("ERROR: VDDINT voltage is out of spec for writing\n"); return -1; } /* Do the actual reading/writing stuff */ ret = 0; for (i = half; i < count + half; ++i) { flags = base_flags | (i % 2 ? OTP_UPPER_HALF : OTP_LOWER_HALF); try_again: ret = otp_func(page, flags, addr); if (ret & OTP_MASTER_ERROR) { if (force_read) { if (flags & OTP_NO_ECC) break; else flags |= OTP_NO_ECC; puts("E"); goto try_again; } else break; } else if (ret) puts("W"); else puts("."); if (!(base_flags & OTP_LOCK)) { ++addr; if (i % 2) ++page; } else ++page; } if (ret & 0x1) printf("\nERROR at page 0x%03X (%s-halfpage): 0x%03X: %s\n", page, lowup(i), ret, otp_strerror(ret)); else puts(" done\n"); /* Make sure we disable writing */ set_otp_timing(false); bfrom_OtpCommand(OTP_CLOSE, 0); return ret; } U_BOOT_CMD( otp, 7, 0, do_otp, "One-Time-Programmable sub-system", "read <addr> <page> [count] [half]\n" " - read 'count' half-pages starting at 'page' (offset 'half') to 'addr'\n" "otp dump <addr> <page> [count] [half]\n" " - like 'otp read', but skip read errors\n" "otp write [--force] <addr> <page> [count] [half]\n" " - write 'count' half-pages starting at 'page' (offset 'half') from 'addr'\n" "otp lock <page> <count>\n" " - lock 'count' pages starting at 'page'" );