Subversion Repositories qaz_libs

//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2015 Authors and OPENCORES.ORG                 ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// restriction provided that this copyright statement is not    ////
//// removed from the file and that any derivative work contains  ////
//// the original copyright notice and the associated disclaimer. ////
////                                                              ////
//// This source file is free software; you can redistribute it   ////
//// and/or modify it under the terms of the GNU Lesser General   ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any   ////
//// later version.                                               ////
////                                                              ////
//// This source 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 Lesser General Public License for more ////
//// details.                                                     ////
////                                                              ////
//// You should have received a copy of the GNU Lesser General    ////
//// Public License along with this source; if not, download it   ////
//// from http://www.opencores.org/lgpl.shtml                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
 
#include "uboot_lib.h"
 
 
/*-----------------------------------------------------------*/
int cmd_get_data_size(const char * arg, int default_size)
{
	/* Check for a size specification .b, .w or .l.
	 */
	int len = strlen(arg);
	if (len > 2 && arg[len-2] == '.') {
		switch (arg[len-1]) {
		case 'b':
			return 1;
		case 'w':
			return 2;
		case 'l':
			return 4;
		case 's':
			return -2;
		default:
			return -1;
		}
	}
	return default_size;
}
 
 
/*-----------------------------------------------------------*/
unsigned long simple_strtoul(const char *cp, char **endp,
				unsigned int base)
{
	unsigned long result = 0;
 
  result  = strtoul( cp, endp, base );
 
	return result;
}
 
 
/*-----------------------------------------------------------*/
#define MAX_LINE_LENGTH_BYTES (64)
#define DEFAULT_LINE_LENGTH_BYTES (16)
int print_buffer(ulong addr, const void *data, uint width, uint count,
		 uint linelen)
{
	/* linebuf as a union causes proper alignment */
	union linebuf {
#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
		uint64_t uq[MAX_LINE_LENGTH_BYTES/sizeof(uint64_t) + 1];
#endif
		uint32_t ui[MAX_LINE_LENGTH_BYTES/sizeof(uint32_t) + 1];
		uint16_t us[MAX_LINE_LENGTH_BYTES/sizeof(uint16_t) + 1];
		uint8_t  uc[MAX_LINE_LENGTH_BYTES/sizeof(uint8_t) + 1];
	} lb;
	int i;
#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
	uint64_t __maybe_unused x;
#else
	uint32_t __maybe_unused x;
#endif
 
	if (linelen*width > MAX_LINE_LENGTH_BYTES)
		linelen = MAX_LINE_LENGTH_BYTES / width;
	if (linelen < 1)
		linelen = DEFAULT_LINE_LENGTH_BYTES / width;
 
	while (count) {
		uint thislinelen = linelen;
		PRINTF_MACRO("%08lx:", addr);
 
		/* check for overflow condition */
		if (count < thislinelen)
			thislinelen = count;
 
		/* Copy from memory into linebuf and print hex values */
		for (i = 0; i < thislinelen; i++) {
			if (width == 4)
      {
				x = lb.ui[i] = *(volatile uint32_t *)data;
        PRINTF_MACRO(" %08x", x);
      }
#ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
			else if (width == 8)
      {
				x = lb.uq[i] = *(volatile uint64_t *)data;
        PRINTF_MACRO(" %016llx", (long long)x);
      }
#endif
			else if (width == 2)
      {
				x = lb.us[i] = *(volatile uint16_t *)data;
        PRINTF_MACRO(" %04x", x);
      }
			else
      {
				x = lb.uc[i] = *(volatile uint8_t *)data;
        PRINTF_MACRO(" %02x", x);
      }
// #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA
			// PRINTF_MACRO(" %0*llx", width * 2, (long long)x);
// #else
			// PRINTF_MACRO(" %0*x", width * 2, x);
// #endif
			data += width;
		}
 
		while (thislinelen < linelen) {
			/* fill line with whitespace for nice ASCII print */
			for (i=0; i<width*2+1; i++)
				puts(" ");
			linelen--;
		}
 
		/* Print data in ASCII characters */
		for (i = 0; i < thislinelen * width; i++) {
			if (!isprint(lb.uc[i]) || lb.uc[i] >= 0x80)
				lb.uc[i] = '.';
		}
		lb.uc[i] = '\0';
		PRINTF_MACRO("    %s\r\n", lb.uc);
 
		/* update references */
		addr += thislinelen * width;
		count -= thislinelen;
 
		// if (ctrlc())
			// return -1;
	}
 
	return 0;
}