int main(int argc, char** argv)
{
struct eeprom e;
int op;
op = 0;
usage_if(argc != 2 || argv[1][0] != '-' || argv[1][2] != '\0');
op = argv[1][1];
fprintf(stderr, "Open /dev/i2c/0 with 8bit mode\n");
die_if(eeprom_open("/dev/i2c/0", 0x50, EEPROM_TYPE_8BIT_ADDR, &e) < 0,
"unable to open eeprom device file "
"(check that the file exists and that it's readable)");
switch(op)
{
case 'r':
fprintf(stderr, " Reading 256 bytes from 0x0\n");
read_from_eeprom(&e, 0, 256);
break;
case 'w':
fprintf(stderr, " Writing 0x00-0xff into 24C08 \n");
write_to_eeprom(&e, 0);
break;
default:
usage_if(1);
exit(1);
}
eeprom_close(&e);
return 0;
}
int main(int argc, char** argv)
{
int r = 0;
int i, j;
unsigned char testbuf[MAXTEST], rxbuf[MAXTEST];
int testtimes = 0;
int errors = 0;
r = eeprom_open();
if( r < 0 ){
printf("eeprom open failed!\n");
exit(1);
}
//for(;;){
r = eeprom_read_buf(0x0, MAXTEST, rxbuf);
if( r < 0 ){
printf("eeprom read failed!\n");
exit(1);
}
printf("\nThe EEPROM contents:\n ");
for(i = 0; i < 16; i ++){
printf(" %02x ", i);
}
printf("\n[00]: ");
for(i = 1, j = 1; i <= MAXTEST; i ++){
printf("0x%02x,", rxbuf[i-1]);
if(i %16 == 0){
if(i < MAXTEST) printf("\n[%02x]: ", j++);
else printf("\n");
}
}
printf("\n");
//}
eeprom_close();
}
int main(int argc, char **argv) {
struct eeprom_dev *dev;
int ch;
int writing = 0;
char *tmp;
struct novena_eeprom_data_v2 newrom;
int newdata = 0;
int update_mac = 0;
int update_features = 0;
int update_serial = 0;
int update_oops_start = 0;
int update_oops_length = 0;
int update_page_size = 0;
int update_total_size = 0;
int update_lvds1 = 0;
int update_lvds2 = 0;
int update_hdmi = 0;
dev = eeprom_open(I2C_BUS, EEPROM_ADDRESS);
if (!dev)
return 1;
while ((ch = getopt(argc, argv, "hm:s:f:wo:p:l:1:2:d:e:i:")) != -1) {
switch(ch) {
/* MAC address */
case 'm':
if (parse_mac(optarg, newrom.mac))
return 1;
update_mac = 1;
break;
/* Serial number */
case 's':
newrom.serial = strtoul(optarg, NULL, 0);
update_serial = 1;
break;
/* Featuresset */
case 'f':
newrom.features = parse_features(optarg);
if (newrom.features == -1)
return 1;
update_features = 1;
break;
case 'o':
newrom.eepromoops_offset = strtoul(optarg, &tmp, 0);
update_oops_start = 1;
if (tmp && *tmp) {
newrom.eepromoops_length = strtoul(tmp + 1,
NULL, 0);
update_oops_length = 1;
}
break;
case 'p':
newrom.page_size = strtoul(optarg, NULL, 0);
update_page_size = 1;
break;
case 'l':
newrom.eeprom_size = strtoul(optarg, NULL, 0);
update_total_size = 1;
break;
case '1':
if (parse_modesetting(&newrom.lvds1, optarg))
return 1;
update_lvds1 = 1;
break;
case '2':
if (parse_modesetting(&newrom.lvds2, optarg))
return 1;
update_lvds2 = 1;
break;
case 'd':
if (parse_modesetting(&newrom.hdmi, optarg))
return 1;
update_hdmi = 1;
break;
case 'e':
return eeprom_export(dev, optarg);
case 'i':
if (eeprom_import(dev, optarg))
return 1;
newdata = 1;
break;
/* Write data */
case 'w':
writing = 1;
break;
case 'h':
print_usage(argv[0]);
return 1;
default:
printf("Unrecognized option: %c\n", ch);
print_usage(argv[0]);
return 1;
}
}
argc -= optind;
argv += optind;
if (update_mac || update_serial || update_features ||
update_oops_start || update_oops_length ||
update_page_size || update_total_size ||
update_lvds1 || update_lvds2 || update_hdmi)
newdata = 1;
if (argc)
print_usage(argv[0]);
else if (!writing) {
if (newdata)
printf("Not writing data, as -w was not specified\n");
printf("Current EEPROM settings:\n");
print_eeprom_data(dev);
}
else {
int ret;
ret = eeprom_read(dev);
if (ret)
return 1;
if (dev->data.v1.version == 1) {
printf("Updating v1 EEPROM to v2...\n");
eeprom_upgrade_v1_to_v2(dev);
}
else if (dev->data.v1.version == 2) {
/* Ignore v2 */;
}
else {
if (memcmp(dev->data.v2.signature, NOVENA_SIGNATURE,
sizeof(dev->data.v2.signature)))
printf("Blank EEPROM found, "
"setting defaults...\n");
else
fprintf(stderr,
"Unrecognized EEPROM version found "
"(v%d), overwriting with v2\n",
dev->data.v1.version);
eeprom_get_defaults(dev);
}
if (update_mac)
memcpy(&dev->data.v2.mac, newrom.mac, sizeof(newrom.mac));
if (update_serial)
dev->data.v2.serial = newrom.serial;
if (update_features)
dev->data.v2.features = newrom.features;
if (update_oops_start)
dev->data.v2.eepromoops_offset = newrom.eepromoops_offset;
if (update_oops_length)
dev->data.v2.eepromoops_length = newrom.eepromoops_length;
if (update_page_size)
dev->data.v2.page_size = newrom.page_size;
if (update_total_size)
dev->data.v2.eeprom_size = newrom.eeprom_size;
if (update_lvds1)
memcpy(&dev->data.v2.lvds1, &newrom.lvds1,
sizeof(dev->data.v2.lvds1));
if (update_lvds2)
memcpy(&dev->data.v2.lvds2, &newrom.lvds2,
sizeof(dev->data.v2.lvds2));
if (update_hdmi)
memcpy(&dev->data.v2.hdmi, &newrom.hdmi,
sizeof(dev->data.v2.hdmi));
memcpy(&dev->data.v2.signature,
NOVENA_SIGNATURE,
sizeof(dev->data.v2.signature));
dev->data.v2.version = 2;
ret = eeprom_write(dev);
if (ret) {
printf("EEPROM write failed\n");
return 1;
}
printf("Updated EEPROM. New values:\n");
print_eeprom_data(dev);
}
eeprom_close(&dev);
return 0;
}
int main(int argc, char** argv)
{
struct eeprom e;
int ret, op, i2c_addr, memaddr, size, want_hex, dummy, force, sixteen;
char *device, *arg = 0, *i2c_addr_s;
struct stat st;
int eeprom_type = 0;
op = want_hex = dummy = force = sixteen = 0;
g_quiet = 0;
while((ret = getopt(argc, argv, "1:8fr:qhw:xd")) != -1)
{
switch(ret)
{
case '1':
usage_if(*optarg != '6' || strlen(optarg) != 1);
die_if(eeprom_type, "EEPROM type switch (-8 or -16) used twice");
eeprom_type = EEPROM_TYPE_16BIT_ADDR;
break;
case 'x':
want_hex++;
break;
case 'd':
dummy++;
break;
case '8':
die_if(eeprom_type, "EEPROM type switch (-8 or -16) used twice");
eeprom_type = EEPROM_TYPE_8BIT_ADDR;
break;
case 'f':
force++;
break;
case 'q':
g_quiet++;
break;
case 'h':
usage_if(1);
break;
default:
die_if(op != 0, "Both read and write requested");
arg = optarg;
op = ret;
}
}
if(!eeprom_type)
eeprom_type = EEPROM_TYPE_8BIT_ADDR; // default
usage_if(op == 0); // no switches
// set device and i2c_addr reading from cmdline or env
device = i2c_addr_s = 0;
switch(argc - optind)
{
case 0:
device = getenv(ENV_DEV);
i2c_addr_s = getenv(ENV_I2C_ADDR);
break;
case 1:
if(stat(argv[optind], &st) != -1)
{
device = argv[optind];
i2c_addr_s = getenv(ENV_I2C_ADDR);
} else {
device = getenv(ENV_DEV);
i2c_addr_s = argv[optind];
}
break;
case 2:
device = argv[optind++];
i2c_addr_s = argv[optind];
break;
default:
usage_if(1);
}
usage_if(!device || !i2c_addr_s);
i2c_addr = strtoul(i2c_addr_s, 0, 0);
print_info("eeprog %s, a 24Cxx EEPROM reader/writer\n", VERSION);
print_info("Copyright (c) 2003 by Stefano Barbato - All rights reserved.\n");
print_info(" Bus: %s, Address: 0x%x, Mode: %dbit\n",
device, i2c_addr,
(eeprom_type == EEPROM_TYPE_8BIT_ADDR ? 8 : 16) );
if(dummy)
{
fprintf(stderr, "Dummy mode selected, nothing done.\n");
return 0;
}
die_if(eeprom_open(device, i2c_addr, eeprom_type, &e) < 0,
"unable to open eeprom device file (check that the file exists and that it's readable)");
switch(op)
{
case 'r':
if(force == 0)
confirm_action();
size = 1; // default
parse_arg(arg, &memaddr, &size);
print_info(" Reading %d bytes from 0x%x\n", size, memaddr);
read_from_eeprom(&e, memaddr, size, want_hex);
break;
case 'w':
if(force == 0)
confirm_action();
parse_arg(arg, &memaddr, &size);
print_info(" Writing stdin starting at address 0x%x\n",
memaddr);
write_to_eeprom(&e, memaddr);
break;
default:
usage_if(1);
exit(1);
}
eeprom_close(&e);
return 0;
}
