Esempio n. 1
0
static int do_memset(int argc, char *argv[])
{
	loff_t	s, c, n;
	int     fd;
	char   *buf;
	int	mode  = O_RWSIZE_1;
	int     ret = 1;
	char	*file = "/dev/mem";

	if (mem_parse_options(argc, argv, "bwlqd:", &mode, NULL, &file,
			NULL) < 0)
		return 1;

	if (optind + 3 > argc)
		return COMMAND_ERROR_USAGE;

	s = strtoull_suffix(argv[optind], NULL, 0);
	c = strtoull_suffix(argv[optind + 1], NULL, 0);
	n = strtoull_suffix(argv[optind + 2], NULL, 0);

	fd = open_and_lseek(file, mode | O_WRONLY, s);
	if (fd < 0)
		return 1;

	buf = xmalloc(RW_BUF_SIZE);
	memset(buf, c, RW_BUF_SIZE);

	while (n > 0) {
		int now;

		now = min((loff_t)RW_BUF_SIZE, n);

		ret = write(fd, buf, now);
		if (ret < 0) {
			perror("write");
			ret = 1;
			goto out;
		}

		n -= now;
	}

	ret = 0;
out:
	close(fd);
	free(buf);

	return ret;
}
Esempio n. 2
0
static int art_read_mac(struct device_d *dev, const char *file)
{
	int fd, rbytes;
	struct ar9300_eeprom eeprom;

	fd = open_and_lseek(file, O_RDONLY, AR93000_EPPROM_OFFSET);
	if (fd < 0) {
		dev_err(dev, "Failed to open eeprom path %s %d\n",
		       file, fd);
		return fd;
	}

	rbytes = read_full(fd, &eeprom, sizeof(eeprom));
	close(fd);
	if (rbytes < sizeof(eeprom)) {
		dev_err(dev, "Failed to read %s\n", file);
		return rbytes < 0 ? rbytes : -EIO;
	}

	dev_dbg(dev, "ART version: %x.%x\n",
		 eeprom.eeprom_version, eeprom.template_version);
	dev_dbg(dev, "mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
	       eeprom.mac_addr[0],
	       eeprom.mac_addr[1],
	       eeprom.mac_addr[2],
	       eeprom.mac_addr[3],
	       eeprom.mac_addr[4],
	       eeprom.mac_addr[5]);

	if (!is_valid_ether_addr(&eeprom.mac_addr[0])) {
		dev_err(dev, "bad MAC addr\n");
		return -EILSEQ;
	}

	return art_set_mac(dev, &eeprom);
}
Esempio n. 3
0
static int do_mem_mm(int argc, char *argv[])
{
	int ret = 0;
	int fd;
	char *filename = "/dev/mem";
	int mode = O_RWSIZE_4;
	loff_t adr;
	int swab = 0;
	u8 val8;
	u16 val16;
	u32 val32;
	u64 val64;
	u64 value, mask;

	if (mem_parse_options(argc, argv, "bwlqd:", &mode, NULL, &filename,
			&swab) < 0)
		return 1;

	if (optind + 2 >= argc)
		return COMMAND_ERROR_USAGE;

	adr = strtoull_suffix(argv[optind++], NULL, 0);
	value = simple_strtoull(argv[optind++], NULL, 0);
	mask = simple_strtoull(argv[optind++], NULL, 0);

	fd = open_and_lseek(filename, mode | O_RDWR, adr);
	if (fd < 0)
		return 1;

	switch (mode) {
	case O_RWSIZE_1:
		ret = pread(fd, &val8, 1, adr);
		if (ret < 0)
			goto out_read;
		val8 &= ~mask;
		val8 |= (value & mask);
		ret = pwrite(fd, &val8, 1, adr);
		if (ret < 0)
			goto out_write;
		break;
	case O_RWSIZE_2:
		ret = pread(fd, &val16, 2, adr);
		if (ret < 0)
			goto out_read;
		val16 &= ~mask;
		val16 |= (value & mask);
		ret = pwrite(fd, &val16, 2, adr);
		if (ret < 0)
			goto out_write;
		break;
	case O_RWSIZE_4:
		if (ret < 0)
			goto out_read;
		ret = pread(fd, &val32, 4, adr);
		val32 &= ~mask;
		val32 |= (value & mask);
		ret = pwrite(fd, &val32, 4, adr);
		if (ret < 0)
			goto out_write;
		break;
	case O_RWSIZE_8:
		if (ret < 0)
			goto out_read;
		ret = pread(fd, &val64, 8, adr);
		val64 &= ~mask;
		val64 |= (value & mask);
		ret = pwrite(fd, &val64, 8, adr);
		if (ret < 0)
			goto out_write;
		break;
	}

	close(fd);

	return 0;

out_read:
	perror("read");
	close(fd);
	return 1;

out_write:
	perror("write");
	close(fd);
	return 1;
}