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; }