/* * 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 to 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>#ifdef CONFIG_CMD_OTP#include <asm/blackfin.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")int do_otp(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]){	bool force = false;	if (!strcmp(argv[1], "--force")) {		force = true;		argv[1] = argv[0];		argv++;		--argc;	}	uint32_t (*otp_func)(uint32_t page, uint32_t flags, uint64_t *page_content);	if (!strcmp(argv[1], "read"))		otp_func = otp_read;	else if (!strcmp(argv[1], "write"))		otp_func = otp_write;	else { usage:		printf("Usage:\n%s\n", cmdtp->usage);		return 1;	}	uint64_t *addr = (uint64_t *)simple_strtoul(argv[2], NULL, 16);	uint32_t page = simple_strtoul(argv[3], NULL, 16);	uint32_t flags, ret;	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;	/* do to the nature of OTP, make sure users are sure */	if (!force && otp_func == otp_write) {		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%03X\n"			"   number to write: %ld halfpages\n"			" type \"YES\" (no quotes) to confirm: ",			addr,			lowup(half), page,			lowup(half + count - 1), page + (half + count - 1) / 2,			half + count		);		i = 0;		while (1) {			if (tstc()) {				const char exp_ans[] = "YES\r";				char c;				putc(c = getc());				if (exp_ans[i++] != c) {					printf(" Aborting\n");					return 1;				} else if (!exp_ans[i]) {					puts("\n");					break;				}			}		}		/* Only supported in newer silicon ... enable writing */#if (0)		otp_command(OTP_INIT, ...);#else		*pOTP_TIMING = 0x32149485;#endif	}	printf("OTP memory %s: addr 0x%08lx  page 0x%03X  count %ld ... ",		argv[1], addr, page, count);	ret = 0;	for (i = half; i < count + half; ++i) {		flags = (i % 2) ? OTP_UPPER_HALF : OTP_LOWER_HALF;		ret = otp_func(page, flags, addr);		if (ret & 0x1)			break;		else if (ret)			puts("W");		else			puts(".");		++addr;		if (i % 2)			++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");	if (otp_func == otp_write)		/* Only supported in newer silicon ... disable writing */#if (0)		otp_command(OTP_INIT, ...);#else		*pOTP_TIMING = 0x1485;#endif	return ret;}U_BOOT_CMD(otp, 6, 0, do_otp,	"otp - One-Time-Programmable sub-system\n",	"read <addr> <page> [count] [half]\n"	"otp write [--force] <addr> <page> [count] [half]\n"	"    - read/write 'count' half-pages starting at page 'page' (offset 'half')\n");#endif