Beispiel #1
0
static void
fis_delete(int argc, char *argv[])
{
    char *name;
    int num_reserved, i, stat;
    void *err_addr;
    struct fis_image_desc *img;

    if (!scan_opts(argc, argv, 2, 0, 0, (void *)&name, OPTION_ARG_TYPE_STR, "image name"))
    {
        fis_usage("invalid arguments");
        return;
    }
#ifdef CYGHWR_REDBOOT_ARM_FLASH_SIB
    // FIXME: this is somewhat half-baked
    arm_fis_delete(name);
    return;
#endif
    img = (struct fis_image_desc *)fis_work_block;
    num_reserved = 0;
#ifdef CYGOPT_REDBOOT_FIS_RESERVED_BASE
    num_reserved++;
#endif
#ifdef CYGOPT_REDBOOT_FIS_REDBOOT
    num_reserved++;
#endif
#ifdef CYGOPT_REDBOOT_FIS_REDBOOT_BACKUP
    num_reserved++;
#endif
#ifdef CYGOPT_REDBOOT_FIS_REDBOOT_POST
    num_reserved++;
#endif
#if defined(CYGSEM_REDBOOT_FLASH_CONFIG) && defined(CYGHWR_REDBOOT_FLASH_CONFIG_MEDIA_FLASH)
    num_reserved++;
#endif
#if 1 // And the descriptor for the descriptor table itself
    num_reserved++;
#endif

    img = fis_lookup(name, &i);
    if (img) {
        if (i < num_reserved) {
            diag_printf("Sorry, '%s' is a reserved image and cannot be deleted\n", img->name);
            return;
        }
        if (!verify_action("Delete image '%s'", name)) {
            return;
        }
    } else {
        diag_printf("No image '%s' found\n", name);
        return;
    }
    // Erase Data blocks (free space)
    if ((stat = flash_erase((void *)img->flash_base, img->size, (void **)&err_addr)) != 0) {
        diag_printf("Error erasing at %p: %s\n", err_addr, flash_errmsg(stat));
    } else {
        img->name[0] = (unsigned char)0xFF;    
        fis_update_directory();
    }
}
Beispiel #2
0
static void
do_delay(int argc,
         char *argv[])
{
  struct option_info opts[1];
  int count = 0x00000000;
  bool count_set;
  int value;
  register int i;

  init_opts(&opts[0], 'c', true, OPTION_ARG_TYPE_NUM,
            (void**)&count, &count_set, "Number of times to delay");

  if (!scan_opts(argc, argv,
                 1,
                 opts, sizeof(opts) / sizeof(opts[0]),
                 (void*)&value, OPTION_ARG_TYPE_NUM, "amount of time to delay (usec)")) {
    return;
  }

  if (!count_set) {
    count = 1;
  }
  for (i = 0; i < count; i++) {
    diag_printf("Delaying %d useconds...", value);
    HAL_DELAY_US(value);
    diag_printf("Done\n");
  }
}
Beispiel #3
0
static void
do_gpio(int argc,char *argv[]) {
    struct option_info opts[2];
    bool set_bits_set, clr_bits_set;
    int set_bits, clr_bits;
    init_opts(&opts[0], 's', true, OPTION_ARG_TYPE_NUM, 
              (void **)&set_bits, (bool *)&set_bits_set, "bits to set");
    init_opts(&opts[1], 'c', true, OPTION_ARG_TYPE_NUM, 
              (void **)&clr_bits, (bool *)&clr_bits_set, "bits to clear");
    if (!scan_opts(argc, argv, 1, opts, 2, NULL, 0, NULL))
    {
        return;
    }
    if ( !set_bits_set && !clr_bits_set ) {
	// display only
	diag_printf("  gpio = 0x%08lX\n", *SA11X0_GPIO_PIN_LEVEL);
	diag_printf("         0x%08lX are output\n", *SA11X0_GPIO_PIN_DIRECTION);
	diag_printf("         0x%08lX rising edge detect\n", *SA11X0_GPIO_RISING_EDGE_DETECT);
	diag_printf("         0x%08lX falling edge detect\n", *SA11X0_GPIO_FALLING_EDGE_DETECT);
	diag_printf("         0x%08lX edge detect status\n", *SA11X0_GPIO_EDGE_DETECT_STATUS);
	diag_printf("         0x%08lX alternate function\n", *SA11X0_GPIO_ALTERNATE_FUNCTION);
	return;
    }
    diag_printf( "  gpio 0x%08lX, ", *SA11X0_GPIO_PIN_LEVEL);
    if ( set_bits_set ) {
	diag_printf("set(0x%08X) ",set_bits);
	*SA11X0_GPIO_PIN_OUTPUT_SET = set_bits;
    }
    if ( clr_bits_set ) {
	diag_printf("clear(0x%08X) ",clr_bits);
	*SA11X0_GPIO_PIN_OUTPUT_CLEAR = clr_bits;
    }
    diag_printf( "gives 0x%08lX\n", *SA11X0_GPIO_PIN_LEVEL);
}
Beispiel #4
0
void
do_cksum(int argc, char *argv[])
{
    struct option_info opts[2];
    unsigned long base, len, crc;
    bool base_set, len_set;

    init_opts(&opts[0], 'b', true, OPTION_ARG_TYPE_NUM, 
              (void *)&base, (bool *)&base_set, "base address");
    init_opts(&opts[1], 'l', true, OPTION_ARG_TYPE_NUM, 
              (void *)&len, (bool *)&len_set, "length");
    if (!scan_opts(argc, argv, 1, opts, 2, 0, 0, "")) {
        return;
    }
    if (!base_set || !len_set) {
	if (load_address >= (CYG_ADDRESS)ram_start &&
	    load_address_end < (CYG_ADDRESS)ram_end &&
	    load_address < load_address_end) {
	    base = load_address;
	    len = load_address_end - load_address;
            diag_printf("Computing cksum for area %lx-%lx\n",
                        base, load_address_end);
	} else {
	    diag_printf("usage: cksum -b <addr> -l <length>\n");
	    return;
	}
    }
    crc = cyg_posix_crc32((unsigned char *)base, len);
    diag_printf("POSIX cksum = %lu %lu (0x%08lx 0x%08lx)\n", crc, len, crc, len);
}
Beispiel #5
0
static void
do_mem(int argc, char *argv[]) {
    struct option_info opts[3];
    bool mem_half_word, mem_byte;
    static int address = 0x00000000;
    int value;
    init_opts(&opts[0], 'b', false, OPTION_ARG_TYPE_FLG,
	      (void**)&mem_byte, 0, "write a byte");
    init_opts(&opts[1], 'h', false, OPTION_ARG_TYPE_FLG,
	      (void**)&mem_half_word, 0, "write a half-word");
    init_opts(&opts[2], 'a', true, OPTION_ARG_TYPE_NUM,
	      (void**)&address, NULL, "address to write at");
    if (!scan_opts(argc, argv, 1, opts, 3, (void*)&value, OPTION_ARG_TYPE_NUM, "address to set"))
	return;
    if ( mem_byte && mem_half_word ) {
	diag_printf("*ERR: Should not specify both byte and half-word access\n");
    } else if ( mem_byte ) {
	*(cyg_uint8*)address = (cyg_uint8)(value & 255);
	diag_printf("  Set 0x%08X to 0x%02X (result 0x%02X)\n", address, value & 255, (int)*(cyg_uint8*)address );
    } else if ( mem_half_word ) {
	if ( address & 1 ) {
	    diag_printf( "*ERR: Badly aligned address 0x%08X for half-word store\n", address );
	} else {
	    *(cyg_uint16*)address = (cyg_uint16)(value & 0xffff);
	    diag_printf("  Set 0x%08X to 0x%04X (result 0x%04X)\n", address, value & 0xffff, (int)*(cyg_uint16*)address );
	}
    } else {
	if ( address & 3 ) {
	    diag_printf( "*ERR: Badly aligned address 0x%08X for word store\n", address );
	} else {
	    *(cyg_uint32*)address = (cyg_uint32)value;
	    diag_printf("  Set 0x%08X to 0x%08X (result 0x%08X)\n", address, value, (int)*(cyg_uint32*)address );
	}
    }
}
Beispiel #6
0
static void
do_egpio(int argc,char *argv[]) {
    struct option_info opts[2];
    bool set_bits_set, clr_bits_set;
    int set_bits, clr_bits;
    init_opts(&opts[0], 's', true, OPTION_ARG_TYPE_NUM, 
              (void **)&set_bits, (bool *)&set_bits_set, "bits to set");
    init_opts(&opts[1], 'c', true, OPTION_ARG_TYPE_NUM, 
              (void **)&clr_bits, (bool *)&clr_bits_set, "bits to clear");
    if (!scan_opts(argc, argv, 1, opts, 2, NULL, 0, NULL)) return;
    if ( !set_bits_set && !clr_bits_set ) {
	// display only
	diag_printf("  egpio = 0x%04X\n", (int)(_ipaq_EGPIO & 0xffff));
	return;
    }
    diag_printf( "  egpio 0x%04X, ", (int)(_ipaq_EGPIO & 0xffff));
    if ( set_bits_set ) {
	diag_printf("set(0x%08X) ",set_bits);
	ipaq_EGPIO( set_bits, set_bits );
    }
    if ( clr_bits_set ) {
	diag_printf("clear(0x%08X) ",clr_bits);
	ipaq_EGPIO( clr_bits, 0x0000 );
    }
    diag_printf( "gives 0x%04X\n", (int)(_ipaq_EGPIO & 0xffff));
}
Beispiel #7
0
static void 
do_exec(int argc, char *argv[])
{
    unsigned long oldints;
    bool wait_time_set;
    int  wait_time, res;
    bool cmd_line_set;
    struct option_info opts[4];
    code_fun entry;
    char line[8];
    char *cmd_line;
    int num_options;

    entry = (code_fun)entry_address;  // Default from last 'load' operation
    init_opts(&opts[0], 'w', true, OPTION_ARG_TYPE_NUM, 
              (void **)&wait_time, (bool *)&wait_time_set, "wait timeout");
    init_opts(&opts[1], 'c', true, OPTION_ARG_TYPE_STR, 
              (void **)&cmd_line, (bool *)&cmd_line_set, "kernel command line");
    num_options = 2;

    if (!scan_opts(argc, argv, 1, opts, num_options, (void *)&entry, 
                   OPTION_ARG_TYPE_NUM, "starting address"))
    {
        return;
    }
    if (entry == (unsigned long)NO_MEMORY) {
        diag_printf("Can't execute Linux - invalid entry address\n");
        return;
    }
    if (cmd_line_set) {
	memcpy((char*)CYGHWR_REDBOOT_AM33_LINUX_CMD_ADDRESS,"cmdline:",8);
        strncpy((char*)CYGHWR_REDBOOT_AM33_LINUX_CMD_ADDRESS+8,cmd_line,256);
	*(char*)(CYGHWR_REDBOOT_AM33_LINUX_CMD_ADDRESS+8+256) = 0;
    }
    else {
	*(char*)(CYGHWR_REDBOOT_AM33_LINUX_CMD_ADDRESS+256) = 0;
    }

    if (wait_time_set) {
        diag_printf("About to start execution at %p - abort with ^C within %d seconds\n",
                    (void *)entry, wait_time);
        res = _rb_gets(line, sizeof(line), wait_time*1000);
        if (res == _GETS_CTRLC) {
            return;
        }
    }

#ifdef CYGPKG_IO_ETH_DRIVERS
    eth_drv_stop();
#endif

    HAL_DISABLE_INTERRUPTS(oldints);
    HAL_DCACHE_SYNC();
    HAL_ICACHE_DISABLE();
    HAL_DCACHE_DISABLE();
    HAL_DCACHE_SYNC();
    HAL_ICACHE_INVALIDATE_ALL();
    HAL_DCACHE_INVALIDATE_ALL();
    (*entry)();
}
Beispiel #8
0
void
do_baud_rate(int argc, char *argv[])
{
    int new_rate, ret, old_rate;
    bool new_rate_set;
    hal_virtual_comm_table_t *__chan;
    struct option_info opts[1];
#ifdef CYGSEM_REDBOOT_FLASH_CONFIG
    struct config_option opt;
#endif

    init_opts(&opts[0], 'b', true, OPTION_ARG_TYPE_NUM, 
              (void **)&new_rate, (bool *)&new_rate_set, "new baud rate");
    if (!scan_opts(argc, argv, 1, opts, 1, 0, 0, "")) {
        return;
    }
    __chan = CYGACC_CALL_IF_CONSOLE_PROCS();
    if (new_rate_set) {
        diag_printf("Baud rate will be changed to %d - update your settings\n", new_rate);
        _sleep(500);  // Give serial time to flush
        old_rate = CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_GETBAUD);
        ret = set_console_baud_rate(new_rate);
        if (ret < 0) {
            if (old_rate > 0) {
                // Try to restore
                set_console_baud_rate(old_rate);
                _sleep(500);  // Give serial time to flush
                diag_printf("\nret = %d\n", ret);
            }
            return;  // Couldn't set the desired rate
        }
        old_rate = ret;
        // Make sure this new rate works or back off to previous value
        // Sleep for a few seconds, then prompt to see if it works
        _sleep(3000);  // Give serial time to flush
        if (!verify_action_with_timeout(5000, "Baud rate changed to %d", new_rate)) {
            _sleep(500);  // Give serial time to flush
            set_console_baud_rate(old_rate);
            _sleep(500);  // Give serial time to flush
            return;
        }
#ifdef CYGSEM_REDBOOT_FLASH_CONFIG
        opt.type = CONFIG_INT;
        opt.enable = (char *)0;
        opt.enable_sense = 1;
        opt.key = "console_baud_rate";
        opt.dflt = new_rate;
        flash_add_config(&opt, true);
#endif
    } else {
        ret = CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_GETBAUD);
        diag_printf("Baud rate = ");
        if (ret <= 0) {
            diag_printf("unknown\n");
        } else {
            diag_printf("%d\n", ret);
        }
    }
}
Beispiel #9
0
////
// main
//
int main (int argc, char **argv) {
   // Creat a struct for the options.
   struct options options =
      {FALSE, FALSE, NULL, FALSE, NULL, FALSE, NULL};
   set_execname (argv[0]); // Set the execution name.
   // Get the options from the command line.
   scan_opts (argc, argv, &options);

   //
   char buffer[256];
   bzero (buffer, 256);
   int sockfd, n;
   int portno = 1337; // Default server port number 1337
   struct sockaddr_in serv_addr;
   struct hostent *server;

   // SOCKET
   sockfd = socket (AF_INET, SOCK_STREAM, 0);
   if (sockfd < 0) error ("opening socket");
   // GETHOSTBYNAME
   server = gethostbyname (options.serverIP);
   if (server == NULL) error ("no such host");
   bzero ((char *) &serv_addr, sizeof (serv_addr));
   serv_addr.sin_family = AF_INET;
   bcopy ((char *) server->h_addr, (char *) &serv_addr.sin_addr.s_addr,
          server->h_length);
   serv_addr.sin_port = htons (portno);
   // CONNECT
   if (connect (sockfd, (struct sockaddr *) &serv_addr,
                sizeof (serv_addr)) < 0) error ("connecting");

   // vote protocol
   if (options.vote) {
      // convert candidate name to all lower case
      char *cand = strdup (options.candidateName);
      char *voter = strdup (options.voterID);
      int i;
      for (i = 0; cand[i]; ++i) cand[i] = tolower (cand[i]);
      vote_func (sockfd, cand, voter);
      free (cand); // strdup uses malloc
      free (voter);
   }
   // results protocol
   if (options.results) results_func (sockfd);

   // finish protocol
   n = write (sockfd, "done", 4);
   if (n < 0) error ("writing to socket");   
   bzero (buffer, 256);
   // verify finish
   n = read (sockfd, buffer, 255);
   if (n < 0) error ("reading socket");
   if (strcmp (buffer, "done") != 0) error ("finishing");

   // CLOSE
  close (sockfd);

   return get_exitstatus();
}
Beispiel #10
0
static void
do_set_npe_mac(int argc, char *argv[])
{
    bool portnum_set;
    int  portnum, i;
    char *addr = 0;
    struct option_info opts[1];
    cyg_uint8  mac[6];
    
    init_opts(&opts[0], 'p', true, OPTION_ARG_TYPE_NUM, 
              (void **)&portnum, (bool *)&portnum_set, "port number");
    if (!scan_opts(argc, argv, 1, opts, 1, (void *)&addr,
		   OPTION_ARG_TYPE_STR, "MAC address")) {
        return;
    }

    if ((!portnum_set && addr) ||
	(portnum_set && portnum != 0 && portnum != 1)) {
	diag_printf("Must specify port with \"-p <0|1>\"\n");
	return;
    }

    if (!portnum_set) {
	for (i = 0; i < 2; i++) {
	    cyghal_get_npe_esa(i, mac);
	    diag_printf("NPE eth%d mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
			i, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	}
	return;
    }

    if (!addr) {
	cyghal_get_npe_esa(portnum, mac);
	diag_printf("NPE eth%d mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
		    portnum, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	return;
    }

    // parse MAC address from user.
    // acceptable formats are "nn:nn:nn:nn:nn:nn" and "nnnnnnnnnnnn"
    for (i = 0; i < 6; i++) {
	if (!_is_hex(addr[0]) || !_is_hex(addr[1]))
	    break;
	mac[i] = (_from_hex(addr[0]) * 16) + _from_hex(addr[1]);
	addr += 2;
	if (*addr == ':')
	    addr++;
    }
    
    if (i != 6 || *addr != '\0') {
	diag_printf("Malformed MAC address.\n");
	return;
    }

    for (i = 0; i < 6; i++) {
	eeprom_write(MAC_EEPROM_OFFSET(portnum) + i, mac[i]);
	hal_delay_us(100000);
    }
}
Beispiel #11
0
void
do_gunzip(int argc, char *argv[])
{
    struct option_info opts[2];
    unsigned long src, dst;
    bool src_set, dst_set;
    _pipe_t pipe;
    _pipe_t* p = &pipe;
    int err;

    init_opts(&opts[0], 's', true, OPTION_ARG_TYPE_NUM, 
              (void *)&src, (bool *)&src_set, "source address");
    init_opts(&opts[1], 'd', true, OPTION_ARG_TYPE_NUM, 
              (void *)&dst, (bool *)&dst_set, "destination address");
    if (!scan_opts(argc, argv, 1, opts, 2, 0, 0, "")) {
        return;
    }

    // Must have src and dst
    if (!src_set || !dst_set) {
        // try to use load_address for src 
        if (dst_set 
            && load_address >= (CYG_ADDRESS)ram_start 
            && load_address < load_address_end) {
            src = load_address;
            diag_printf("Decompressing from %p to %p\n",
			(void*)src, (void*)dst);
        }
        else
        {
            diag_printf("usage: gunzip -s <addr> -d <addr>\n");
            return;
        }
    }

    p->out_buf = (unsigned char*)dst;
    p->out_max = p->out_size = -1;
    p->in_buf = (unsigned char*)src;
    p->in_avail = -1;

    err = (*_dc_init)(p);

    if (0 == err)
        err = (*_dc_inflate)(p);

    // Free used resources, do final translation of error value.
    err = (*_dc_close)(p, err);

    if (0 != err && p->msg) {
       entry_address = (CYG_ADDRESS)NO_MEMORY;
       diag_printf("Decompression error: %s\n", p->msg);
    } else {
        load_address     = entry_address = (CYG_ADDRESS)dst;
        load_address_end = (CYG_ADDRESS)p->out_buf;
        diag_printf("Decompressed %lu bytes\n", 
                    load_address_end - load_address);
    }
}
Beispiel #12
0
static void
do_physaddr(int argc, char *argv[]) {
    unsigned long phys_addr, virt_addr;

    if ( !scan_opts(argc,argv,1,0,0,(void*)&virt_addr, OPTION_ARG_TYPE_NUM, "virtual address") )
	return;
    phys_addr = hal_virt_to_phys_address(virt_addr);
    diag_printf("Virtual addr %p = physical addr %p\n", virt_addr, phys_addr);
}
Beispiel #13
0
void
do_iopoke(int argc, char *argv[])
{
    struct option_info opts[5];
    unsigned long base;
    bool base_set, value_set;
    bool set_32bit = false;
    bool set_16bit = false;
    bool set_8bit = false;
    cyg_uint32 value;
    int size = 1;

    init_opts(&opts[0], 'b', true, OPTION_ARG_TYPE_NUM, 
              &base, &base_set, "base address");
    init_opts(&opts[1], 'v', true, OPTION_ARG_TYPE_NUM, 
              &value, &value_set, "valuex");
    init_opts(&opts[2], '4', false, OPTION_ARG_TYPE_FLG,
              &set_32bit, 0, "output 32 bit units");
    init_opts(&opts[3], '2', false, OPTION_ARG_TYPE_FLG,
              &set_16bit, 0, "output 16 bit units");
    init_opts(&opts[4], '1', false, OPTION_ARG_TYPE_FLG,
              &set_8bit, 0, "output 8 bit units");
    if (!scan_opts(argc, argv, 1, opts, 5, 0, 0, "")) {
        return;
    }
    if (!base_set) {
        diag_printf("iopoke what <location>?\n");
        return;
    }
    if (!value_set) { 
        diag_printf("iopoke what <value>?\n");
        return;
    }
    if (set_32bit) {
        size = 4;
    } else if (set_16bit) {
        size = 2;
    } else if (set_8bit) {
        size = 1;
    }

    switch (size) {
    case 4:
        HAL_WRITE_UINT32 ( base, value );
        break;
    case 2:
        HAL_WRITE_UINT16 ( base, value );
        break;
    case 1: 
        HAL_WRITE_UINT8 ( base, value );
        break;
    }
}
Beispiel #14
0
void 
do_ip_addr(int argc, char *argv[])
{
    struct option_info opts[3];
    char *ip_addr, *host_addr;
    bool ip_addr_set, host_addr_set;
    struct sockaddr_in host;
#ifdef CYGPKG_REDBOOT_NETWORKING_DNS
    char *dns_addr;
    bool dns_addr_set;
#endif
    int num_opts;

    init_opts(&opts[0], 'l', true, OPTION_ARG_TYPE_STR, 
              (void **)&ip_addr, (bool *)&ip_addr_set, "local IP address");
    init_opts(&opts[1], 'h', true, OPTION_ARG_TYPE_STR, 
              (void **)&host_addr, (bool *)&host_addr_set, "default server address");
    num_opts = 2;
#ifdef CYGPKG_REDBOOT_NETWORKING_DNS
    init_opts(&opts[2], 'd', true, OPTION_ARG_TYPE_STR, 
              (void **)&dns_addr, (bool *)&dns_addr_set, "DNS server address");
    num_opts++;
#endif
    if (!scan_opts(argc, argv, 1, opts, num_opts, 0, 0, "")) {
        return;
    }
    if (ip_addr_set) {
        if (!_gethostbyname(ip_addr, (in_addr_t *)&host)) {
            diag_printf("Invalid local IP address: %s\n", ip_addr);
            return;
        }
        // Of course, each address goes in its own place :-)
        memcpy(&__local_ip_addr, &host.sin_addr, sizeof(host.sin_addr));
    }
    if (host_addr_set) {
        if (!_gethostbyname(host_addr, (in_addr_t *)&host)) {
            diag_printf("Invalid server address: %s\n", host_addr);
            return;
        }
        my_bootp_info.bp_siaddr = host.sin_addr;
    }
#ifdef CYGPKG_REDBOOT_NETWORKING_DNS
    if (dns_addr_set) {
        set_dns(dns_addr);
    }
#endif
    show_addrs();
    if (!have_net) {
        have_net = true;
        net_io_init();
    }
}
Beispiel #15
0
void
do_go(int argc, char *argv[])
{
    typedef void code_fun(void);
    unsigned long entry;
    unsigned long oldints;
    code_fun *fun;
    bool wait_time_set;
    int  wait_time, res;
    struct option_info opts[1];
    char line[8];

    entry = entry_address;  // Default from last 'load' operation
    init_opts(&opts[0], 'w', true, OPTION_ARG_TYPE_NUM, 
              (void **)&wait_time, (bool *)&wait_time_set, "wait timeout");
    if (!scan_opts(argc, argv, 1, opts, 1, (void *)&entry, OPTION_ARG_TYPE_NUM, "starting address"))
    {
        return;
    }
    if (wait_time_set) {
        int script_timeout_ms = wait_time * 1000;
#ifdef CYGSEM_REDBOOT_FLASH_CONFIG
        unsigned char *hold_script = script;
        script = (unsigned char *)0;
#endif
        diag_printf("About to start execution at %p - abort with ^C within %d seconds\n",
                    (void *)entry, wait_time);
        while (script_timeout_ms >= CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT) {
            res = _rb_gets(line, sizeof(line), CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT);
            if (res == _GETS_CTRLC) {
#ifdef CYGSEM_REDBOOT_FLASH_CONFIG
                script = hold_script;  // Re-enable script
#endif
                return;
            }
            script_timeout_ms -= CYGNUM_REDBOOT_CLI_IDLE_TIMEOUT;
        }
    }
    fun = (code_fun *)entry;
    HAL_DISABLE_INTERRUPTS(oldints);
    HAL_DCACHE_SYNC();
    HAL_ICACHE_DISABLE();
    HAL_DCACHE_DISABLE();
    HAL_DCACHE_SYNC();
    HAL_ICACHE_INVALIDATE_ALL();
    HAL_DCACHE_INVALIDATE_ALL();
#ifdef HAL_ARCH_PROGRAM_NEW_STACK
    HAL_ARCH_PROGRAM_NEW_STACK(fun);
#else
    (*fun)();
#endif
}
Beispiel #16
0
void
do_help(int argc, char *argv[])
{
    struct cmd *cmd;
    char *which = (char *)0;

    if (!scan_opts(argc, argv, 1, 0, 0, (void **)&which, OPTION_ARG_TYPE_STR, "<topic>")) {
        diag_printf("Invalid argument\n");
        return;
    }
    cmd = __RedBoot_CMD_TAB__;
    show_help(cmd, &__RedBoot_CMD_TAB_END__, which, "");
    return;
}
Beispiel #17
0
void
do_iopeek(int argc, char *argv[])
{
    struct option_info opts[4];
    unsigned long base;
    bool base_set;
    bool set_32bit = false;
    bool set_16bit = false;
    bool set_8bit = false;
    int size = 1, value;

    init_opts(&opts[0], 'b', true, OPTION_ARG_TYPE_NUM, 
              &base, &base_set, "base address");
    init_opts(&opts[1], '4', false, OPTION_ARG_TYPE_FLG,
              &set_32bit, 0, "output 32 bit units");
    init_opts(&opts[2], '2', false, OPTION_ARG_TYPE_FLG,
              &set_16bit, 0, "output 16 bit units");
    init_opts(&opts[3], '1', false, OPTION_ARG_TYPE_FLG,
              &set_8bit, 0, "output 8 bit units");
    if (!scan_opts(argc, argv, 1, opts, 4, 0, 0, "")) {
        return;
    }
    if (!base_set) {
        diag_printf("iopeek what <location>?\n");
        return;
    }
    if (set_32bit) {
      size = 4;
    } else if (set_16bit) {
        size = 2;
    } else if (set_8bit) {
        size = 1;
    }

    switch (size) {
    case 4:
        HAL_READ_UINT32 ( base, value );
        diag_printf("0x%04lx = 0x%08x\n", base, value );
        break;
    case 2:
        HAL_READ_UINT16 ( base, value );
        diag_printf("0x%04lx = 0x%04x\n", base, value );
        break;
    case 1: 
        HAL_READ_UINT8 ( base, value );
        diag_printf("0x%04lx = 0x%02x\n", base, value );
        break;
    }
}
Beispiel #18
0
static void
fis_unlock(int argc, char *argv[])
{
    char *name;
    int stat;
    unsigned long length;
    CYG_ADDRESS flash_addr;
    bool flash_addr_set = false;
    bool length_set = false;
    void *err_addr;
    struct option_info opts[2];

    init_opts(&opts[0], 'f', true, OPTION_ARG_TYPE_NUM, 
              (void *)&flash_addr, (bool *)&flash_addr_set, "FLASH memory base address");
    init_opts(&opts[1], 'l', true, OPTION_ARG_TYPE_NUM, 
              (void *)&length, (bool *)&length_set, "length");
    if (!scan_opts(argc, argv, 2, opts, 2, &name, OPTION_ARG_TYPE_STR, "image name"))
    {
        fis_usage("invalid arguments");
        return;
    }

    if (name) {
        struct fis_image_desc *img;
        if ((img = fis_lookup(name, NULL)) == (struct fis_image_desc *)0) {
            diag_printf("No image '%s' found\n", name);
            return;
        }

        flash_addr = img->flash_base;
        length = img->size;
    } else  if (!flash_addr_set || !length_set) {
        fis_usage("missing argument");
        return;
    }
    if (flash_addr_set &&
        ((stat = flash_verify_addr((void *)flash_addr)) ||
         (stat = flash_verify_addr((void *)(flash_addr+length-1))))) {
        _show_invalid_flash_address(flash_addr, stat);
        return;
    }

    if ((stat = flash_unlock((void *)flash_addr, length, (void **)&err_addr)) != 0) {
        diag_printf("Error unlocking at %p: %s\n", err_addr, flash_errmsg(stat));
    }
}
Beispiel #19
0
static void
fis_erase(int argc, char *argv[])
{
    int stat;
    unsigned long length;
    CYG_ADDRESS flash_addr;
    bool flash_addr_set = false;
    bool length_set = false;
    void *err_addr;
    struct option_info opts[2];

    init_opts(&opts[0], 'f', true, OPTION_ARG_TYPE_NUM, 
              (void *)&flash_addr, (bool *)&flash_addr_set, "FLASH memory base address");
    init_opts(&opts[1], 'l', true, OPTION_ARG_TYPE_NUM, 
              (void *)&length, (bool *)&length_set, "length");
    if (!scan_opts(argc, argv, 2, opts, 2, (void **)0, 0, ""))
    {
        fis_usage("invalid arguments");
        return;
    }

    if (!flash_addr_set || !length_set) {
        fis_usage("missing argument");
        return;
    }
    if (flash_addr_set &&
        ((stat = flash_verify_addr((void *)flash_addr)) ||
         (stat = flash_verify_addr((void *)(flash_addr+length-1))))) {
        _show_invalid_flash_address(flash_addr, stat);
        return;
    }
    if (flash_addr_set && flash_addr & (flash_block_size-1)) {
        diag_printf("Invalid FLASH address: %p\n", (void *)flash_addr);
        diag_printf("   must be 0x%x aligned\n", flash_block_size);
        return;
    }
    // Safety check - make sure the address range is not within the code we're running
    if (flash_code_overlaps((void *)flash_addr, (void *)(flash_addr+length-1))) {
        diag_printf("Can't erase this region - contains code in use!\n");
        return;
    }
    if ((stat = flash_erase((void *)flash_addr, length, (void **)&err_addr)) != 0) {
        diag_printf("Error erasing at %p: %s\n", err_addr, flash_errmsg(stat));
    }
}
static void
do_umount(int argc, char *argv[])
{
    char *dir_str;
    int err;
    int i;
    
     if( mount_count == 0 )
     {
         err_printf("fs: No filesystems mounted\n");
         return;
     }
     
    if (!scan_opts(argc, argv, 1, NULL, 0, &dir_str, OPTION_ARG_TYPE_STR, "mountpoint"))
        return;

    if( dir_str == 0 )
        dir_str = "/";

    for( i = 0; i < MAX_MOUNTS; i++ )
    {
        if( strcmp(mounts[i].mp_str, dir_str ) == 0 )
            break;
    }

    if( i == MAX_MOUNTS )
    {
        err_printf("fs unmount: unknown mountpoint %s\n",dir_str);
        return;
    }
    
    err = umount (dir_str);

    if (err)
        err_printf("fs umount: unmount failed %d\n", errno);
    else
    {
        mounts[i].mp_str[0] = '\0';
        mount_count--;
        if( mount_count == 0 )
            chdir( "/" );
    }
    
}
Beispiel #21
0
//--------------------------------------------------------------------------
// do_led --
//
static void
do_led (int argc, char *argv[])
{
    struct option_info opts[1];
    unsigned long mask;
    bool mask_set;

    init_opts (&opts[0], 'm', true, OPTION_ARG_TYPE_NUM,
               &mask, &mask_set, "mask");
    if (!scan_opts (argc, argv, 1, opts, 1, 0, 0, "")) {
        return;
    }
    if (!mask_set) {
        diag_printf ("led what <mask>?\n");
        return;
    }
    hal_lpc2xxx_set_leds (mask);
    return;
}
Beispiel #22
0
#if 0
//==========================================================================
//
//      redboot_cmds.c
//
//      OMAP1510DC EVM [platform] specific RedBoot commands
//
//==========================================================================
// ####ECOSGPLCOPYRIGHTBEGIN####                                            
// -------------------------------------------                              
// This file is part of eCos, the Embedded Configurable Operating System.   
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under    
// the terms of the GNU General Public License as published by the Free     
// Software Foundation; either version 2 or (at your option) any later      
// version.                                                                 
//
// eCos is distributed in the hope that it will be useful, but WITHOUT      
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or    
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    
// for more details.                                                        
//
// You should have received a copy of the GNU General Public License        
// along with eCos; if not, write to the Free Software Foundation, Inc.,    
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
//
// As a special exception, if other files instantiate templates or use      
// macros or inline functions from this file, or you compile this file      
// and link it with other works to produce a work based on this file,       
// this file does not by itself cause the resulting work to be covered by   
// the GNU General Public License. However the source code for this file    
// must still be made available in accordance with section (3) of the GNU   
// General Public License v2.                                               
//
// This exception does not invalidate any other reasons why a work based    
// on this file might be covered by the GNU General Public License.         
// -------------------------------------------                              
// ####ECOSGPLCOPYRIGHTEND####                                              
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):    Patrick Doyle <*****@*****.**>
// Contributors: Patrick Doyle <*****@*****.**>
// Date:         2002-11-27
// Purpose:      
// Description:  
//              
// This code is part of RedBoot (tm).  It was modified from "redboot_cmds"
// for the iPaq by wpd in order to add some platform specific commands to
// the OMAP1510DC EVM platform.
//
//####DESCRIPTIONEND####
//
//==========================================================================

#include <redboot.h>

#include <cyg/hal/hal_intr.h>
#include <cyg/hal/hal_cache.h>
#include <cyg/hal/hal_io.h>
#include <cyg/hal/hal_diag.h>
#include <cyg/hal/innovator.h>

static void do_mem(int argc, char *argv[]);
static void do_try_reset(int argc, char *argv[]);
static void do_testsdram(int argc, char *argv[]);
static void do_delay(int argc, char *argv[]);

RedBoot_cmd("mem",
	    "Set a memory location",
	    "[-h|-b] [-n] [-a <address>] <data>",
	    do_mem
    );

RedBoot_cmd("try_reset",
	    "try to reset the platform",
	    "[-1|-2|-3|-4]",
	    do_try_reset
    );


RedBoot_cmd("testsdram",
	    "test SDRAM (very simply)",
	    "[-l length]",
	    do_testsdram
    );

RedBoot_cmd("delay",
	    "delay specified number of usecs",
	    "[-c count] amount",
	    do_delay
    );


static void
do_mem(int argc,
       char *argv[])
{
  struct option_info opts[4];
  bool mem_half_word, mem_byte;
  bool no_verify = false;
  static int address = 0x00000000;
  int value;
  init_opts(&opts[0], 'b', false, OPTION_ARG_TYPE_FLG,
            (void**)&mem_byte, 0, "write a byte");
  init_opts(&opts[1], 'h', false, OPTION_ARG_TYPE_FLG,
            (void**)&mem_half_word, 0, "write a half-word");
  init_opts(&opts[2], 'a', true, OPTION_ARG_TYPE_NUM,
            (void**)&address, NULL, "address to write at");
  init_opts(&opts[3], 'n', false, OPTION_ARG_TYPE_FLG,
            (void**)&no_verify, 0, "noverify");

  if (!scan_opts(argc, argv,
                 1,
                 opts, sizeof(opts) / sizeof(opts[0]),
                 (void*)&value, OPTION_ARG_TYPE_NUM, "address to set")) {
    return;
  }

  if ( mem_byte && mem_half_word ) {
    diag_printf("*ERR: Should not specify both byte and half-word access\n");
  } else if ( mem_byte ) {
    *(cyg_uint8*)address = (cyg_uint8)(value & 255);
    if (no_verify) {
      diag_printf("  Set 0x%08X to 0x%02X\n",
                  address, value & 255);
    } else {
            diag_printf("  Set 0x%08X to 0x%02X (result 0x%02X)\n",
                  address, value & 255, (int)*(cyg_uint8*)address );
    }
  } else if ( mem_half_word ) {
    if ( address & 1 ) {
      diag_printf( "*ERR: Badly aligned address 0x%08X for half-word store\n",
                   address );
    } else {
      *(cyg_uint16*)address = (cyg_uint16)(value & 0xffff);
      if (no_verify) {
        diag_printf("  Set 0x%08X to 0x%04X\n",
                    address, value & 0xffff);
      } else {
        diag_printf("  Set 0x%08X to 0x%04X (result 0x%04X)\n",
                    address, value & 0xffff, (int)*(cyg_uint16*)address );
      }
    }
  } else {
    if ( address & 3 ) {
      diag_printf( "*ERR: Badly aligned address 0x%08X for word store\n",
                   address );
    } else {
      *(cyg_uint32*)address = (cyg_uint32)value;
      if (no_verify) {
        diag_printf("  Set 0x%08X to 0x%08X\n",
                    address, value);
      } else {
        diag_printf("  Set 0x%08X to 0x%08X (result 0x%08X)\n",
                    address, value, (int)*(cyg_uint32*)address );
      }
    }
  }
}

static void
do_try_reset(int argc,
             char *argv[])
{
  struct option_info opts[4];
  bool flag_1 = false;
  bool flag_2 = false;
  bool flag_3 = false;
  bool flag_4 = false;

  cyg_uint16 tmp = 0;

  init_opts(&opts[0], '1', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_1, 0, "only try phase 1");
  init_opts(&opts[1], '2', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_2, 0, "try phase 1 & phase 2");
  init_opts(&opts[2], '3', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_3, 0, "try phase 1 through phase 3");
  init_opts(&opts[3], '4', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_4, 0, "try phase 1 through phase 4");

  if (!scan_opts(argc, argv,
                 1,
                 opts, sizeof(opts) / sizeof(opts[0]),
                 0, 0, 0)) {
    return;
  }
  diag_printf("flag_4 = %d, flag_3 = %d, flag_2 = %d, flag_1 = %d\n",
              flag_4, flag_3, flag_2, flag_1);
  if (flag_4) {
    flag_3 = flag_2 = flag_1 = true;
  } else if (flag_3) {
    flag_2 = flag_1 = true;
  } else if (flag_2) {
    flag_1 = true;
  }
  diag_printf("flag_4 = %d, flag_3 = %d, flag_2 = %d, flag_1 = %d\n",
              flag_4, flag_3, flag_2, flag_1);

  if (flag_1) {
    HAL_READ_UINT16(CLKM_ARM_IDLECT2, tmp);
    diag_printf("tmp = %04X\n", tmp);
  }

  if (flag_2) {
    tmp |= 1;
    diag_printf("Writing %04X to %08X\n", tmp, CLKM_ARM_IDLECT2);
    HAL_WRITE_UINT16(CLKM_ARM_IDLECT2, tmp | 1);
  }

  if (flag_3) {
    diag_printf("Writing %04X to %08X\n", 0x80F5, WATCHDOG_TIMER_MODE);
    HAL_WRITE_UINT16(WATCHDOG_TIMER_MODE, 0x80F5); \
  }

  if (flag_4) {
    diag_printf("Writing %04X to %08X\n", 0x80F5, WATCHDOG_TIMER_MODE);
    HAL_WRITE_UINT16(WATCHDOG_TIMER_MODE, 0x80F5); \
  }

  diag_printf("try_reset: done\n");
}

#define SDRAM_BASE 0x10000000
#define SDRAM_LEN  (32*1024*1024)	/* 32 Mbytes */
static void
do_testsdram(int argc,
	     char *argv[])
{
  cyg_uint32 *mem_addr = (cyg_uint32 *)SDRAM_BASE;
  unsigned    len;
  bool        len_set;

  register int i;
  struct option_info opts[1];

  init_opts(&opts[0], 'l', true, OPTION_ARG_TYPE_NUM,
            (void**)&len, &len_set, "length");

  if (!scan_opts(argc, argv,
                 1,
                 opts, 1,
                 0, 0, 0)) {
    return;
  }
  if (!len_set) {
    len = SDRAM_LEN / 4;
  }

  diag_printf("Length = 0x%08X\n", len);

  diag_printf("Writing data-equals-address pattern to SDRAM\n");
  for (i = 0; i < len; i++) {
    mem_addr[i] = ~(cyg_uint32)(mem_addr + i);
  }
  diag_printf("Reading back pattern\n");
  for (i = 0; i < len; i++) {
    if (mem_addr[i] != ~(cyg_uint32)(mem_addr + i)) {
      diag_printf("Error: mismatch at address %p, read back 0x%08x\n",
		  mem_addr + i,
		  mem_addr[i]);
      break;
    }
  }
  diag_printf("Done\n");
}
Beispiel #23
0
static void
do_swab(int argc, char *argv[])
{
    // Fill a region of memory with a pattern
    struct option_info opts[4];
    unsigned long base;
    long len;
    bool base_set, len_set;
    bool set_32bit, set_16bit;

    init_opts(&opts[0], 'b', true, OPTION_ARG_TYPE_NUM, 
              (void *)&base, (bool *)&base_set, "base address");
    init_opts(&opts[1], 'l', true, OPTION_ARG_TYPE_NUM, 
              (void *)&len, (bool *)&len_set, "length");
    init_opts(&opts[2], '4', false, OPTION_ARG_TYPE_FLG,
              (void *)&set_32bit, (bool *)0, "fill 32 bit units");
    init_opts(&opts[3], '2', false, OPTION_ARG_TYPE_FLG,
              (void *)&set_16bit, (bool *)0, "fill 16 bit units");
    if (!scan_opts(argc, argv, 1, opts, 4, 0, 0, "")) {
        return;
    }
    if (!base_set || !len_set) {
        diag_printf("usage: swab -b <addr> -l <length> [-2|-4]\n");
        return;
    }
    if (set_16bit) {
        // 16 bits at a time
        while ((len -= sizeof(cyg_uint16)) >= 0) {
	    *(cyg_uint16 *)base = CYG_SWAP16(*(cyg_uint16 *)base);
	    base += sizeof(cyg_uint16);
	}
    } else {
        // Default - 32 bits
        while ((len -= sizeof(cyg_uint32)) >= 0) {
	    *(cyg_uint32 *)base = CYG_SWAP32(*(cyg_uint32 *)base);
	    base += sizeof(cyg_uint32);
	}
    }
}
static void 
do_cd(int argc, char * argv[])
{
    char *dir_str;
    int err;
    
     if( mount_count == 0 )
     {
         err_printf("fs: No filesystems mounted\n");
         return;
     }
     
    if (!scan_opts(argc, argv, 1, NULL, 0, &dir_str, OPTION_ARG_TYPE_STR, "directory"))
        return;

    if( dir_str == NULL )
        dir_str = "/";
    
    err = chdir( dir_str );

    if( err != 0 )
        err_printf("fs cd: failed to change directory %s\n",dir_str);
}
static void 
do_del(int argc, char * argv[])
{
    char *name_str = NULL;
    int err;
    
     if( mount_count == 0 )
     {
         err_printf("fs: No filesystems mounted\n");
         return;
     }
     
    if (!scan_opts(argc, argv, 1, NULL, 0, &name_str, OPTION_ARG_TYPE_STR, "file") ||
        name_str == NULL)
    {
        fs_usage("invalid arguments");
        return;
    }

    err = unlink( name_str );

    if( err != 0 )
        err_printf("fs del: failed to delete file %s\n",name_str);
}
static void 
do_deldir(int argc, char * argv[])
{
    char *dir_str;
    int err;
    
     if( mount_count == 0 )
     {
         err_printf("fs: No filesystems mounted\n");
         return;
     }
     
    if (!scan_opts(argc, argv, 1, NULL, 0, &dir_str, OPTION_ARG_TYPE_STR, "directory") ||
        dir_str == NULL)
    {
        fs_usage("invalid arguments");
        return;
    }

    err = rmdir( dir_str );

    if( err != 0 )
        err_printf("fs deldir: failed to remove directory %s\n",dir_str);
}
Beispiel #27
0
static void do_ping(int argc, char *argv[])
{
	struct option_info opts[7];
	long count, timeout, length, rate, start_time, end_time, timer,
	    received, tries;
	char *local_ip_addr, *host_ip_addr;
	bool local_ip_addr_set, host_ip_addr_set, count_set,
	    timeout_set, length_set, rate_set, verbose;
	struct sockaddr_in local_addr, host_addr;
	ip_addr_t hold_addr;
	icmp_header_t *icmp;
	pktbuf_t *pkt;
	ip_header_t *ip;
	unsigned short cksum;
	ip_route_t dest_ip;

	init_opts(&opts[0], 'n', true, OPTION_ARG_TYPE_NUM,
		  (void *)&count, (bool *) & count_set,
		  "<count> - number of packets to test");
	init_opts(&opts[1], 't', true, OPTION_ARG_TYPE_NUM, (void *)&timeout,
		  (bool *) & timeout_set,
		  "<timeout> - max #ms per packet [rount trip]");
	init_opts(&opts[2], 'i', true, OPTION_ARG_TYPE_STR,
		  (void *)&local_ip_addr, (bool *) & local_ip_addr_set,
		  "local IP address");
	init_opts(&opts[3], 'h', true, OPTION_ARG_TYPE_STR,
		  (void *)&host_ip_addr, (bool *) & host_ip_addr_set,
		  "host name or IP address");
	init_opts(&opts[4], 'l', true, OPTION_ARG_TYPE_NUM, (void *)&length,
		  (bool *) & length_set, "<length> - size of payload");
	init_opts(&opts[5], 'v', false, OPTION_ARG_TYPE_FLG, (void *)&verbose,
		  (bool *) 0, "verbose operation");
	init_opts(&opts[6], 'r', true, OPTION_ARG_TYPE_NUM, (void *)&rate,
		  (bool *) & rate_set, "<rate> - time between packets");
	if (!scan_opts(argc, argv, 1, opts, 7, (void **)0, 0, "")) {
		diag_printf("PING - Invalid option specified\n");
		return;
	}
	// Set defaults; this has to be done _after_ the scan, since it will
	// have destroyed all values not explicitly set.
	if (local_ip_addr_set) {
		if (!_gethostbyname(local_ip_addr, (in_addr_t *) & local_addr)) {
			diag_printf("PING - Invalid local name: %s\n",
				    local_ip_addr);
			return;
		}
	} else {
		memcpy((in_addr_t *) & local_addr, __local_ip_addr,
		       sizeof(__local_ip_addr));
	}
	if (host_ip_addr_set) {
		if (!_gethostbyname(host_ip_addr, (in_addr_t *) & host_addr)) {
			diag_printf("PING - Invalid host name: %s\n",
				    host_ip_addr);
			return;
		}
		if (__arp_lookup((ip_addr_t *) & host_addr.sin_addr, &dest_ip) <
		    0) {
			diag_printf("PING: Cannot reach server '%s' (%s)\n",
				    host_ip_addr,
				    inet_ntoa((in_addr_t *) & host_addr));
			return;
		}
	} else {
		diag_printf("PING - host name or IP address required\n");
		return;
	}
#define DEFAULT_LENGTH   64
#define DEFAULT_COUNT    10
#define DEFAULT_TIMEOUT  1000
#define DEFAULT_RATE     1000
	if (!rate_set) {
		rate = DEFAULT_RATE;
	}
	if (!length_set) {
		length = DEFAULT_LENGTH;
	}
	if ((length < 64) || (length > 1400)) {
		diag_printf("Invalid length specified: %ld\n", length);
		return;
	}
	if (!count_set) {
		count = DEFAULT_COUNT;
	}
	if (!timeout_set) {
		timeout = DEFAULT_TIMEOUT;
	}
	// Note: two prints here because 'inet_ntoa' returns a static pointer
	diag_printf("Network PING - from %s",
		    inet_ntoa((in_addr_t *) & local_addr));
	diag_printf(" to %s\n", inet_ntoa((in_addr_t *) & host_addr));
	received = 0;
	__icmp_install_listener(handle_icmp);
	// Save default "local" address
	memcpy(hold_addr, __local_ip_addr, sizeof(hold_addr));
	for (tries = 0; tries < count; tries++) {
		// The network stack uses the global variable '__local_ip_addr'
		memcpy(__local_ip_addr, &local_addr, sizeof(__local_ip_addr));
		// Build 'ping' request
		if ((pkt = __pktbuf_alloc(ETH_MAX_PKTLEN)) == NULL) {
			// Give up if no packets - something is wrong
			break;
		}

		icmp = pkt->icmp_hdr;
		ip = pkt->ip_hdr;
		pkt->pkt_bytes = length + sizeof(icmp_header_t);

		icmp->type = ICMP_TYPE_ECHOREQUEST;
		icmp->code = 0;
		icmp->checksum = 0;
		icmp->seqnum = htons(tries + 1);
		cksum = __sum((word *) icmp, pkt->pkt_bytes, 0);
		icmp->checksum = htons(cksum);

		memcpy(ip->source, (in_addr_t *) & local_addr,
		       sizeof(ip_addr_t));
		memcpy(ip->destination, (in_addr_t *) & host_addr,
		       sizeof(ip_addr_t));
		ip->protocol = IP_PROTO_ICMP;
		ip->length = htons(pkt->pkt_bytes);

		__ip_send(pkt, IP_PROTO_ICMP, &dest_ip);
		__pktbuf_free(pkt);

		start_time = MS_TICKS();
		timer = start_time + timeout;
		icmp_received = false;
		while (!icmp_received && (MS_TICKS_DELAY() < timer)) {
			if (_rb_break(1)) {
				goto abort;
			}
			MS_TICKS_DELAY();
			__enet_poll();
		}
		end_time = MS_TICKS();

		timer = MS_TICKS() + rate;
		while (MS_TICKS_DELAY() < timer) {
			if (_rb_break(1)) {
				goto abort;
			}
			MS_TICKS_DELAY();
			__enet_poll();
		}

		if (icmp_received) {
			received++;
			if (verbose) {
				diag_printf(" seq: %ld, time: %ld (ticks)\n",
					    ntohs(hold_hdr.seqnum),
					    end_time - start_time);
			}
		}
	}
abort:
	__icmp_remove_listener();
	// Clean up
	memcpy(__local_ip_addr, &hold_addr, sizeof(__local_ip_addr));
	// Report
	diag_printf("PING - received %ld of %ld expected\n", received, count);
}
Beispiel #28
0
static void
do_flash_config(int argc, char *argv[])
{
    bool need_update = false;
    struct config_option *optend = __CONFIG_options_TAB_END__;
    struct config_option *opt = __CONFIG_options_TAB__;
    struct option_info opts[5];
    bool list_only;
    bool nicknames;
    bool fullnames;
    bool dumbterminal;
    int list_opt = 0;
    unsigned char *dp;
    int len, ret;
    char *title;
    char *onlyone = NULL;
    char *onevalue = NULL;
    bool doneone = false;
    bool init = false;

#ifdef CYGHWR_REDBOOT_FLASH_CONFIG_MEDIA_FLASH
    if (!__flash_init) {
        diag_printf("Sorry, no FLASH memory is available\n");
        return;
    }
#endif
    memcpy(backup_config, config, sizeof(struct _config));
    script = (unsigned char *)0;

    init_opts(&opts[0], 'l', false, OPTION_ARG_TYPE_FLG, 
              (void *)&list_only, (bool *)0, "list configuration only");
    init_opts(&opts[1], 'n', false, OPTION_ARG_TYPE_FLG, 
              (void *)&nicknames, (bool *)0, "show nicknames");
    init_opts(&opts[2], 'f', false, OPTION_ARG_TYPE_FLG, 
              (void *)&fullnames, (bool *)0, "show full names");
    init_opts(&opts[3], 'i', false, OPTION_ARG_TYPE_FLG, 
              (void *)&init, (bool *)0, "initialize configuration database");
    init_opts(&opts[4], 'd', false, OPTION_ARG_TYPE_FLG, 
              (void *)&dumbterminal, (bool *)0, "dumb terminal: no clever edits");

    // First look to see if we are setting or getting a single option
    // by just quoting its nickname
    if ( (2 == argc && '-' != argv[1][0]) ||
         (3 == argc && '-' != argv[1][0] && '-' != argv[2][0])) {
        // then the command was "fconfig foo [value]"
        onlyone = argv[1];
        onevalue = (3 == argc) ? argv[2] : NULL;
        list_opt = LIST_OPT_NICKNAMES;
    }
    // Next see if we are setting or getting a single option with a dumb
    // terminal invoked, ie. no line editing.
    else if (3 == argc &&
             '-' == argv[1][0] && 'd' == argv[1][1] && 0 == argv[1][2] && 
             '-' != argv[2][0]) {
        // then the command was "fconfig -d foo"
        onlyone = argv[2];
        onevalue = NULL;
        list_opt = LIST_OPT_NICKNAMES | LIST_OPT_DUMBTERM;
    }
    else {
        if (!scan_opts(argc, argv, 1, opts, 5, 0, 0, ""))
            return;
        list_opt |= list_only ? LIST_OPT_LIST_ONLY : 0;
        list_opt |= nicknames ? LIST_OPT_NICKNAMES : LIST_OPT_FULLNAMES;
        list_opt |= fullnames ? LIST_OPT_FULLNAMES : 0;
        list_opt |= dumbterminal ? LIST_OPT_DUMBTERM : 0;
    }

    if (init && verify_action("Initialize non-volatile configuration")) {
        config_init();
        need_update = true;
    }

    dp = &config->config_data[0];
    while (dp < &config->config_data[sizeof(config->config_data)]) {
        if (CONFIG_OBJECT_TYPE(dp) == CONFIG_EMPTY) {
            break;
        }
        len = 4 + CONFIG_OBJECT_KEYLEN(dp) + CONFIG_OBJECT_ENABLE_KEYLEN(dp) + 
            config_length(CONFIG_OBJECT_TYPE(dp));
        // Provide a title for well known [i.e. builtin] objects
        title = (char *)NULL;
        opt = __CONFIG_options_TAB__;
        while (opt != optend) {
            if (strcmp(opt->key, CONFIG_OBJECT_KEY(dp)) == 0) {
                title = opt->title;
                break;
            }
            opt++;
        }
        if ( onlyone && 0 != strcmp(CONFIG_OBJECT_KEY(dp), onlyone) )
            ret = CONFIG_OK; // skip this entry
        else {
            doneone = true;
            ret = get_config(dp, title, list_opt, onevalue); // do this opt
        }
        switch (ret) {
        case CONFIG_DONE:
            goto done;
        case CONFIG_ABORT:
            memcpy(config, backup_config, sizeof(struct _config));
            return;
        case CONFIG_CHANGED:
            need_update = true;
        case CONFIG_OK:
            dp += len;
            break;
        case CONFIG_BACK:
            dp = &config->config_data[0];
            continue;
        case CONFIG_BAD:
            // Nothing - make him do it again
            diag_printf ("** invalid entry\n");
            onevalue = NULL; // request a good value be typed in - or abort/whatever
        }
    }

 done:
    if (NULL != onlyone && !doneone) {
#ifdef CYGSEM_REDBOOT_ALLOW_DYNAMIC_FLASH_CONFIG_DATA
        if (verify_action("** entry '%s' not found - add", onlyone)) {
            struct config_option opt;
            diag_printf("Trying to add value\n");
        }
#else
        diag_printf("** entry '%s' not found\n", onlyone);
#endif
    }
    if (!need_update)
        return;
    flash_write_config(true);
}
Beispiel #29
0
static void
do_try_reset(int argc,
             char *argv[])
{
  struct option_info opts[4];
  bool flag_1 = false;
  bool flag_2 = false;
  bool flag_3 = false;
  bool flag_4 = false;

  cyg_uint16 tmp = 0;

  init_opts(&opts[0], '1', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_1, 0, "only try phase 1");
  init_opts(&opts[1], '2', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_2, 0, "try phase 1 & phase 2");
  init_opts(&opts[2], '3', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_3, 0, "try phase 1 through phase 3");
  init_opts(&opts[3], '4', false, OPTION_ARG_TYPE_FLG,
            (void**)&flag_4, 0, "try phase 1 through phase 4");

  if (!scan_opts(argc, argv,
                 1,
                 opts, sizeof(opts) / sizeof(opts[0]),
                 0, 0, 0)) {
    return;
  }
  diag_printf("flag_4 = %d, flag_3 = %d, flag_2 = %d, flag_1 = %d\n",
              flag_4, flag_3, flag_2, flag_1);
  if (flag_4) {
    flag_3 = flag_2 = flag_1 = true;
  } else if (flag_3) {
    flag_2 = flag_1 = true;
  } else if (flag_2) {
    flag_1 = true;
  }
  diag_printf("flag_4 = %d, flag_3 = %d, flag_2 = %d, flag_1 = %d\n",
              flag_4, flag_3, flag_2, flag_1);

  if (flag_1) {
    HAL_READ_UINT16(CLKM_ARM_IDLECT2, tmp);
    diag_printf("tmp = %04X\n", tmp);
  }

  if (flag_2) {
    tmp |= 1;
    diag_printf("Writing %04X to %08X\n", tmp, CLKM_ARM_IDLECT2);
    HAL_WRITE_UINT16(CLKM_ARM_IDLECT2, tmp | 1);
  }

  if (flag_3) {
    diag_printf("Writing %04X to %08X\n", 0x80F5, WATCHDOG_TIMER_MODE);
    HAL_WRITE_UINT16(WATCHDOG_TIMER_MODE, 0x80F5); \
  }

  if (flag_4) {
    diag_printf("Writing %04X to %08X\n", 0x80F5, WATCHDOG_TIMER_MODE);
    HAL_WRITE_UINT16(WATCHDOG_TIMER_MODE, 0x80F5); \
  }

  diag_printf("try_reset: done\n");
}
Beispiel #30
0
void 
do_load(int argc, char *argv[])
{
    int res, num_options;
    int i, err;
    bool verbose, raw;
    bool base_addr_set, mode_str_set;
    char *mode_str;
#ifdef CYGPKG_REDBOOT_NETWORKING
    struct sockaddr_in host;
    bool hostname_set, port_set;
    unsigned int port;	// int because it's an OPTION_ARG_TYPE_NUM, 
                        // but will be cast to short
    char *hostname;
#endif
#ifdef CYGBLD_REDBOOT_LOAD_INTO_FLASH
    bool flash_addr_set = false;
#endif
    bool decompress = false;
    int chan = -1;
#if CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS > 1
    bool chan_set;
#endif
    unsigned long base = 0;
    unsigned long end = 0;
    char type[4];
    char *filename = 0;
    struct option_info opts[9];
    connection_info_t info;
    getc_io_funcs_t *io = NULL;
    struct load_io_entry *io_tab;
#ifdef CYGSEM_REDBOOT_VALIDATE_USER_RAM_LOADS
    bool spillover_ok = false;
#endif

#ifdef CYGPKG_REDBOOT_NETWORKING
    memset((char *)&host, 0, sizeof(host));
    host.sin_len = sizeof(host);
    host.sin_family = AF_INET;
    host.sin_addr = my_bootp_info.bp_siaddr;
    host.sin_port = 0;
#endif

    init_opts(&opts[0], 'v', false, OPTION_ARG_TYPE_FLG, 
              (void *)&verbose, 0, "verbose");
    init_opts(&opts[1], 'r', false, OPTION_ARG_TYPE_FLG, 
              (void *)&raw, 0, "load raw data");
    init_opts(&opts[2], 'b', true, OPTION_ARG_TYPE_NUM, 
              (void *)&base, (bool *)&base_addr_set, "load address");
    init_opts(&opts[3], 'm', true, OPTION_ARG_TYPE_STR, 
              (void *)&mode_str, (bool *)&mode_str_set, "download mode (TFTP, xyzMODEM, or disk)");
    num_options = 4;
#if CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS > 1
    init_opts(&opts[num_options], 'c', true, OPTION_ARG_TYPE_NUM, 
              (void *)&chan, (bool *)&chan_set, "I/O channel");
    num_options++;
#endif
#ifdef CYGPKG_REDBOOT_NETWORKING
    init_opts(&opts[num_options], 'h', true, OPTION_ARG_TYPE_STR, 
              (void *)&hostname, (bool *)&hostname_set, "host name or IP address");
    num_options++;
    init_opts(&opts[num_options], 'p', true, OPTION_ARG_TYPE_NUM, 
              (void *)&port, (bool *)&port_set, "TCP port");
    num_options++;
#endif
#ifdef CYGBLD_BUILD_REDBOOT_WITH_ZLIB
    init_opts(&opts[num_options], 'd', false, OPTION_ARG_TYPE_FLG, 
              (void *)&decompress, 0, "decompress");
    num_options++;
#endif
#ifdef CYGBLD_REDBOOT_LOAD_INTO_FLASH
    init_opts(&opts[num_options], 'f', true, OPTION_ARG_TYPE_NUM,
              (void *)&base, (bool *)&flash_addr_set, "flash address");
    num_options++;
#endif
    CYG_ASSERT(num_options <= NUM_ELEMS(opts), "Too many options");
    
    if (!scan_opts(argc, argv, 1, opts, num_options, 
                   (void *)&filename, OPTION_ARG_TYPE_STR, "file name")) {
        return;
    }
#ifdef CYGPKG_REDBOOT_NETWORKING
    if (hostname_set) {
        ip_route_t rt;
        if (!_gethostbyname(hostname, (in_addr_t *)&host)) {
            err_printf("Invalid host: %s\n", hostname);
            return;
        }
        /* check that the host can be accessed */
        if (__arp_lookup((ip_addr_t *)&host.sin_addr, &rt) < 0) {
            err_printf("Unable to reach host %s (%s)\n",
                        hostname, inet_ntoa((in_addr_t *)&host));
            return;
        }
    }
    if (port_set) 
	    host.sin_port = port;
#endif
    if (chan >= CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS) {
        err_printf("Invalid I/O channel: %d\n", chan);
        return;
    }
    if (mode_str_set) {
        for (io_tab = __RedBoot_LOAD_TAB__; 
             io_tab != &__RedBoot_LOAD_TAB_END__;  io_tab++) {
            if (strncasecmp(&mode_str[0], io_tab->name, strlen(&mode_str[0])) == 0) {
                io = io_tab->funcs;
                break;
            }
        }
        if (!io) {
            diag_printf("Invalid 'mode': %s.  Valid modes are:", mode_str);
            for (io_tab = __RedBoot_LOAD_TAB__; 
                 io_tab != &__RedBoot_LOAD_TAB_END__;  io_tab++) {
                diag_printf(" %s", io_tab->name);
            }
            err_printf("\n");
        }
        if (!io) {
            return;
        }
        verbose &= io_tab->can_verbose;
        if (io_tab->need_filename && !filename) {
            diag_printf("File name required\n");
            err_printf("usage: load %s\n", usage);
            return;
        }
    } else {
        char *which = "";
        io_tab = (struct load_io_entry *)NULL;  // Default
#ifdef CYGPKG_REDBOOT_NETWORKING
#ifdef CYGSEM_REDBOOT_NET_TFTP_DOWNLOAD        
        which = "TFTP";
        io = &tftp_io;
#elif defined(CYGSEM_REDBOOT_NET_HTTP_DOWNLOAD)
        which = "HTTP";
        io = &http_io;
#endif
#endif
#if 0 //def CYGPKG_REDBOOT_FILEIO
        // Make file I/O default if mounted
	if (fileio_mounted) {
	    which = "file";
	    io = &fileio_io;
	}
#endif
        if (!io) {
#ifdef CYGBLD_BUILD_REDBOOT_WITH_XYZMODEM
            which = "Xmodem";
            io = &xyzModem_io;
            verbose = false;
#else
            err_printf("No default protocol!\n");
            return;
#endif
        }
        diag_printf("Using default protocol (%s)\n", which);
    }
#ifdef CYGSEM_REDBOOT_VALIDATE_USER_RAM_LOADS
#ifdef  CYGBLD_REDBOOT_LOAD_INTO_FLASH
    if (flash_addr_set && flash_verify_addr((unsigned char *)base)) {
        if (!verify_action("Specified address (%p) is not believed to be in FLASH", (void*)base))
          return;
        spillover_ok = true;
    }
#endif
    if (base_addr_set && !valid_address((unsigned char *)base)) {
        if (!verify_action("Specified address (%p) is not believed to be in RAM", (void*)base))
            return;
        spillover_ok = true;
    }
#endif
    if (raw && !(base_addr_set 
#ifdef CYGBLD_REDBOOT_LOAD_INTO_FLASH
                || flash_addr_set
#endif
        )) {
        err_printf("Raw load requires a memory address\n");
        return;
    }
    info.filename = filename;
    info.chan = chan;
    info.mode = io_tab ? io_tab->mode : 0;
#ifdef CYGPKG_REDBOOT_NETWORKING
    info.server = &host;
#endif
    res = redboot_getc_init(&info, io, verbose, decompress);
    if (res < 0) {
        return;
    }
#ifdef CYGBLD_REDBOOT_LOAD_INTO_FLASH
    flash_load_start();
#endif
    // Stream open, process the data
    if (raw) {
        unsigned char *mp = (unsigned char *)base;
        err = 0;
        while ((res = redboot_getc()) >= 0) {
#ifdef CYGSEM_REDBOOT_VALIDATE_USER_RAM_LOADS
#ifdef CYGBLD_REDBOOT_LOAD_INTO_FLASH
            if (flash_addr_set && flash_verify_addr(mp) && !spillover_ok) {
                // Only if there is no need to stop the download
                // before printing output can we ask confirmation
                // questions.
                redboot_getc_terminate(true);
                err_printf("*** Abort! RAW data spills over limit of FLASH at %p\n",(void*)mp);
                err = -1;
                break;
            }
#endif
            if (base_addr_set && !valid_address(mp) && !spillover_ok) {
                // Only if there is no need to stop the download
                // before printing output can we ask confirmation
                // questions.
                redboot_getc_terminate(true);
                err_printf("*** Abort! RAW data spills over limit of user RAM at %p\n",(void*)mp);
                err = -1;
                break;
            }
#endif
#ifdef CYGBLD_REDBOOT_LOAD_INTO_FLASH
            if (flash_addr_set) {
              flash_load_write(mp, res);
              mp++;
              res++;
            } else
#endif
            *mp++ = res;
        }
        end = (unsigned long) mp;

        // Save load base/top
        load_address = base;
        load_address_end = end;
        entry_address = base;           // best guess

        redboot_getc_terminate(false);
        if (0 == err)
            diag_printf("Raw file loaded %p-%p, assumed entry at %p\n", 
                        (void *)base, (void *)(end - 1), (void*)base);
    } else {
        // Read initial header - to determine file [image] type
        for (i = 0;  i < sizeof(type);  i++) {
            if ((res = redboot_getc()) < 0) {
                err = getc_info.err;
                break;
            } 
            type[i] = res;
        }
        if (res >= 0) {
            redboot_getc_rewind();  // Restore header to stream
            // Treat data as some sort of executable image
            if (strncmp(&type[1], "ELF", 3) == 0) {
                end = load_elf_image(redboot_getc, base);
            } else if ((type[0] == 'S') &&
                       ((type[1] >= '0') && (type[1] <= '9'))) {
		end = load_srec_image(redboot_getc, base);
            } else {
                redboot_getc_terminate(true);
                err_printf("Unrecognized image type: 0x%lx\n", *(unsigned long *)type);
            }
        }
    }
#ifdef CYGBLD_REDBOOT_LOAD_INTO_FLASH
    flash_load_finish();
#endif

    redboot_getc_close();  // Clean up
    return;
}