Subversion Repositories funbase_ip_library

/*
 * Copyright (c) 2011, Mentor Graphics Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. Neither the name of the <ORGANIZATION> nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
/* XXX would be better to stay closer to dd(1) parameters and functionality */
 
#include <stdio.h>
#include <sys/mman.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <sys/ioctl.h>
#include <getopt.h>
#include <limits.h>
 
#define DEVMCOMM "/dev/mcomm"
 
typedef int (*command_t)(void *mem, size_t bytes, unsigned long base);
 
static ssize_t read_mcomm_size(void)
{
	ssize_t size;
	unsigned long val;
	FILE *f;
	int rc;
 
	f = fopen("/sys/devices/mcomm.0/size", "r");
	if (!f)
		return -ENOENT;
 
	rc = fscanf(f, "%lx", &val);
	size = val;
	if (rc < 0) {
		perror("fscanf");
		size = -EINVAL;
	}
 
	fclose(f);
 
	return size;
}
 
static void *map(int fd, ssize_t bytes, unsigned long off)
{
	void *mem = NULL;
 
	mem = mmap(NULL, bytes, PROT_READ|PROT_WRITE, MAP_SHARED, fd, off);
	if (mem == MAP_FAILED) {
		perror("mmap");
		return NULL;
	}
 
	return mem;
}
 
static void unmap(int fd, void *mem, int bytes)
{
	close(fd);
	munmap(mem, bytes);
}
 
void usage(char *name)
{
	printf("Usage: %s [options] <command>\n"
	       "Options:\n"
		   "  -d, --device=<path>\n"
		   "          Device to open.\n"
		   "\n"
		   "  -o, --offset=<offset>\n"
		   "          Offset (in bytes) at which to start. Must be page-aligned.\n"
		   "\n"
		   "  -l, --length=<length>\n"
		   "          Number of bytes on which to operate.\n"
		   "          Defaults to the entire mcomm region, or 4K for other devices.\n"
		   "\n"
	       "Commands:\n"
		   "  clear: zeroes memory\n"
		   "  dump:  dump memory contents as hex\n",
		   name);
	exit(1);
}
 
static int clear(void *mem, size_t bytes, unsigned long base)
{
	memset(mem, 0, bytes);
	return 0;
}
 
static int dump(void *addr, size_t bytes, unsigned long base)
{
	const int COLS = 4;
	unsigned int *data = addr;
	int pos, i;
 
    for (pos = 0; sizeof(int) * pos < bytes; pos += COLS) {
        printf("%08lx:", base + pos * sizeof(int));
        for (i = 0; i < COLS; i++)
            printf(" %08x", data[pos + i]);
        printf("\n");
    }
 
	return 0;
}
 
int main(int argc, char *argv[])
{
	unsigned long offset = 0;
	unsigned long length = ULONG_MAX;
	char *dev = "/dev/mem";
	unsigned int *mem;
	command_t command = NULL;
	ssize_t bytes;
	int dev_fd;
	int c;
	int rc = 0;
	unsigned int pagesize;
 
	while (1) {
		static struct option long_options[] = {
			{"device", 1, 0, 'd'},
			{"offset", 1, 0, 'o'},
			{"length", 1, 0, 'l'},
			{NULL, 0, 0, 0},
		};
		int option_index = 0;
 
		c = getopt_long(argc, argv, "d:o:l:", long_options, &option_index);
		if (c == -1)
			break;
 
		switch (c) {
		case 'd':
			dev = optarg;
			break;
 
		case 'o':
			offset = strtoul(optarg, NULL, 0);
			if (offset == ULONG_MAX) {
				printf("couldn't use offset\n");
				usage(argv[0]);
			}
			pagesize = getpagesize();
			if (offset & (pagesize-1)) {
				printf("offset must be a multiple of 0x%x\n", pagesize);
				usage(argv[0]);
			}
			break;
 
		case 'l':
			length = strtoul(optarg, NULL, 0);
			if (length == ULONG_MAX) {
				printf("couldn't use length\n");
				usage(argv[0]);
			}
			break;
 
		default:
			printf("%d\n", c);
			usage(argv[0]);
		}
	}
 
	if (optind < argc) {
		char *cmdstr = argv[optind];
 
		if (strcmp(cmdstr, "dump") == 0)
			command = dump;
		else if (strcmp(cmdstr, "clear") == 0)
			command = clear;
 
		optind++;
	}
 
	if ((optind < argc) || (command == NULL)) {
		usage(argv[0]);
	}
 
	dev_fd = open(dev, O_RDWR);
	if (dev_fd < 0) {
		rc = errno;
		perror("open");
		return rc;
	}
 
	if (strncmp(dev, DEVMCOMM, strlen(DEVMCOMM)) == 0) {
		bytes = read_mcomm_size();
		if (bytes <= 0) {
			perror("read mcomm size");
			goto out;
		}
	} else {
		bytes = 1<<12;
	}
 
	if (length < bytes)
		bytes = length;
 
	mem = map(dev_fd, bytes, offset);
	if (mem == NULL) {
		rc = -1;
		goto out;
	}
 
	rc = command(mem, bytes, offset);
 
	unmap(dev_fd, mem, bytes);
 
out:
	return rc;
}