int upgrade_bootloader(void)
{
int i = 0, j = 0, retry = 2;
char str[128];
unsigned long size, size1;
char *filepath;
printf("u-boot upgrading...\n");
if(run_command ("mmcinfo", 0))
{
UPGRADE_DPRINT("## ERROR: SD card not find!!!\n");
}
else
{
UPGRADE_DPRINT("Find SD card!!!\n");
for(i = 0; i < SCAN_MMC_PARTITION; i++)
{
sprintf(str, "fatexist mmc 0:%d ${bootloader_path}", (i + 1));
UPGRADE_DPRINT("command: %s\n", str);
if(!run_command (str, 0))
{
size = simple_strtoul (getenv ("bootloader_filesize"), NULL, 16);
size1 = simple_strtoul (getenv ("filesize"), NULL, 16);
//if(size != size1)
{
UPGRADE_DPRINT("bootloader_filesize:%d != filesize:%d\n", size, size1);
while(retry-- > 0)
{
sprintf(str, "fatload mmc 0:%d ${loadaddr} ${bootloader_path}", (i + 1));
UPGRADE_DPRINT("command: %s\n", str);
run_command (str, 0);
run_command ("nand rom_protect off", 0);
#ifdef NAND_CLEAN
int partition_num = simple_strtoul(getenv ("partnum"), NULL, 16);;
for(j = 0; j < partition_num; j++)
{
sprintf(str, "p%dpath", j);
filepath = getenv (str);
sprintf(str, "fatexist mmc 0:%d %s", (i + 1), filepath);
UPGRADE_DPRINT("command: %s\n", str);
if(run_command (str, 0))
{
break;
}
}
if(j >= (partition_num - 1))
{
run_command ("nand scrub", 0);
}
#endif
run_command ("nand rom_write ${loadaddr} ${bootloader_start} ${bootloader_size}", 0);
run_command ("nand rom_protect on", 0);
size = simple_strtoul (getenv ("filesize"), NULL, 16);
sprintf(str, "set bootloader_filesize 0x%x", size);
run_command (str, 0);
UPGRADE_DPRINT("bootloader upgrade successful!\n");
run_command ("save", 0);
return 1;
}
}
}
}
}
return 0;
}
static ssize_t timeout_suspend_store(struct device *d, struct device_attribute *attr, const char *buf, size_t n)
{
timeout_suspend_us = simple_strtoul(buf, NULL, 10);
return n;
}
static int __init root_delay_setup(char *str)
{
root_delay = simple_strtoul(str, NULL, 0);
return 1;
}
static int __init hung_task_panic_setup(char *str)
{
sysctl_hung_task_panic = simple_strtoul(str, NULL, 0);
return 1;
}
void dmw_bootmenu(void)
{
char *tmp = NULL;
tmp = getenv("bootmenu_on");
enter_bootmenu = tmp ? simple_strtoul(tmp, NULL, 10) : 0;
if (enter_bootmenu != 1) {
/* no bootmenu */
return;
}
/* init time base */
time_base = get_timer(0);
tmp = getenv("menu_enter_keypad_row");
menu_enter_keypad_row = tmp ? simple_strtoul(tmp, NULL, 10) : -1;
tmp = getenv("menu_enter_keypad_col");
menu_enter_keypad_col = tmp ? simple_strtoul(tmp, NULL, 10) : -1;
tmp = getenv("menu_next_keypad_row");
menu_next_keypad_row = tmp ? simple_strtoul(tmp, NULL, 10) : -1;
tmp = getenv("menu_next_keypad_col");
menu_next_keypad_col = tmp ? simple_strtoul(tmp, NULL, 10) : -1;
tmp = getenv("menu_next_key_text");
if (tmp != NULL) {
strncpy(menu_next_keypad_text, tmp, min(MENU_KEYPAD_TEXT_SIZE, strlen(tmp)));
bootmenu_setup.next_key_action = &menu_next_keypad_text[0];
}
tmp = getenv("menu_enter_key_text");
if (tmp != NULL) {
strncpy(menu_enter_keypad_text, tmp, min(MENU_KEYPAD_TEXT_SIZE, strlen(tmp)));
bootmenu_setup.enter_key_name = &menu_enter_keypad_text[0];
}
if ((menu_next_keypad_row == -1) || (menu_next_keypad_col == -1)) {
bootmenu_setup.next_key_action = "Press [no key defined]";
bootmenu_setup.next_key = NULL;
}
if ((menu_next_keypad_row == -1) || (menu_next_keypad_col == -1)) {
bootmenu_setup.next_key_action = "Press [no key defined]";
bootmenu_setup.next_key = no_key;
}
if ((menu_enter_keypad_row == -1) || (menu_enter_keypad_col == -1)) {
bootmenu_setup.enter_key_name = "[no key defined]";
bootmenu_setup.enter_key = no_key;
}
bootmenu_add("Boot Linux", NULL, "boot");
/* bootmenu_add("Set console to USB", NULL, "setenv stdin=usbtty; setenv stdout=usbtty; setenv stderr=usbtty");
bootmenu_add("Set console to serial", NULL, "setenv stdin=serial; setenv stdout=serial; setenv stderr=serial"); */
bootmenu_add("Reboot", NULL, "reset");
/* bootmenu_add("Power off", NULL, "reset"); */
bootmenu_add("Factory reset", NULL, "defenv; saveenv");
bootmenu_add("Upgrade from SD card", NULL, "if mmc rescan 0; then " \
"if run loadbootscript; then " \
"run bootscript; fi; fi");
bootmenu_init(&bootmenu_setup);
bootmenu();
}
dev_t name_to_dev_t(char *name)
{
char s[32];
char *p;
dev_t res = 0;
int part;
#ifdef CONFIG_SYSFS
int mkdir_err = sys_mkdir("/sys", 0700);
if (sys_mount("sysfs", "/sys", "sysfs", 0, NULL) < 0)
goto out;
#endif
if (strncmp(name, "/dev/", 5) != 0) {
unsigned maj, min;
if (sscanf(name, "%u:%u", &maj, &min) == 2) {
res = MKDEV(maj, min);
if (maj != MAJOR(res) || min != MINOR(res))
goto fail;
} else {
res = new_decode_dev(simple_strtoul(name, &p, 16));
if (*p)
goto fail;
}
goto done;
}
name += 5;
res = Root_NFS;
if (strcmp(name, "nfs") == 0)
goto done;
res = Root_RAM0;
if (strcmp(name, "ram") == 0)
goto done;
if (strlen(name) > 31)
goto fail;
strcpy(s, name);
for (p = s; *p; p++)
if (*p == '/')
*p = '!';
res = try_name(s, 0);
if (res)
goto done;
while (p > s && isdigit(p[-1]))
p--;
if (p == s || !*p || *p == '0')
goto fail;
part = simple_strtoul(p, NULL, 10);
*p = '\0';
res = try_name(s, part);
if (res)
goto done;
if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
goto fail;
p[-1] = '\0';
res = try_name(s, part);
done:
#ifdef CONFIG_SYSFS
sys_umount("/sys", 0);
out:
if (!mkdir_err)
sys_rmdir("/sys");
#endif
return res;
fail:
res = 0;
goto done;
}
static int parse_opts(char *opts, uid_t *uid, gid_t *gid, umode_t *umask,
int *lowercase, int *conv, int *eas, int *chk, int *errs,
int *chkdsk, int *timeshift)
{
char *p;
int option;
if (!opts)
return 1;
/*printk("Parsing opts: '%s'\n",opts);*/
while ((p = strsep(&opts, ",")) != NULL) {
substring_t args[MAX_OPT_ARGS];
int token;
if (!*p)
continue;
token = match_token(p, tokens, args);
switch (token) {
case Opt_help:
return 2;
case Opt_uid:
if (match_int(args, &option))
return 0;
*uid = option;
break;
case Opt_gid:
if (match_int(args, &option))
return 0;
*gid = option;
break;
case Opt_umask:
if (match_octal(args, &option))
return 0;
*umask = option;
break;
case Opt_case_lower:
*lowercase = 1;
break;
case Opt_case_asis:
*lowercase = 0;
break;
case Opt_conv_binary:
*conv = CONV_BINARY;
break;
case Opt_conv_text:
*conv = CONV_TEXT;
break;
case Opt_conv_auto:
*conv = CONV_AUTO;
break;
case Opt_check_none:
*chk = 0;
break;
case Opt_check_normal:
*chk = 1;
break;
case Opt_check_strict:
*chk = 2;
break;
case Opt_err_cont:
*errs = 0;
break;
case Opt_err_ro:
*errs = 1;
break;
case Opt_err_panic:
*errs = 2;
break;
case Opt_eas_no:
*eas = 0;
break;
case Opt_eas_ro:
*eas = 1;
break;
case Opt_eas_rw:
*eas = 2;
break;
case Opt_chkdsk_no:
*chkdsk = 0;
break;
case Opt_chkdsk_errors:
*chkdsk = 1;
break;
case Opt_chkdsk_always:
*chkdsk = 2;
break;
case Opt_timeshift:
{
int m = 1;
char *rhs = args[0].from;
if (!rhs || !*rhs)
return 0;
if (*rhs == '-') m = -1;
if (*rhs == '+' || *rhs == '-') rhs++;
*timeshift = simple_strtoul(rhs, &rhs, 0) * m;
if (*rhs)
return 0;
break;
}
default:
return 0;
}
}
return 1;
}
static ssize_t set_vrm(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
struct lm87_data *data = dev_get_drvdata(dev);
data->vrm = simple_strtoul(buf, NULL, 10);
return count;
}
static int do_usb_mass_storage(cmd_tbl_t *cmdtp, int flag,
int argc, char * const argv[])
{
const char *usb_controller;
const char *devtype;
const char *devnum;
unsigned int controller_index;
int rc;
int cable_ready_timeout __maybe_unused;
if (argc < 3)
return CMD_RET_USAGE;
usb_controller = argv[1];
if (argc >= 4) {
devtype = argv[2];
devnum = argv[3];
} else {
devtype = "mmc";
devnum = argv[2];
}
rc = ums_init(devtype, devnum);
if (rc < 0)
return CMD_RET_FAILURE;
controller_index = (unsigned int)(simple_strtoul(
usb_controller, NULL, 0));
if (board_usb_init(controller_index, USB_INIT_DEVICE)) {
pr_err("Couldn't init USB controller.");
rc = CMD_RET_FAILURE;
goto cleanup_ums_init;
}
rc = fsg_init(ums, ums_count);
if (rc) {
pr_err("fsg_init failed");
rc = CMD_RET_FAILURE;
goto cleanup_board;
}
rc = g_dnl_register("usb_dnl_ums");
if (rc) {
pr_err("g_dnl_register failed");
rc = CMD_RET_FAILURE;
goto cleanup_board;
}
/* Timeout unit: seconds */
cable_ready_timeout = UMS_CABLE_READY_TIMEOUT;
if (!g_dnl_board_usb_cable_connected()) {
/*
* Won't execute if we don't know whether the cable is
* connected.
*/
puts("Please connect USB cable.\n");
while (!g_dnl_board_usb_cable_connected()) {
if (ctrlc()) {
puts("\rCTRL+C - Operation aborted.\n");
rc = CMD_RET_SUCCESS;
goto cleanup_register;
}
if (!cable_ready_timeout) {
puts("\rUSB cable not detected.\n" \
"Command exit.\n");
rc = CMD_RET_SUCCESS;
goto cleanup_register;
}
printf("\rAuto exit in: %.2d s.", cable_ready_timeout);
mdelay(1000);
cable_ready_timeout--;
}
puts("\r\n");
}
while (1) {
usb_gadget_handle_interrupts(controller_index);
rc = fsg_main_thread(NULL);
if (rc) {
/* Check I/O error */
if (rc == -EIO)
printf("\rCheck USB cable connection\n");
/* Check CTRL+C */
if (rc == -EPIPE)
printf("\rCTRL+C - Operation aborted\n");
rc = CMD_RET_SUCCESS;
goto cleanup_register;
}
}
cleanup_register:
g_dnl_unregister();
cleanup_board:
board_usb_cleanup(controller_index, USB_INIT_DEVICE);
cleanup_ums_init:
ums_fini();
return rc;
}
static int __init spin_retry_setup(char *str)
{
spin_retry = simple_strtoul(str, &str, 0);
return 1;
}
static int
parse_options(char *options, uid_t *uid, gid_t *gid, int *mode, int *reserved, int *root,
int *blocksize, char **prefix, char *volume, unsigned long *mount_opts)
{
char *this_char, *value;
int f;
/* Fill in defaults */
*uid = 0;
*gid = 0;
*reserved = 2;
*root = -1;
*blocksize = -1;
*prefix = "/";
volume[0] = ':';
volume[1] = 0;
*mount_opts = 0;
if (!options)
return 1;
for (this_char = strtok(options,","); this_char; this_char = strtok(NULL,",")) {
f = 0;
if ((value = strchr(this_char,'=')) != NULL)
*value++ = 0;
if (!strcmp(this_char,"protect")) {
if (value) {
printk("AFFS: option protect does not take an argument\n");
return 0;
}
*mount_opts |= SF_IMMUTABLE;
}
if (!strcmp(this_char,"usemp")) {
if (value) {
printk("AFFS: option usemp does not take an argument\n");
return 0;
}
*mount_opts |= SF_USE_MP;
}
else if (!strcmp(this_char,"verbose")) {
if (value) {
printk("AFFS: option verbose does not take an argument\n");
return 0;
}
*mount_opts |= SF_VERBOSE;
}
else if ((f = !strcmp(this_char,"uid")) || !strcmp(this_char,"setuid")) {
if (!value)
*uid = current->uid;
else if (!*value) {
printk("AFFS: argument for uid option missing\n");
return 0;
} else {
*uid = simple_strtoul(value,&value,0);
if (*value)
return 0;
if (!f)
*mount_opts |= SF_SETUID;
}
}
else if ((f = !strcmp(this_char,"gid")) || !strcmp(this_char,"setgid")) {
if (!value)
*gid = current->gid;
else if (!*value) {
printk("AFFS: argument for gid option missing\n");
return 0;
} else {
*gid = simple_strtoul(value,&value,0);
if (*value)
return 0;
if (!f)
*mount_opts |= SF_SETGID;
}
}
else if (!strcmp(this_char,"prefix")) {
if (!value) {
printk("AFFS: The prefix option requires an argument\n");
return 0;
}
*prefix = kmalloc(strlen(value) + 1,GFP_KERNEL);
if (!*prefix)
return 0;
strcpy(*prefix,value);
*mount_opts |= SF_PREFIX;
}
else if (!strcmp(this_char,"volume")) {
if (!value) {
printk("AFFS: The volume option requires an argument\n");
return 0;
}
if (strlen(value) > 30)
value[30] = 0;
strcpy(volume,value);
}
else if (!strcmp(this_char,"mode")) {
if (!value || !*value) {
printk("AFFS: The mode option requires an argument\n");
return 0;
}
*mode = simple_strtoul(value,&value,8) & 0777;
if (*value)
return 0;
*mount_opts |= SF_SETMODE;
}
else if (!strcmp(this_char,"reserved")) {
if (!value || !*value) {
printk("AFFS: The reserved option requires an argument\n");
return 0;
}
*reserved = simple_strtoul(value,&value,0);
if (*value)
return 0;
}
else if (!strcmp(this_char,"root")) {
if (!value || !*value) {
printk("AFFS: The root option requires an argument\n");
return 0;
}
*root = simple_strtoul(value,&value,0);
if (*value)
return 0;
}
else if (!strcmp(this_char,"bs")) {
if (!value || !*value) {
printk("AFFS: The bs option requires an argument\n");
return 0;
}
*blocksize = simple_strtoul(value,&value,0);
if (*value)
return 0;
if (*blocksize != 512 && *blocksize != 1024 && *blocksize != 2048
&& *blocksize != 4096) {
printk ("AFFS: Invalid blocksize (512, 1024, 2048, 4096 allowed).\n");
return 0;
}
}
/* Silently ignore the quota options */
else if (!strcmp (this_char, "grpquota")
|| !strcmp (this_char, "noquota")
|| !strcmp (this_char, "quota")
|| !strcmp (this_char, "usrquota"))
;
else {
printk("AFFS: Unrecognized mount option %s\n", this_char);
return 0;
}
}
return 1;
}
static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct cros_ec_dev *dev;
struct udevice *udev;
const char *cmd;
int ret = 0;
if (argc < 2)
return CMD_RET_USAGE;
cmd = argv[1];
if (0 == strcmp("init", cmd)) {
/* Remove any existing device */
ret = uclass_find_device(UCLASS_CROS_EC, 0, &udev);
if (!ret)
device_remove(udev);
ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
if (ret) {
printf("Could not init cros_ec device (err %d)\n", ret);
return 1;
}
return 0;
}
ret = uclass_get_device(UCLASS_CROS_EC, 0, &udev);
if (ret) {
printf("Cannot get cros-ec device (err=%d)\n", ret);
return 1;
}
dev = dev_get_uclass_priv(udev);
if (0 == strcmp("id", cmd)) {
char id[MSG_BYTES];
if (cros_ec_read_id(dev, id, sizeof(id))) {
debug("%s: Could not read KBC ID\n", __func__);
return 1;
}
printf("%s\n", id);
} else if (0 == strcmp("info", cmd)) {
struct ec_response_mkbp_info info;
if (cros_ec_info(dev, &info)) {
debug("%s: Could not read KBC info\n", __func__);
return 1;
}
printf("rows = %u\n", info.rows);
printf("cols = %u\n", info.cols);
printf("switches = %#x\n", info.switches);
} else if (0 == strcmp("curimage", cmd)) {
enum ec_current_image image;
if (cros_ec_read_current_image(dev, &image)) {
debug("%s: Could not read KBC image\n", __func__);
return 1;
}
printf("%d\n", image);
} else if (0 == strcmp("hash", cmd)) {
struct ec_response_vboot_hash hash;
int i;
if (cros_ec_read_hash(dev, &hash)) {
debug("%s: Could not read KBC hash\n", __func__);
return 1;
}
if (hash.hash_type == EC_VBOOT_HASH_TYPE_SHA256)
printf("type: SHA-256\n");
else
printf("type: %d\n", hash.hash_type);
printf("offset: 0x%08x\n", hash.offset);
printf("size: 0x%08x\n", hash.size);
printf("digest: ");
for (i = 0; i < hash.digest_size; i++)
printf("%02x", hash.hash_digest[i]);
printf("\n");
} else if (0 == strcmp("reboot", cmd)) {
int region;
enum ec_reboot_cmd cmd;
if (argc >= 3 && !strcmp(argv[2], "cold"))
cmd = EC_REBOOT_COLD;
else {
region = cros_ec_decode_region(argc - 2, argv + 2);
if (region == EC_FLASH_REGION_RO)
cmd = EC_REBOOT_JUMP_RO;
else if (region == EC_FLASH_REGION_RW)
cmd = EC_REBOOT_JUMP_RW;
else
return CMD_RET_USAGE;
}
if (cros_ec_reboot(dev, cmd, 0)) {
debug("%s: Could not reboot KBC\n", __func__);
return 1;
}
} else if (0 == strcmp("events", cmd)) {
uint32_t events;
if (cros_ec_get_host_events(dev, &events)) {
debug("%s: Could not read host events\n", __func__);
return 1;
}
printf("0x%08x\n", events);
} else if (0 == strcmp("clrevents", cmd)) {
uint32_t events = 0x7fffffff;
if (argc >= 3)
events = simple_strtol(argv[2], NULL, 0);
if (cros_ec_clear_host_events(dev, events)) {
debug("%s: Could not clear host events\n", __func__);
return 1;
}
} else if (0 == strcmp("read", cmd)) {
ret = do_read_write(dev, 0, argc, argv);
if (ret > 0)
return CMD_RET_USAGE;
} else if (0 == strcmp("write", cmd)) {
ret = do_read_write(dev, 1, argc, argv);
if (ret > 0)
return CMD_RET_USAGE;
} else if (0 == strcmp("erase", cmd)) {
int region = cros_ec_decode_region(argc - 2, argv + 2);
uint32_t offset, size;
if (region == -1)
return CMD_RET_USAGE;
if (cros_ec_flash_offset(dev, region, &offset, &size)) {
debug("%s: Could not read region info\n", __func__);
ret = -1;
} else {
ret = cros_ec_flash_erase(dev, offset, size);
if (ret) {
debug("%s: Could not erase region\n",
__func__);
}
}
} else if (0 == strcmp("regioninfo", cmd)) {
int region = cros_ec_decode_region(argc - 2, argv + 2);
uint32_t offset, size;
if (region == -1)
return CMD_RET_USAGE;
ret = cros_ec_flash_offset(dev, region, &offset, &size);
if (ret) {
debug("%s: Could not read region info\n", __func__);
} else {
printf("Region: %s\n", region == EC_FLASH_REGION_RO ?
"RO" : "RW");
printf("Offset: %x\n", offset);
printf("Size: %x\n", size);
}
} else if (0 == strcmp("vbnvcontext", cmd)) {
uint8_t block[EC_VBNV_BLOCK_SIZE];
char buf[3];
int i, len;
unsigned long result;
if (argc <= 2) {
ret = cros_ec_read_vbnvcontext(dev, block);
if (!ret) {
printf("vbnv_block: ");
for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++)
printf("%02x", block[i]);
putc('\n');
}
} else {
/*
* TODO(clchiou): Move this to a utility function as
* cmd_spi might want to call it.
*/
memset(block, 0, EC_VBNV_BLOCK_SIZE);
len = strlen(argv[2]);
buf[2] = '\0';
for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++) {
if (i * 2 >= len)
break;
buf[0] = argv[2][i * 2];
if (i * 2 + 1 >= len)
buf[1] = '0';
else
buf[1] = argv[2][i * 2 + 1];
strict_strtoul(buf, 16, &result);
block[i] = result;
}
ret = cros_ec_write_vbnvcontext(dev, block);
}
if (ret) {
debug("%s: Could not %s VbNvContext\n", __func__,
argc <= 2 ? "read" : "write");
}
} else if (0 == strcmp("test", cmd)) {
int result = cros_ec_test(dev);
if (result)
printf("Test failed with error %d\n", result);
else
puts("Test passed\n");
} else if (0 == strcmp("version", cmd)) {
struct ec_response_get_version *p;
char *build_string;
ret = cros_ec_read_version(dev, &p);
if (!ret) {
/* Print versions */
printf("RO version: %1.*s\n",
(int)sizeof(p->version_string_ro),
p->version_string_ro);
printf("RW version: %1.*s\n",
(int)sizeof(p->version_string_rw),
p->version_string_rw);
printf("Firmware copy: %s\n",
(p->current_image <
ARRAY_SIZE(ec_current_image_name) ?
ec_current_image_name[p->current_image] :
"?"));
ret = cros_ec_read_build_info(dev, &build_string);
if (!ret)
printf("Build info: %s\n", build_string);
}
} else if (0 == strcmp("ldo", cmd)) {
uint8_t index, state;
char *endp;
if (argc < 3)
return CMD_RET_USAGE;
index = simple_strtoul(argv[2], &endp, 10);
if (*argv[2] == 0 || *endp != 0)
return CMD_RET_USAGE;
if (argc > 3) {
state = simple_strtoul(argv[3], &endp, 10);
if (*argv[3] == 0 || *endp != 0)
return CMD_RET_USAGE;
ret = cros_ec_set_ldo(dev, index, state);
} else {
ret = cros_ec_get_ldo(dev, index, &state);
if (!ret) {
printf("LDO%d: %s\n", index,
state == EC_LDO_STATE_ON ?
"on" : "off");
}
}
if (ret) {
debug("%s: Could not access LDO%d\n", __func__, index);
return ret;
}
} else if (0 == strcmp("i2c", cmd)) {
ret = cros_ec_i2c_passthrough(dev, flag, argc - 2, argv + 2);
} else {
return CMD_RET_USAGE;
}
if (ret < 0) {
printf("Error: CROS-EC command failed (error %d)\n", ret);
ret = 1;
}
return ret;
}
/* * TODO([email protected]): This code copied almost verbatim from cmd_i2c.c * so we can remove it later. */ static int cros_ec_i2c_md(struct cros_ec_dev *dev, int flag, int argc, char * const argv[]) { u_char chip; uint addr, alen, length = 0x10; int j, nbytes, linebytes; if (argc < 2) return CMD_RET_USAGE; if (1 || (flag & CMD_FLAG_REPEAT) == 0) { /* * New command specified. */ /* * I2C chip address */ chip = simple_strtoul(argv[0], NULL, 16); /* * I2C data address within the chip. This can be 1 or * 2 bytes long. Some day it might be 3 bytes long :-). */ addr = simple_strtoul(argv[1], NULL, 16); alen = get_alen(argv[1]); if (alen > 3) return CMD_RET_USAGE; /* * If another parameter, it is the length to display. * Length is the number of objects, not number of bytes. */ if (argc > 2) length = simple_strtoul(argv[2], NULL, 16); } /* * Print the lines. * * We buffer all read data, so we can make sure data is read only * once. */ nbytes = length; do { unsigned char linebuf[DISP_LINE_LEN]; unsigned char *cp; linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes; if (cros_ec_i2c_xfer(dev, chip, addr, alen, linebuf, linebytes, 1)) puts("Error reading the chip.\n"); else { printf("%04x:", addr); cp = linebuf; for (j = 0; j < linebytes; j++) { printf(" %02x", *cp++); addr++; } puts(" "); cp = linebuf; for (j = 0; j < linebytes; j++) { if ((*cp < 0x20) || (*cp > 0x7e)) puts("."); else printf("%c", *cp); cp++; } putc('\n'); } nbytes -= linebytes; } while (nbytes > 0); return 0; }
int upgrade_partition(void)
{
int i = 0, j = 0, ret = 0, partition_num = 0;
char upgrade_status_list[16];
char str[128];
unsigned long size, size1;
char *filepath;
printf("partition upgrading...\n");
if(run_command ("mmcinfo", 0))
{
UPGRADE_DPRINT("## ERROR: SD card not find!!!\n");
}
else
{
UPGRADE_DPRINT("Find SD card!!!\n");
memset(upgrade_status_list, 0, 16);
partition_num = simple_strtoul(getenv ("partnum"), NULL, 16);
for(i = 0; i < SCAN_MMC_PARTITION; i++)
{
for(j = 0; j < partition_num; j++)
{
if(!upgrade_status_list[j])
{
sprintf(str, "p%dpath", j);
filepath = getenv (str);
sprintf(str, "fatexist mmc 0:%d %s", (i + 1), filepath);
UPGRADE_DPRINT("command: %s\n", str);
if(!run_command (str, 0))
{
sprintf(str, "p%dfilesize", j);
size = simple_strtoul (getenv (str), NULL, 16);
size1 = simple_strtoul (getenv ("filesize"), NULL, 16);
//if(size != size1)
{
sprintf(str, "fatload mmc 0:%d ${loadaddr} ${p%dpath}", (i + 1), j);
UPGRADE_DPRINT("command: %s\n", str);
run_command (str, 0);
sprintf(str, "nand erase ${p%dstart} ${p%dsize}", j, j);
run_command(str, 0);
sprintf(str, "nand write ${loadaddr} ${p%dstart} ${p%dsize}", j, j);
run_command (str, 0);
sprintf(str, "set p%dfilesize ${filesize}", j);
run_command (str, 0);
upgrade_status_list[j] = 1;
}
}
}
}
}
}
for(j = 0; j < partition_num; j++)
{
if(upgrade_status_list[j])
{
UPGRADE_DPRINT("p% upgrade successful!\n", j);
ret = 1;
}
}
if(ret)
{
run_command ("save", 0);
}
return ret;
}
/* Modify memory.
*
* Syntax:
* mm{.b, .w, .l} {addr}
* nm{.b, .w, .l} {addr}
*/
static int
mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char *argv[])
{
ulong addr, i;
int nbytes, size;
extern char console_buffer[];
if (argc != 2) {
cmd_usage(cmdtp);
return 1;
}
#ifdef CONFIG_BOOT_RETRY_TIME
reset_cmd_timeout(); /* got a good command to get here */
#endif
/* We use the last specified parameters, unless new ones are
* entered.
*/
addr = mm_last_addr;
size = mm_last_size;
if ((flag & CMD_FLAG_REPEAT) == 0) {
/* New command specified. Check for a size specification.
* Defaults to long if no or incorrect specification.
*/
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
return 1;
/* Address is specified since argc > 1
*/
addr = simple_strtoul(argv[1], NULL, 16);
addr += base_address;
}
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash(addr)){
puts ("Can't modify DataFlash in place. Use cp instead.\n\r");
return 0;
}
#endif
#ifdef CONFIG_BLACKFIN
if (addr_bfin_on_chip_mem(addr)) {
puts ("Can't modify L1 instruction in place. Use cp instead.\n\r");
return 0;
}
#endif
/* Print the address, followed by value. Then accept input for
* the next value. A non-converted value exits.
*/
do {
printf("%08lx:", addr);
if (size == 4)
printf(" %08x", *((uint *)addr));
else if (size == 2)
printf(" %04x", *((ushort *)addr));
else
printf(" %02x", *((u_char *)addr));
nbytes = readline (" ? ");
if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
/* <CR> pressed as only input, don't modify current
* location and move to next. "-" pressed will go back.
*/
if (incrflag)
addr += nbytes ? -size : size;
nbytes = 1;
#ifdef CONFIG_BOOT_RETRY_TIME
reset_cmd_timeout(); /* good enough to not time out */
#endif
}
#ifdef CONFIG_BOOT_RETRY_TIME
else if (nbytes == -2) {
break; /* timed out, exit the command */
}
#endif
else {
char *endp;
i = simple_strtoul(console_buffer, &endp, 16);
nbytes = endp - console_buffer;
if (nbytes) {
#ifdef CONFIG_BOOT_RETRY_TIME
/* good enough to not time out
*/
reset_cmd_timeout();
#endif
if (size == 4)
*((uint *)addr) = i;
else if (size == 2)
*((ushort *)addr) = i;
else
*((u_char *)addr) = i;
if (incrflag)
addr += size;
}
}
} while (nbytes);
mm_last_addr = addr;
mm_last_size = size;
return 0;
}
/* this was (ext2)parse_options */
static int parse_options (char * options, unsigned long * mount_options, unsigned long * blocks)
{
char * this_char;
char * value;
*blocks = 0;
if (!options)
/* use default configuration: create tails, journaling on, no
conversion to newest format */
return 1;
for (this_char = strtok (options, ","); this_char != NULL; this_char = strtok (NULL, ",")) {
if ((value = strchr (this_char, '=')) != NULL)
*value++ = 0;
if (!strcmp (this_char, "notail")) {
set_bit (NOTAIL, mount_options);
} else if (!strcmp (this_char, "conv")) {
// if this is set, we update super block such that
// the partition will not be mounable by 3.5.x anymore
set_bit (REISERFS_CONVERT, mount_options);
} else if (!strcmp (this_char, "noborder")) {
/* this is used for benchmarking
experimental variations, it is not
intended for users to use, only for
developers who want to casually
hack in something to test */
set_bit (REISERFS_NO_BORDER, mount_options);
} else if (!strcmp (this_char, "no_unhashed_relocation")) {
set_bit (REISERFS_NO_UNHASHED_RELOCATION, mount_options);
} else if (!strcmp (this_char, "hashed_relocation")) {
set_bit (REISERFS_HASHED_RELOCATION, mount_options);
} else if (!strcmp (this_char, "test4")) {
set_bit (REISERFS_TEST4, mount_options);
} else if (!strcmp (this_char, "nolog")) {
reiserfs_warning("reiserfs: nolog mount option not supported yet\n");
} else if (!strcmp (this_char, "replayonly")) {
set_bit (REPLAYONLY, mount_options);
} else if (!strcmp (this_char, "resize")) {
if (value && *value){
*blocks = simple_strtoul (value, &value, 0);
} else {
printk("reiserfs: resize option requires a value\n");
return 0;
}
} else if (!strcmp (this_char, "hash")) {
if (value && *value) {
/* if they specify any hash option, we force detection
** to make sure they aren't using the wrong hash
*/
if (!strcmp(value, "rupasov")) {
set_bit (FORCE_RUPASOV_HASH, mount_options);
set_bit (FORCE_HASH_DETECT, mount_options);
} else if (!strcmp(value, "tea")) {
set_bit (FORCE_TEA_HASH, mount_options);
set_bit (FORCE_HASH_DETECT, mount_options);
} else if (!strcmp(value, "r5")) {
set_bit (FORCE_R5_HASH, mount_options);
set_bit (FORCE_HASH_DETECT, mount_options);
} else if (!strcmp(value, "detect")) {
set_bit (FORCE_HASH_DETECT, mount_options);
} else {
printk("reiserfs: invalid hash function specified\n") ;
return 0 ;
}
} else {
printk("reiserfs: hash option requires a value\n");
return 0 ;
}
} else {
printk ("reiserfs: Unrecognized mount option %s\n", this_char);
return 0;
}
}
return 1;
}
int do_vcma9(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
if (strcmp(argv[1], "info") == 0)
{
print_vcma9_info();
return 0;
}
#if defined(CONFIG_DRIVER_CS8900)
if (strcmp(argv[1], "cs8900") == 0) {
if (strcmp(argv[2], "read") == 0) {
uchar addr; ushort data;
addr = simple_strtoul(argv[3], NULL, 16);
cs8900_e2prom_read(addr, &data);
printf("0x%2.2X: 0x%4.4X\n", addr, data);
} else if (strcmp(argv[2], "write") == 0) {
uchar addr; ushort data;
addr = simple_strtoul(argv[3], NULL, 16);
data = simple_strtoul(argv[4], NULL, 16);
cs8900_e2prom_write(addr, data);
} else if (strcmp(argv[2], "setaddr") == 0) {
uchar addr, i, csum; ushort data;
/* check for valid ethaddr */
for (i = 0; i < 6; i++)
if (gd->bd->bi_enetaddr[i] != 0)
break;
if (i < 6) {
addr = 1;
data = 0x2158;
cs8900_e2prom_write(addr, data);
csum = cs8900_chksum(data);
addr++;
for (i = 0; i < 6; i+=2) {
data = gd->bd->bi_enetaddr[i+1] << 8 |
gd->bd->bi_enetaddr[i];
cs8900_e2prom_write(addr, data);
csum += cs8900_chksum(data);
addr++;
}
/* calculate header link byte */
data = 0xA100 | (addr * 2);
cs8900_e2prom_write(0, data);
csum += cs8900_chksum(data);
/* write checksum word */
cs8900_e2prom_write(addr, (0 - csum) << 8);
} else {
puts("\nplease defined 'ethaddr'\n");
}
} else if (strcmp(argv[2], "dump") == 0) {
uchar addr = 0, endaddr, csum; ushort data;
puts("Dump of CS8900 config device: ");
cs8900_e2prom_read(addr, &data);
if ((data & 0xE000) == 0xA000) {
endaddr = (data & 0x00FF) / 2;
csum = cs8900_chksum(data);
for (addr = 1; addr <= endaddr; addr++) {
cs8900_e2prom_read(addr, &data);
printf("\n0x%2.2X: 0x%4.4X", addr, data);
csum += cs8900_chksum(data);
}
printf("\nChecksum: %s", (csum == 0) ? "ok" : "wrong");
} else {
puts("no valid config found");
}
puts("\n");
}
return 0;
}
#endif
#if 0
if (strcmp(argv[1], "cantest") == 0) {
if (argc >= 3)
vcma9_cantest(strcmp(argv[2], "s") ? 0 : 1);
else
vcma9_cantest(0);
return 0;
}
if (strcmp(argv[1], "nandtest") == 0) {
vcma9_nandtest();
return 0;
}
if (strcmp(argv[1], "nanderase") == 0) {
vcma9_nanderase();
return 0;
}
if (strcmp(argv[1], "nandread") == 0) {
ulong offset = 0;
if (argc >= 3)
offset = simple_strtoul(argv[2], NULL, 16);
vcma9_nandread(offset);
return 0;
}
if (strcmp(argv[1], "nandwrite") == 0) {
ulong offset = 0;
if (argc >= 3)
offset = simple_strtoul(argv[2], NULL, 16);
vcma9_nandwrite(offset);
return 0;
}
if (strcmp(argv[1], "dactest") == 0) {
if (argc >= 3)
vcma9_dactest(strcmp(argv[2], "s") ? 0 : 1);
else
vcma9_dactest(0);
return 0;
}
#endif
return (do_mplcommon(cmdtp, flag, argc, argv));
}
void
sti_putc(struct sti_struct *sti, int c, int y, int x)
{
struct sti_font_inptr inptr = {
.font_start_addr= STI_PTR(sti->font->raw),
.index = c_index(sti, c),
.fg_color = c_fg(sti, c),
.bg_color = c_bg(sti, c),
.dest_x = x * sti->font_width,
.dest_y = y * sti->font_height,
};
struct sti_font_outptr outptr = { 0, };
s32 ret;
unsigned long flags;
do {
spin_lock_irqsave(&sti->lock, flags);
ret = STI_CALL(sti->font_unpmv, &default_font_flags,
&inptr, &outptr, sti->glob_cfg);
spin_unlock_irqrestore(&sti->lock, flags);
} while (ret == 1);
}
static const struct sti_blkmv_flags clear_blkmv_flags = {
.wait = STI_WAIT,
.color = 1,
.clear = 1,
};
void
sti_set(struct sti_struct *sti, int src_y, int src_x,
int height, int width, u8 color)
{
struct sti_blkmv_inptr inptr = {
.fg_color = color,
.bg_color = color,
.src_x = src_x,
.src_y = src_y,
.dest_x = src_x,
.dest_y = src_y,
.width = width,
.height = height,
};
struct sti_blkmv_outptr outptr = { 0, };
s32 ret;
unsigned long flags;
do {
spin_lock_irqsave(&sti->lock, flags);
ret = STI_CALL(sti->block_move, &clear_blkmv_flags,
&inptr, &outptr, sti->glob_cfg);
spin_unlock_irqrestore(&sti->lock, flags);
} while (ret == 1);
}
void
sti_clear(struct sti_struct *sti, int src_y, int src_x,
int height, int width, int c)
{
struct sti_blkmv_inptr inptr = {
.fg_color = c_fg(sti, c),
.bg_color = c_bg(sti, c),
.src_x = src_x * sti->font_width,
.src_y = src_y * sti->font_height,
.dest_x = src_x * sti->font_width,
.dest_y = src_y * sti->font_height,
.width = width * sti->font_width,
.height = height* sti->font_height,
};
struct sti_blkmv_outptr outptr = { 0, };
s32 ret;
unsigned long flags;
do {
spin_lock_irqsave(&sti->lock, flags);
ret = STI_CALL(sti->block_move, &clear_blkmv_flags,
&inptr, &outptr, sti->glob_cfg);
spin_unlock_irqrestore(&sti->lock, flags);
} while (ret == 1);
}
static const struct sti_blkmv_flags default_blkmv_flags = {
.wait = STI_WAIT,
};
void
sti_bmove(struct sti_struct *sti, int src_y, int src_x,
int dst_y, int dst_x, int height, int width)
{
struct sti_blkmv_inptr inptr = {
.src_x = src_x * sti->font_width,
.src_y = src_y * sti->font_height,
.dest_x = dst_x * sti->font_width,
.dest_y = dst_y * sti->font_height,
.width = width * sti->font_width,
.height = height* sti->font_height,
};
struct sti_blkmv_outptr outptr = { 0, };
s32 ret;
unsigned long flags;
do {
spin_lock_irqsave(&sti->lock, flags);
ret = STI_CALL(sti->block_move, &default_blkmv_flags,
&inptr, &outptr, sti->glob_cfg);
spin_unlock_irqrestore(&sti->lock, flags);
} while (ret == 1);
}
/* FIXME: Do we have another solution for this ? */
static void sti_flush(unsigned long from, unsigned long len)
{
flush_data_cache();
flush_kernel_dcache_range(from, len);
flush_icache_range(from, from+len);
}
void __init
sti_rom_copy(unsigned long base, unsigned long count, void *dest)
{
unsigned long dest_len = count;
unsigned long dest_start = (unsigned long) dest;
/* this still needs to be revisited (see arch/parisc/mm/init.c:246) ! */
while (count >= 4) {
count -= 4;
*(u32 *)dest = __raw_readl(base);
base += 4;
dest += 4;
}
while (count) {
count--;
*(u8 *)dest = __raw_readb(base);
base++;
dest++;
}
sti_flush(dest_start, dest_len);
}
static char default_sti_path[21];
#ifndef MODULE
static int __init sti_setup(char *str)
{
if (str)
strlcpy (default_sti_path, str, sizeof (default_sti_path));
return 0;
}
/* Assuming the machine has multiple STI consoles (=graphic cards) which
* all get detected by sticon, the user may define with the linux kernel
* parameter sti=<x> which of them will be the initial boot-console.
* <x> is a number between 0 and MAX_STI_ROMS, with 0 as the default
* STI screen.
*/
__setup("sti=", sti_setup);
#endif
static char __initdata *font_name[MAX_STI_ROMS] = { "VGA8x16", };
static int __initdata font_index[MAX_STI_ROMS],
font_height[MAX_STI_ROMS],
font_width[MAX_STI_ROMS];
#ifndef MODULE
static int __init sti_font_setup(char *str)
{
char *x;
int i = 0;
/* we accept sti_font=VGA8x16, sti_font=10x20, sti_font=10*20
* or sti_font=7 style command lines. */
while (i<MAX_STI_ROMS && str && *str) {
if (*str>='0' && *str<='9') {
if ((x = strchr(str, 'x')) || (x = strchr(str, '*'))) {
font_height[i] = simple_strtoul(str, NULL, 0);
font_width[i] = simple_strtoul(x+1, NULL, 0);
} else {
font_index[i] = simple_strtoul(str, NULL, 0);
}
} else {
font_name[i] = str; /* fb font name */
}
if ((x = strchr(str, ',')))
*x++ = 0;
str = x;
i++;
}
return 0;
}
/* The optional linux kernel parameter "sti_font" defines which font
* should be used by the sticon driver to draw characters to the screen.
* Possible values are:
* - sti_font=<fb_fontname>:
* <fb_fontname> is the name of one of the linux-kernel built-in
* framebuffer font names (e.g. VGA8x16, SUN22x18).
* This is only available if the fonts have been statically compiled
* in with e.g. the CONFIG_FONT_8x16 or CONFIG_FONT_SUN12x22 options.
* - sti_font=<number>
* most STI ROMs have built-in HP specific fonts, which can be selected
* by giving the desired number to the sticon driver.
* NOTE: This number is machine and STI ROM dependend.
* - sti_font=<height>x<width> (e.g. sti_font=16x8)
* <height> and <width> gives hints to the height and width of the
* font which the user wants. The sticon driver will try to use
* a font with this height and width, but if no suitable font is
* found, sticon will use the default 8x8 font.
*/
__setup("sti_font=", sti_font_setup);
#endif
static void __init
sti_dump_globcfg(struct sti_glob_cfg *glob_cfg, unsigned int sti_mem_request)
{
struct sti_glob_cfg_ext *cfg;
DPRINTK((KERN_INFO
"%d text planes\n"
"%4d x %4d screen resolution\n"
"%4d x %4d offscreen\n"
"%4d x %4d layout\n"
"regions at %08x %08x %08x %08x\n"
"regions at %08x %08x %08x %08x\n"
"reent_lvl %d\n"
"save_addr %08x\n",
glob_cfg->text_planes,
glob_cfg->onscreen_x, glob_cfg->onscreen_y,
glob_cfg->offscreen_x, glob_cfg->offscreen_y,
glob_cfg->total_x, glob_cfg->total_y,
glob_cfg->region_ptrs[0], glob_cfg->region_ptrs[1],
glob_cfg->region_ptrs[2], glob_cfg->region_ptrs[3],
glob_cfg->region_ptrs[4], glob_cfg->region_ptrs[5],
glob_cfg->region_ptrs[6], glob_cfg->region_ptrs[7],
glob_cfg->reent_lvl,
glob_cfg->save_addr));
/* dump extended cfg */
cfg = PTR_STI(glob_cfg->ext_ptr);
DPRINTK(( KERN_INFO
"monitor %d\n"
"in friendly mode: %d\n"
"power consumption %d watts\n"
"freq ref %d\n"
"sti_mem_addr %08x (size=%d bytes)\n",
cfg->curr_mon,
cfg->friendly_boot,
cfg->power,
cfg->freq_ref,
cfg->sti_mem_addr, sti_mem_request));
}
static void __init
sti_dump_outptr(struct sti_struct *sti)
{
DPRINTK((KERN_INFO
"%d bits per pixel\n"
"%d used bits\n"
"%d planes\n"
"attributes %08x\n",
sti->outptr.bits_per_pixel,
sti->outptr.bits_used,
sti->outptr.planes,
sti->outptr.attributes));
}
static dev_t try_name(char *name, int part)
{
char path[64];
char buf[32];
int range;
dev_t res;
char *s;
int len;
int fd;
unsigned int maj, min;
/* read device number from .../dev */
sprintf(path, "/sys/block/%s/dev", name);
fd = sys_open(path, 0, 0);
if (fd < 0)
goto fail;
len = sys_read(fd, buf, 32);
sys_close(fd);
if (len <= 0 || len == 32 || buf[len - 1] != '\n')
goto fail;
buf[len - 1] = '\0';
if (sscanf(buf, "%u:%u", &maj, &min) == 2) {
/*
* Try the %u:%u format -- see print_dev_t()
*/
res = MKDEV(maj, min);
if (maj != MAJOR(res) || min != MINOR(res))
goto fail;
} else {
/*
* Nope. Try old-style "0321"
*/
res = new_decode_dev(simple_strtoul(buf, &s, 16));
if (*s)
goto fail;
}
/* if it's there and we are not looking for a partition - that's it */
if (!part)
return res;
/* otherwise read range from .../range */
sprintf(path, "/sys/block/%s/range", name);
fd = sys_open(path, 0, 0);
if (fd < 0)
goto fail;
len = sys_read(fd, buf, 32);
sys_close(fd);
if (len <= 0 || len == 32 || buf[len - 1] != '\n')
goto fail;
buf[len - 1] = '\0';
range = simple_strtoul(buf, &s, 10);
if (*s)
goto fail;
/* if partition is within range - we got it */
if (part < range)
return res + part;
fail:
return 0;
}
int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong addr1, addr2, count, ngood;
int size;
int rcode = 0;
if (argc != 4) {
cmd_usage(cmdtp);
return 1;
}
/* Check for size specification.
*/
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
return 1;
addr1 = simple_strtoul(argv[1], NULL, 16);
addr1 += base_address;
addr2 = simple_strtoul(argv[2], NULL, 16);
addr2 += base_address;
count = simple_strtoul(argv[3], NULL, 16);
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash(addr1) | addr_dataflash(addr2)){
puts ("Comparison with DataFlash space not supported.\n\r");
return 0;
}
#endif
#ifdef CONFIG_BLACKFIN
if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) {
puts ("Comparison with L1 instruction memory not supported.\n\r");
return 0;
}
#endif
ngood = 0;
while (count-- > 0) {
if (size == 4) {
ulong word1 = *(ulong *)addr1;
ulong word2 = *(ulong *)addr2;
if (word1 != word2) {
printf("word at 0x%08lx (0x%08lx) "
"!= word at 0x%08lx (0x%08lx)\n",
addr1, word1, addr2, word2);
rcode = 1;
break;
}
}
else if (size == 2) {
ushort hword1 = *(ushort *)addr1;
ushort hword2 = *(ushort *)addr2;
if (hword1 != hword2) {
printf("halfword at 0x%08lx (0x%04x) "
"!= halfword at 0x%08lx (0x%04x)\n",
addr1, hword1, addr2, hword2);
rcode = 1;
break;
}
}
else {
u_char byte1 = *(u_char *)addr1;
u_char byte2 = *(u_char *)addr2;
if (byte1 != byte2) {
printf("byte at 0x%08lx (0x%02x) "
"!= byte at 0x%08lx (0x%02x)\n",
addr1, byte1, addr2, byte2);
rcode = 1;
break;
}
}
ngood++;
addr1 += size;
addr2 += size;
}
printf("Total of %ld %s%s were the same\n",
ngood, size == 4 ? "word" : size == 2 ? "halfword" : "byte",
ngood == 1 ? "" : "s");
return rcode;
}
static int wl_android_set_pno_setup(struct net_device *dev, char *command, int total_len)
{
wlc_ssid_t ssids_local[MAX_PFN_LIST_COUNT];
int res = -1;
int nssid = 0;
cmd_tlv_t *cmd_tlv_temp;
char *str_ptr;
int tlv_size_left;
int pno_time = 0;
int pno_repeat = 0;
int pno_freq_expo_max = 0;
#ifdef PNO_SET_DEBUG
int i;
char pno_in_example[] = {
'P', 'N', 'O', 'S', 'E', 'T', 'U', 'P', ' ',
'S', '1', '2', '0',
'S',
0x05,
'd', 'l', 'i', 'n', 'k',
'S',
0x04,
'G', 'O', 'O', 'G',
'T',
'0', 'B',
'R',
'2',
'M',
'2',
0x00
};
#endif /* PNO_SET_DEBUG */
DHD_INFO(("%s: command=%s, len=%d\n", __FUNCTION__, command, total_len));
if (total_len < (strlen(CMD_PNOSETUP_SET) + sizeof(cmd_tlv_t))) {
DBG_871X("%s argument=%d less min size\n", __FUNCTION__, total_len);
goto exit_proc;
}
#ifdef PNO_SET_DEBUG
memcpy(command, pno_in_example, sizeof(pno_in_example));
for (i = 0; i < sizeof(pno_in_example); i++)
printf("%02X ", command[i]);
printf("\n");
total_len = sizeof(pno_in_example);
#endif
str_ptr = command + strlen(CMD_PNOSETUP_SET);
tlv_size_left = total_len - strlen(CMD_PNOSETUP_SET);
cmd_tlv_temp = (cmd_tlv_t *)str_ptr;
memset(ssids_local, 0, sizeof(ssids_local));
if ((cmd_tlv_temp->prefix == PNO_TLV_PREFIX) &&
(cmd_tlv_temp->version == PNO_TLV_VERSION) &&
(cmd_tlv_temp->subver == PNO_TLV_SUBVERSION)) {
str_ptr += sizeof(cmd_tlv_t);
tlv_size_left -= sizeof(cmd_tlv_t);
if ((nssid = wl_iw_parse_ssid_list_tlv(&str_ptr, ssids_local,
MAX_PFN_LIST_COUNT, &tlv_size_left)) <= 0) {
DBG_871X("SSID is not presented or corrupted ret=%d\n", nssid);
goto exit_proc;
} else {
if ((str_ptr[0] != PNO_TLV_TYPE_TIME) || (tlv_size_left <= 1)) {
DBG_871X("%s scan duration corrupted field size %d\n",
__FUNCTION__, tlv_size_left);
goto exit_proc;
}
str_ptr++;
pno_time = simple_strtoul(str_ptr, &str_ptr, 16);
DHD_INFO(("%s: pno_time=%d\n", __FUNCTION__, pno_time));
if (str_ptr[0] != 0) {
if ((str_ptr[0] != PNO_TLV_FREQ_REPEAT)) {
DBG_871X("%s pno repeat : corrupted field\n",
__FUNCTION__);
goto exit_proc;
}
str_ptr++;
pno_repeat = simple_strtoul(str_ptr, &str_ptr, 16);
DHD_INFO(("%s :got pno_repeat=%d\n", __FUNCTION__, pno_repeat));
if (str_ptr[0] != PNO_TLV_FREQ_EXPO_MAX) {
DBG_871X("%s FREQ_EXPO_MAX corrupted field size\n",
__FUNCTION__);
goto exit_proc;
}
str_ptr++;
pno_freq_expo_max = simple_strtoul(str_ptr, &str_ptr, 16);
DHD_INFO(("%s: pno_freq_expo_max=%d\n",
__FUNCTION__, pno_freq_expo_max));
}
}
} else {
DBG_871X("%s get wrong TLV command\n", __FUNCTION__);
goto exit_proc;
}
res = dhd_dev_pno_set(dev, ssids_local, nssid, pno_time, pno_repeat, pno_freq_expo_max);
exit_proc:
return res;
}
int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong addr, dest, count;
int size;
if (argc != 4) {
cmd_usage(cmdtp);
return 1;
}
/* Check for size specification.
*/
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
return 1;
addr = simple_strtoul(argv[1], NULL, 16);
addr += base_address;
dest = simple_strtoul(argv[2], NULL, 16);
dest += base_address;
count = simple_strtoul(argv[3], NULL, 16);
if (count == 0) {
puts ("Zero length ???\n");
return 1;
}
#ifndef CONFIG_SYS_NO_FLASH
/* check if we are copying to Flash */
if ( (addr2info(dest) != NULL)
#ifdef CONFIG_HAS_DATAFLASH
&& (!addr_dataflash(dest))
#endif
) {
int rc;
puts ("Copy to Flash... ");
rc = flash_write ((char *)addr, dest, count*size);
if (rc != 0) {
flash_perror (rc);
return (1);
}
puts ("done\n");
return 0;
}
#endif
#ifdef CONFIG_HAS_DATAFLASH
/* Check if we are copying from RAM or Flash to DataFlash */
if (addr_dataflash(dest) && !addr_dataflash(addr)){
int rc;
puts ("Copy to DataFlash... ");
rc = write_dataflash (dest, addr, count*size);
if (rc != 1) {
dataflash_perror (rc);
return (1);
}
puts ("done\n");
return 0;
}
/* Check if we are copying from DataFlash to RAM */
if (addr_dataflash(addr) && !addr_dataflash(dest)
#ifndef CONFIG_SYS_NO_FLASH
&& (addr2info(dest) == NULL)
#endif
){
int rc;
rc = read_dataflash(addr, count * size, (char *) dest);
if (rc != 1) {
dataflash_perror (rc);
return (1);
}
return 0;
}
if (addr_dataflash(addr) && addr_dataflash(dest)){
puts ("Unsupported combination of source/destination.\n\r");
return 1;
}
#endif
#ifdef CONFIG_BLACKFIN
/* See if we're copying to/from L1 inst */
if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) {
memcpy((void *)dest, (void *)addr, count * size);
return 0;
}
#endif
while (count-- > 0) {
if (size == 4)
*((ulong *)dest) = *((ulong *)addr);
else if (size == 2)
*((ushort *)dest) = *((ushort *)addr);
else
*((u_char *)dest) = *((u_char *)addr);
addr += size;
dest += size;
}
return 0;
}
static int do_ubi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
size_t size = 0;
ulong addr = 0;
if (argc < 2)
return CMD_RET_USAGE;
if (strcmp(argv[1], "part") == 0) {
const char *vid_header_offset = NULL;
/* Print current partition */
if (argc == 2) {
if (!ubi_dev.selected) {
printf("Error, no UBI device/partition selected!\n");
return 1;
}
printf("Device %d: %s, partition %s\n",
ubi_dev.nr, ubi_dev.mtd_info->name, ubi_dev.part_name);
return 0;
}
if (argc < 3)
return CMD_RET_USAGE;
if (argc > 3)
vid_header_offset = argv[3];
return ubi_part(argv[2], vid_header_offset);
}
if ((strcmp(argv[1], "part") != 0) && (!ubi_dev.selected)) {
printf("Error, no UBI device/partition selected!\n");
return 1;
}
if (strcmp(argv[1], "info") == 0) {
int layout = 0;
if (argc > 2 && !strncmp(argv[2], "l", 1))
layout = 1;
return ubi_info(layout);
}
if (strncmp(argv[1], "create", 6) == 0) {
int dynamic = 1; /* default: dynamic volume */
/* Use maximum available size */
size = 0;
/* E.g., create volume size type */
if (argc == 5) {
if (strncmp(argv[4], "s", 1) == 0)
dynamic = 0;
else if (strncmp(argv[4], "d", 1) != 0) {
printf("Incorrect type\n");
return 1;
}
argc--;
}
/* E.g., create volume size */
if (argc == 4) {
size = simple_strtoul(argv[3], NULL, 16);
argc--;
}
/* Use maximum available size */
if (!size) {
size = ubi->avail_pebs * ubi->leb_size;
printf("No size specified -> Using max size (%u)\n", size);
}
/* E.g., create volume */
if (argc == 3)
return ubi_create_vol(argv[2], size, dynamic);
}
if (strncmp(argv[1], "remove", 6) == 0) {
/* E.g., remove volume */
if (argc == 3)
return ubi_remove_vol(argv[2]);
}
if (strncmp(argv[1], "write", 5) == 0) {
int ret;
if (argc < 5) {
printf("Please see usage\n");
return 1;
}
addr = simple_strtoul(argv[2], NULL, 16);
size = simple_strtoul(argv[4], NULL, 16);
ret = ubi_volume_write(argv[3], (void *)addr, size);
if (!ret) {
printf("%d bytes written to volume %s\n", size,
argv[3]);
}
return ret;
}
if (strncmp(argv[1], "read", 4) == 0) {
size = 0;
/* E.g., read volume size */
if (argc == 5) {
size = simple_strtoul(argv[4], NULL, 16);
argc--;
}
/* E.g., read volume */
if (argc == 4) {
addr = simple_strtoul(argv[2], NULL, 16);
argc--;
}
if (argc == 3) {
printf("Read %d bytes from volume %s to %lx\n", size,
argv[3], addr);
return ubi_volume_read(argv[3], (char *)addr, size);
}
}
printf("Please see usage\n");
return 1;
}
int do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong addr, length, i, data;
int size;
volatile uint *longp;
volatile ushort *shortp;
volatile u_char *cp;
if (argc < 4) {
cmd_usage(cmdtp);
return 1;
}
/* Check for a size spefication.
* Defaults to long if no or incorrect specification.
*/
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
return 1;
/* Address is always specified.
*/
addr = simple_strtoul(argv[1], NULL, 16);
/* Length is the number of objects, not number of bytes.
*/
length = simple_strtoul(argv[2], NULL, 16);
/* data to write */
data = simple_strtoul(argv[3], NULL, 16);
/* We want to optimize the loops to run as fast as possible.
* If we have only one object, just run infinite loops.
*/
if (length == 1) {
if (size == 4) {
longp = (uint *)addr;
for (;;)
*longp = data;
}
if (size == 2) {
shortp = (ushort *)addr;
for (;;)
*shortp = data;
}
cp = (u_char *)addr;
for (;;)
*cp = data;
}
if (size == 4) {
for (;;) {
longp = (uint *)addr;
i = length;
while (i-- > 0)
*longp++ = data;
}
}
if (size == 2) {
for (;;) {
shortp = (ushort *)addr;
i = length;
while (i-- > 0)
*shortp++ = data;
}
}
for (;;) {
cp = (u_char *)addr;
i = length;
while (i-- > 0)
*cp++ = data;
}
}
static void process_dbg_opt(const char *opt)
{
char *buf = dbg_buf + strlen(dbg_buf);
if (0 == strncmp(opt, "regr:", 5))
{
char *p = (char *)opt + 5;
unsigned int addr = (unsigned int) simple_strtoul(p, &p, 16);
if (addr)
{
unsigned int regVal = DISP_REG_GET(addr);
DDP_DRV_INFO("regr: 0x%08X = 0x%08X\n", addr, regVal);
sprintf(buf, "regr: 0x%08X = 0x%08X\n", addr, regVal);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "regw:", 5))
{
char *p = (char *)opt + 5;
unsigned int addr = (unsigned int) simple_strtoul(p, &p, 16);
unsigned int val = (unsigned int) simple_strtoul(p + 1, &p, 16);
if (addr)
{
unsigned int regVal;
DISP_REG_SET(addr, val);
regVal = DISP_REG_GET(addr);
DDP_DRV_DBG("regw: 0x%08X, 0x%08X = 0x%08X\n", addr, val, regVal);
sprintf(buf, "regw: 0x%08X, 0x%08X = 0x%08X\n", addr, val, regVal);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "ddp_drv_dbg_log:", 8))
{
char *p = (char *)opt + 8;
unsigned int enable = (unsigned int) simple_strtoul(p, &p, 10);
if (enable)
ddp_drv_dbg_log = 1;
else
ddp_drv_dbg_log = 0;
sprintf(buf, "ddp_drv_dbg_log: %d\n", ddp_drv_dbg_log);
}
else if (0 == strncmp(opt, "ddp_drv_irq_log:", 8))
{
char *p = (char *)opt + 8;
unsigned int enable = (unsigned int) simple_strtoul(p, &p, 10);
if (enable)
ddp_drv_irq_log = 1;
else
ddp_drv_irq_log = 0;
sprintf(buf, "ddp_drv_irq_log: %d\n", ddp_drv_irq_log);
}
else if (0 == strncmp(opt, "backlight:", 10))
{
char *p = (char *)opt + 10;
unsigned int level = (unsigned int) simple_strtoul(p, &p, 10);
if (level)
{
disp_bls_set_backlight(level);
sprintf(buf, "backlight: %d\n", level);
} else {
goto Error;
}
}
else if (0 == strncmp(opt, "dump_reg:", 9))
{
char *p = (char *)opt + 9;
unsigned int module = (unsigned int) simple_strtoul(p, &p, 10);
DDP_DRV_INFO("process_dbg_opt, module=%d \n", module);
if (module<DISP_MODULE_MAX)
{
disp_dump_reg(module);
sprintf(buf, "dump_reg: %d\n", module);
} else {
DDP_DRV_INFO("process_dbg_opt2, module=%d \n", module);
goto Error;
}
}
else if (0 == strncmp(opt, "dump_aal:", 9))
{
char *p = (char *)opt + 9;
unsigned int arg = (unsigned int) simple_strtoul(p, &p, 10);
if (arg == 0)
{
int i;
unsigned int hist[LUMA_HIST_BIN];
disp_get_hist(hist);
for (i = 0; i < LUMA_HIST_BIN; i++)
{
DDP_DRV_DBG("LUMA_HIST_%02d: %d\n", i, hist[i]);
sprintf(dbg_buf + strlen(dbg_buf), "LUMA_HIST_%2d: %d\n", i, hist[i]);
}
}
else if (arg == 1)
{
int i;
DISP_AAL_PARAM param;
GetUpdateMutex();
memcpy(¶m, get_aal_config(), sizeof(DISP_AAL_PARAM));
ReleaseUpdateMutex();
DDP_DRV_DBG("pwmDuty: %lu\n", param.pwmDuty);
sprintf(dbg_buf + strlen(dbg_buf), "pwmDuty: %lu\n", param.pwmDuty);
for (i = 0; i < LUMA_CURVE_POINT; i++)
{
DDP_DRV_DBG("lumaCurve[%02d]: %lu\n", i, param.lumaCurve[i]);
sprintf(dbg_buf + strlen(dbg_buf), "lumaCurve[%02d]: %lu\n", i, param.lumaCurve[i]);
}
}
}
else if (0 == strncmp(opt, "debug:", 6))
{
char *p = (char *)opt + 6;
unsigned int enable = (unsigned int) simple_strtoul(p, &p, 10);
if(enable==1)
{
printk("[DDP] debug=1, trigger AEE\n");
aee_kernel_exception("DDP-TEST-ASSERT", "[DDP] DDP-TEST-ASSERT");
}
else if(enable==2)
{
ddp_mem_test();
}
else if(enable==3)
{
ddp_mem_test2();
}
}
else if (0 == strncmp(opt, "mmp", 3))
{
init_ddp_mmp_events();
}
else if (0 == strncmp(opt, "dpfd_ut1:", 9))
{
char *p = (char *)opt + 9;
unsigned int channel = (unsigned int) simple_strtoul(p, &p, 10);
//ddpk_testfunc_1(channel);
}
else if (0 == strncmp(opt, "dpfd_ut2:", 9))
{
char *p = (char *)opt + 9;
unsigned int channel = (unsigned int) simple_strtoul(p, &p, 10);
//ddpk_testfunc_2(channel);
}
else if (0 == strncmp(opt, "dpfd:log", 8))
{
}
else if (0 == strncmp(opt, "pqon", 4))
{
pq_debug_flag=0;
sprintf(buf, "Turn on PQ %d\n", pq_debug_flag);
}
else if (0 == strncmp(opt, "pqoff", 5))
{
pq_debug_flag=1;
sprintf(buf, "Turn off PQ %d\n", pq_debug_flag);
}
else if (0 == strncmp(opt, "pqdemo", 6))
{
pq_debug_flag=2;
sprintf(buf, "Turn on PQ (demo) %d\n", pq_debug_flag);
}
else if (0 == strncmp(opt, "pqstop", 6))
{
pq_debug_flag=3;
sprintf(buf, "Stop mutex update %d\n", pq_debug_flag);
}
else if (0 == strncmp(opt, "aalon", 5))
{
aal_debug_flag=0;
sprintf(buf, "resume aal update %d\n", aal_debug_flag);
}
else if (0 == strncmp(opt, "aaloff", 6))
{
aal_debug_flag=1;
sprintf(buf, "suspend aal update %d\n", aal_debug_flag);
}
else if (0 == strncmp(opt, "color_win:", 10))
{
char *p = (char *)opt + 10;
unsigned int sat_upper, sat_lower, hue_upper, hue_lower;
sat_upper = (unsigned int) simple_strtoul(p, &p, 10);
p++;
sat_lower = (unsigned int) simple_strtoul(p, &p, 10);
p++;
hue_upper = (unsigned int) simple_strtoul(p, &p, 10);
p++;
hue_lower = (unsigned int) simple_strtoul(p, &p, 10);
DDP_DRV_INFO("Set color_win: %u, %u, %u, %u\n", sat_upper, sat_lower, hue_upper, hue_lower);
disp_color_set_window(sat_upper, sat_lower, hue_upper, hue_lower);
}
else
{
goto Error;
}
return;
Error:
DDP_DRV_ERR("parse command error!\n%s\n\n%s", opt, STR_HELP);
}
int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong addr, length;
#if defined(CONFIG_HAS_DATAFLASH)
ulong nbytes, linebytes;
#endif
int size;
int rc = 0;
/* We use the last specified parameters, unless new ones are
* entered.
*/
addr = dp_last_addr;
size = dp_last_size;
length = dp_last_length;
if (argc < 2) {
cmd_usage(cmdtp);
return 1;
}
if ((flag & CMD_FLAG_REPEAT) == 0) {
/* New command specified. Check for a size specification.
* Defaults to long if no or incorrect specification.
*/
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
return 1;
/* Address is specified since argc > 1
*/
addr = simple_strtoul(argv[1], NULL, 16);
addr += base_address;
/* If another parameter, it is the length to display.
* Length is the number of objects, not number of bytes.
*/
if (argc > 2)
length = simple_strtoul(argv[2], NULL, 16);
}
#if defined(CONFIG_HAS_DATAFLASH)
/* Print the lines.
*
* We buffer all read data, so we can make sure data is read only
* once, and all accesses are with the specified bus width.
*/
nbytes = length * size;
do {
char linebuf[DISP_LINE_LEN];
void* p;
linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;
rc = read_dataflash(addr, (linebytes/size)*size, linebuf);
p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr;
print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size);
nbytes -= linebytes;
addr += linebytes;
if (ctrlc()) {
rc = 1;
break;
}
} while (nbytes > 0);
#else
# if defined(CONFIG_BLACKFIN)
/* See if we're trying to display L1 inst */
if (addr_bfin_on_chip_mem(addr)) {
char linebuf[DISP_LINE_LEN];
ulong linebytes, nbytes = length * size;
do {
linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
memcpy(linebuf, (void *)addr, linebytes);
print_buffer(addr, linebuf, size, linebytes/size, DISP_LINE_LEN/size);
nbytes -= linebytes;
addr += linebytes;
if (ctrlc()) {
rc = 1;
break;
}
} while (nbytes > 0);
} else
# endif
{
/* Print the lines. */
print_buffer(addr, (void*)addr, size, length, DISP_LINE_LEN/size);
addr += size*length;
}
#endif
dp_last_addr = addr;
dp_last_length = length;
dp_last_size = size;
return (rc);
}
dev_t name_to_dev_t(char *name)
{
char s[32];
char *p;
dev_t res = 0;
int part;
#ifdef CONFIG_BLOCK
if (strncmp(name, "PARTUUID=", 9) == 0) {
name += 9;
if (strlen(name) != 36)
goto fail;
res = devt_from_partuuid(name);
if (!res)
goto fail;
goto done;
}
#endif
if (strncmp(name, "/dev/", 5) != 0) {
unsigned maj, min;
if (sscanf(name, "%u:%u", &maj, &min) == 2) {
res = MKDEV(maj, min);
if (maj != MAJOR(res) || min != MINOR(res))
goto fail;
} else {
res = new_decode_dev(simple_strtoul(name, &p, 16));
if (*p)
goto fail;
}
goto done;
}
name += 5;
res = Root_NFS;
if (strcmp(name, "nfs") == 0)
goto done;
res = Root_RAM0;
if (strcmp(name, "ram") == 0)
goto done;
if (strlen(name) > 31)
goto fail;
strcpy(s, name);
for (p = s; *p; p++)
if (*p == '/')
*p = '!';
res = blk_lookup_devt(s, 0);
if (res)
goto done;
/*
* try non-existent, but valid partition, which may only exist
* after revalidating the disk, like partitioned md devices
*/
while (p > s && isdigit(p[-1]))
p--;
if (p == s || !*p || *p == '0')
goto fail;
/* try disk name without <part number> */
part = simple_strtoul(p, NULL, 10);
*p = '\0';
res = blk_lookup_devt(s, part);
if (res)
goto done;
/* try disk name without p<part number> */
if (p < s + 2 || !isdigit(p[-2]) || p[-1] != 'p')
goto fail;
p[-1] = '\0';
res = blk_lookup_devt(s, part);
if (res)
goto done;
fail:
return 0;
done:
return res;
}
/*
* Perform a memory test. A more complete alternative test can be
* configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
* interrupted by ctrl-c or by a failure of one of the sub-tests.
*/
int do_mem_mtest (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
vu_long *addr, *start, *end;
ulong val;
ulong readback;
int rcode = 0;
int iterations = 1;
int iteration_limit;
#if defined(CONFIG_SYS_ALT_MEMTEST)
vu_long len;
vu_long offset;
vu_long test_offset;
vu_long pattern;
vu_long temp;
vu_long anti_pattern;
vu_long num_words;
#if defined(CONFIG_SYS_MEMTEST_SCRATCH)
vu_long *dummy = (vu_long*)CONFIG_SYS_MEMTEST_SCRATCH;
#else
vu_long *dummy = 0; /* yes, this is address 0x0, not NULL */
#endif
int j;
static const ulong bitpattern[] = {
0x00000001, /* single bit */
0x00000003, /* two adjacent bits */
0x00000007, /* three adjacent bits */
0x0000000F, /* four adjacent bits */
0x00000005, /* two non-adjacent bits */
0x00000015, /* three non-adjacent bits */
0x00000055, /* four non-adjacent bits */
0xaaaaaaaa, /* alternating 1/0 */
};
#else
ulong incr;
ulong pattern;
#endif
if (argc > 1)
start = (ulong *)simple_strtoul(argv[1], NULL, 16);
else
start = (ulong *)CONFIG_SYS_MEMTEST_START;
if (argc > 2)
end = (ulong *)simple_strtoul(argv[2], NULL, 16);
else
end = (ulong *)(CONFIG_SYS_MEMTEST_END);
if (argc > 3)
pattern = (ulong)simple_strtoul(argv[3], NULL, 16);
else
pattern = 0;
if (argc > 4)
iteration_limit = (ulong)simple_strtoul(argv[4], NULL, 16);
else
iteration_limit = 0;
#if defined(CONFIG_SYS_ALT_MEMTEST)
printf ("Testing %08x ... %08x:\n", (uint)start, (uint)end);
PRINTF("%s:%d: start 0x%p end 0x%p\n",
__FUNCTION__, __LINE__, start, end);
for (;;) {
if (ctrlc()) {
putc ('\n');
return 1;
}
if (iteration_limit && iterations > iteration_limit) {
printf("Tested %d iteration(s) without errors.\n",
iterations-1);
return 0;
}
printf("Iteration: %6d\r", iterations);
PRINTF("\n");
iterations++;
/*
* Data line test: write a pattern to the first
* location, write the 1's complement to a 'parking'
* address (changes the state of the data bus so a
* floating bus doen't give a false OK), and then
* read the value back. Note that we read it back
* into a variable because the next time we read it,
* it might be right (been there, tough to explain to
* the quality guys why it prints a failure when the
* "is" and "should be" are obviously the same in the
* error message).
*
* Rather than exhaustively testing, we test some
* patterns by shifting '1' bits through a field of
* '0's and '0' bits through a field of '1's (i.e.
* pattern and ~pattern).
*/
addr = start;
for (j = 0; j < sizeof(bitpattern)/sizeof(bitpattern[0]); j++) {
val = bitpattern[j];
for(; val != 0; val <<= 1) {
*addr = val;
*dummy = ~val; /* clear the test data off of the bus */
readback = *addr;
if(readback != val) {
printf ("FAILURE (data line): "
"expected %08lx, actual %08lx\n",
val, readback);
}
*addr = ~val;
*dummy = val;
readback = *addr;
if(readback != ~val) {
printf ("FAILURE (data line): "
"Is %08lx, should be %08lx\n",
readback, ~val);
}
}
}
/*
* Based on code whose Original Author and Copyright
* information follows: Copyright (c) 1998 by Michael
* Barr. This software is placed into the public
* domain and may be used for any purpose. However,
* this notice must not be changed or removed and no
* warranty is either expressed or implied by its
* publication or distribution.
*/
/*
* Address line test
*
* Description: Test the address bus wiring in a
* memory region by performing a walking
* 1's test on the relevant bits of the
* address and checking for aliasing.
* This test will find single-bit
* address failures such as stuck -high,
* stuck-low, and shorted pins. The base
* address and size of the region are
* selected by the caller.
*
* Notes: For best results, the selected base
* address should have enough LSB 0's to
* guarantee single address bit changes.
* For example, to test a 64-Kbyte
* region, select a base address on a
* 64-Kbyte boundary. Also, select the
* region size as a power-of-two if at
* all possible.
*
* Returns: 0 if the test succeeds, 1 if the test fails.
*/
len = ((ulong)end - (ulong)start)/sizeof(vu_long);
pattern = (vu_long) 0xaaaaaaaa;
anti_pattern = (vu_long) 0x55555555;
PRINTF("%s:%d: length = 0x%.8lx\n",
__FUNCTION__, __LINE__,
len);
/*
* Write the default pattern at each of the
* power-of-two offsets.
*/
for (offset = 1; offset < len; offset <<= 1) {
start[offset] = pattern;
}
/*
* Check for address bits stuck high.
*/
test_offset = 0;
start[test_offset] = anti_pattern;
for (offset = 1; offset < len; offset <<= 1) {
temp = start[offset];
if (temp != pattern) {
printf ("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx\n",
(ulong)&start[offset], pattern, temp);
return 1;
}
}
start[test_offset] = pattern;
WATCHDOG_RESET();
/*
* Check for addr bits stuck low or shorted.
*/
for (test_offset = 1; test_offset < len; test_offset <<= 1) {
start[test_offset] = anti_pattern;
for (offset = 1; offset < len; offset <<= 1) {
temp = start[offset];
if ((temp != pattern) && (offset != test_offset)) {
printf ("\nFAILURE: Address bit stuck low or shorted @"
" 0x%.8lx: expected 0x%.8lx, actual 0x%.8lx\n",
(ulong)&start[offset], pattern, temp);
return 1;
}
}
start[test_offset] = pattern;
}
/*
* Description: Test the integrity of a physical
* memory device by performing an
* increment/decrement test over the
* entire region. In the process every
* storage bit in the device is tested
* as a zero and a one. The base address
* and the size of the region are
* selected by the caller.
*
* Returns: 0 if the test succeeds, 1 if the test fails.
*/
num_words = ((ulong)end - (ulong)start)/sizeof(vu_long) + 1;
/*
* Fill memory with a known pattern.
*/
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET();
start[offset] = pattern;
}
/*
* Check each location and invert it for the second pass.
*/
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET();
temp = start[offset];
if (temp != pattern) {
printf ("\nFAILURE (read/write) @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx)\n",
(ulong)&start[offset], pattern, temp);
return 1;
}
anti_pattern = ~pattern;
start[offset] = anti_pattern;
}
/*
* Check each location for the inverted pattern and zero it.
*/
for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
WATCHDOG_RESET();
anti_pattern = ~pattern;
temp = start[offset];
if (temp != anti_pattern) {
printf ("\nFAILURE (read/write): @ 0x%.8lx:"
" expected 0x%.8lx, actual 0x%.8lx)\n",
(ulong)&start[offset], anti_pattern, temp);
return 1;
}
start[offset] = 0;
}
}
#else /* The original, quickie test */
incr = 1;
for (;;) {
if (ctrlc()) {
putc ('\n');
return 1;
}
if (iteration_limit && iterations > iteration_limit) {
printf("Tested %d iteration(s) without errors.\n",
iterations-1);
return 0;
}
++iterations;
printf ("\rPattern %08lX Writing..."
"%12s"
"\b\b\b\b\b\b\b\b\b\b",
pattern, "");
for (addr=start,val=pattern; addr<end; addr++) {
WATCHDOG_RESET();
*addr = val;
val += incr;
}
puts ("Reading...");
for (addr=start,val=pattern; addr<end; addr++) {
WATCHDOG_RESET();
readback = *addr;
if (readback != val) {
printf ("\nMem error @ 0x%08X: "
"found %08lX, expected %08lX\n",
(uint)addr, readback, val);
rcode = 1;
}
val += incr;
}
/*
* Flip the pattern each time to make lots of zeros and
* then, the next time, lots of ones. We decrement
* the "negative" patterns and increment the "positive"
* patterns to preserve this feature.
*/
if(pattern & 0x80000000) {
pattern = -pattern; /* complement & increment */
}
else {
pattern = ~pattern;
}
incr = -incr;
}
#endif
return rcode;
}
/* TODO: Can we tighten this code up a little? */
int fdtdec_add_aliases_for_id(const void *blob, const char *name,
enum fdt_compat_id id, int *node_list, int maxcount)
{
int name_len = strlen(name);
int nodes[maxcount];
int num_found = 0;
int offset, node;
int alias_node;
int count;
int i, j;
/* find the alias node if present */
alias_node = fdt_path_offset(blob, "/aliases");
/*
* start with nothing, and we can assume that the root node can't
* match
*/
memset(nodes, '\0', sizeof(nodes));
/* First find all the compatible nodes */
for (node = count = 0; node >= 0 && count < maxcount;) {
node = fdtdec_next_compatible(blob, node, id);
if (node >= 0)
nodes[count++] = node;
}
if (node >= 0)
debug("%s: warning: maxcount exceeded with alias '%s'\n",
__func__, name);
/* Now find all the aliases */
for (offset = fdt_first_property_offset(blob, alias_node);
offset > 0;
offset = fdt_next_property_offset(blob, offset)) {
const struct fdt_property *prop;
const char *path;
int number;
int found;
node = 0;
prop = fdt_get_property_by_offset(blob, offset, NULL);
path = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
if (prop->len && 0 == strncmp(path, name, name_len))
node = fdt_path_offset(blob, prop->data);
if (node <= 0)
continue;
/* Get the alias number */
number = simple_strtoul(path + name_len, NULL, 10);
if (number < 0 || number >= maxcount) {
debug("%s: warning: alias '%s' is out of range\n",
__func__, path);
continue;
}
/* Make sure the node we found is actually in our list! */
found = -1;
for (j = 0; j < count; j++)
if (nodes[j] == node) {
found = j;
break;
}
if (found == -1) {
debug("%s: warning: alias '%s' points to a node "
"'%s' that is missing or is not compatible "
" with '%s'\n", __func__, path,
fdt_get_name(blob, node, NULL),
compat_names[id]);
continue;
}
/*
* Add this node to our list in the right place, and mark
* it as done.
*/
if (fdtdec_get_is_enabled(blob, node)) {
if (node_list[number]) {
debug("%s: warning: alias '%s' requires that "
"a node be placed in the list in a "
"position which is already filled by "
"node '%s'\n", __func__, path,
fdt_get_name(blob, node, NULL));
continue;
}
node_list[number] = node;
if (number >= num_found)
num_found = number + 1;
}
nodes[found] = 0;
}
/* Add any nodes not mentioned by an alias */
for (i = j = 0; i < maxcount; i++) {
if (!node_list[i]) {
for (; j < maxcount; j++)
if (nodes[j] &&
fdtdec_get_is_enabled(blob, nodes[j]))
break;
/* Have we run out of nodes to add? */
if (j == maxcount)
break;
assert(!node_list[i]);
node_list[i] = nodes[j++];
if (i >= num_found)
num_found = i + 1;
}
}
return num_found;
}
u32 MDrv_EMAC_VarInit(void)
{
u32 alloRAM_ADDR_BASE;
int i;
char *s, *e;
alloRAM_ADDR_BASE = ((u32)emac_var & 0x1fffffff) | BUS_MIU0_BASE_NONCACHE; //transfer to non-cachable
memset((u32 *)alloRAM_ADDR_BASE,0x00,EMAC_ABSO_MEM_SIZE);
Chip_Flush_Memory();
EMAC_MEM_BASE = (alloRAM_ADDR_BASE + 0x3FFF) & ~0x3FFF; // IMPORTANT: Let lowest 14 bits as zero.
RAM_ADDR_BASE = BUS_MIU0_BASE_NONCACHE;
printf("EMAC Mem Base:%x\n", EMAC_MEM_BASE);
RX_BUFFER_BASE = EMAC_MEM_BASE - RAM_ADDR_BASE;
RBQP_BASE = RX_BUFFER_BASE + RX_BUFFER_SIZE;
if ((RBQP_BASE + RBQP_SIZE+ EMAC_MEM_GAP) > (alloRAM_ADDR_BASE + EMAC_ABSO_MEM_SIZE))
{
printf("MMAP overflow: %x > %x\n", (RBQP_BASE + RBQP_SIZE+ EMAC_MEM_GAP), (alloRAM_ADDR_BASE + EMAC_ABSO_MEM_SIZE));
return 0;
}
printf("Rx buff:%x\nRBQP:%x\n", RX_BUFFER_BASE, RBQP_BASE);
memset(&ThisBCE,0x00,sizeof(BasicConfigEMAC));
memset(&ThisUVE,0x00,sizeof(UtilityVarsEMAC));
ThisBCE.wes = 0; // 0:Disable, 1:Enable (WR_ENABLE_STATISTICS_REGS)
ThisBCE.duplex = 2; // 1:Half-duplex, 2:Full-duplex
ThisBCE.cam = 0; // 0:No CAM, 1:Yes
ThisBCE.rcv_bcast = 0; // 0:No, 1:Yes
ThisBCE.rlf = 0; // 0:No, 1:Yes receive long frame(1522)
ThisBCE.rcv_bcast = 1;
ThisBCE.speed = EMAC_SPEED_100;
s = getenv ("ethaddr");
if (s)
{
for (i = 0; i < 6; ++i)
{
ThisBCE.sa1[i] = s ? simple_strtoul (s, &e, 16) : 0;
if (s)
{
s = (*e) ? e + 1 : e;
}
}
}
else
{
ThisBCE.sa1[0] = MY_MAC[0];
ThisBCE.sa1[1] = MY_MAC[1];
ThisBCE.sa1[2] = MY_MAC[2];
ThisBCE.sa1[3] = MY_MAC[3];
ThisBCE.sa1[4] = MY_MAC[4];
ThisBCE.sa1[5] = MY_MAC[5];
}
ThisBCE.loopback = 0;
//if (!((u32)packet_data% 4))
// packet +=2;
printf("Packet buffer:%lx\n", (long unsigned int)packet);
return alloRAM_ADDR_BASE;
}
