int ARCH_MAINDECL main(int argc, char *argv[])
{
__u_char drv = argc > 1 ? arch_atoc(argv[1]) : 8;
CBM_FILE fd;
if(cbm_driver_open(&fd, 0) == 0)
{
cbm_upload(fd, drv, 0x0500, flash, sizeof(flash));
cbm_exec_command(fd, drv, "U3:", 0);
cbm_driver_close(fd);
return 0;
}
return 1;
}
int ARCH_MAINDECL main(int argc, char *argv[])
{
d64copy_settings *settings = d64copy_get_default_settings();
char *tm = NULL;
char *src_arg;
char *dst_arg;
int c;
int rv = 1;
int l;
int src_is_cbm;
int dst_is_cbm;
struct option longopts[] =
{
{ "help" , no_argument , NULL, 'h' },
{ "version" , no_argument , NULL, 'V' },
{ "warp" , no_argument , NULL, 'w' },
{ "no-warp" , no_argument , &settings->warp, 0 },
{ "quiet" , no_argument , NULL, 'q' },
{ "verbose" , no_argument , NULL, 'v' },
{ "no-progress", no_argument , NULL, 'n' },
{ "interleave" , required_argument, NULL, 'i' },
{ "start-track", required_argument, NULL, 's' },
{ "end-track" , required_argument, NULL, 'e' },
{ "transfer" , required_argument, NULL, 't' },
{ "bam-only" , no_argument , NULL, 'b' },
{ "bam-save" , no_argument , NULL, 'B' },
{ "drive-type" , required_argument, NULL, 'd' },
{ "retry-count", required_argument, NULL, 'r' },
{ "two-sided" , no_argument , NULL, '2' },
{ "error-map" , required_argument, NULL, 'E' },
{ NULL , 0 , NULL, 0 }
};
const char shortopts[] ="hVwqbBt:i:s:e:d:r:2vnE:";
while((c=getopt_long(argc, argv, shortopts, longopts, NULL)) != -1)
{
switch(c)
{
case 'h': help();
return 0;
case 'V': printf("d64copy %s\n", OPENCBM_VERSION);
return 0;
case 'w': settings->warp = 1;
break;
case 'q': if(verbosity > 0) verbosity--;
break;
case 'v': verbosity++;
break;
case 'n': no_progress = 1;
break;
case 'i': settings->interleave = arch_atoc(optarg);
break;
case 's': settings->start_track = atoi(optarg);
break;
case 'e': settings->end_track = atoi(optarg);
break;
case 't': tm = optarg;
break;
case 'b': settings->bam_mode = bm_allocated;
break;
case 'B': settings->bam_mode = bm_save;
break;
case 'd': if(strcmp(optarg, "1541") == 0)
{
settings->drive_type = cbm_dt_cbm1541;
}
else if(strcmp(optarg, "1571") == 0)
{
settings->drive_type = cbm_dt_cbm1571;
}
else if(strcmp(optarg, "1570") == 0)
{
settings->drive_type = cbm_dt_cbm1570;
}
else
{
settings->drive_type = atoi(optarg) != 0 ?
cbm_dt_cbm1571 : cbm_dt_cbm1541;
}
break;
case 'r': settings->retries = atoi(optarg);
break;
case '2': settings->two_sided = 1;
break;
case 'E': l = strlen(optarg);
if(strncmp(optarg, "always", l) == 0)
{
settings->error_mode = em_always;
}
else if(strncmp(optarg, "on_errors", l) == 0)
{
settings->error_mode = em_on_error;
}
else if(strncmp(optarg, "never", l) == 0)
{
settings->error_mode = em_never;
}
else
{
hint(argv[0]);
return 1;
}
break;
case 0: break; // needed for --no-warp
default : hint(argv[0]);
return 1;
}
}
settings->transfer_mode = d64copy_get_transfer_mode_index(tm);
if(settings->transfer_mode < 0)
{
char *modes = d64copy_get_transfer_modes();
char *m;
fprintf(stderr, "Unknown transfer mode: %s\nAvailable modes:\n", tm);
for(m = modes; *m; m+=(strlen(m)+1))
{
fprintf(stderr, " %s\n", m);
}
free(modes);
return 1;
}
my_message_cb(3, "transfer mode is %d", settings->transfer_mode );
if(optind + 2 != argc)
{
fprintf(stderr, "Usage: %s [OPTION]... [SOURCE] [TARGET]\n", argv[0]);
hint(argv[0]);
return 1;
}
src_arg = argv[optind];
dst_arg = argv[optind+1];
src_is_cbm = is_cbm(src_arg);
dst_is_cbm = is_cbm(dst_arg);
if(src_is_cbm == dst_is_cbm)
{
my_message_cb(0, "either source or target must be a CBM drive");
return 1;
}
if(cbm_driver_open(&fd_cbm, 0) == 0)
{
/*
* If the user specified auto transfer mode, find out
* which transfer mode to use.
*/
settings->transfer_mode =
d64copy_check_auto_transfer_mode(fd_cbm,
settings->transfer_mode,
atoi(src_is_cbm ? src_arg : dst_arg));
my_message_cb(3, "decided to use transfer mode %d", settings->transfer_mode );
signal(SIGINT, reset);
if(src_is_cbm)
{
rv = d64copy_read_image(fd_cbm, settings, atoi(src_arg), dst_arg,
my_message_cb, my_status_cb);
}
else
{
rv = d64copy_write_image(fd_cbm, settings, src_arg, atoi(dst_arg),
my_message_cb, my_status_cb);
}
if(!no_progress && rv >= 0)
{
printf("\n%d blocks copied.\n", rv);
}
cbm_driver_close(fd_cbm);
rv = 0;
}
else
{
arch_error(0, arch_get_errno(), "%s", cbm_get_driver_name(0));
}
free(settings);
return rv;
}
static int
main_testlines(int argc, char **argv)
{
/* CBM_FILE fd; */
int rv;
FUNC_ENTER();
do
{
rv = cbm_driver_open(&fd, 0);
if (rv != 0)
break;
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Releasing all lines"));
cbm_iec_release(fd, IEC_CLOCK | IEC_DATA | IEC_ATN | IEC_RESET);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Setting CLOCK"));
cbm_iec_set(fd, IEC_CLOCK);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Setting DATA"));
cbm_iec_set(fd, IEC_DATA);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Setting ATN"));
cbm_iec_set(fd, IEC_ATN);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Setting RESET"));
cbm_iec_set(fd, IEC_RESET);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Releasing CLOCK"));
cbm_iec_release(fd, IEC_CLOCK);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Releasing DATA"));
cbm_iec_release(fd, IEC_DATA);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Releasing ATN"));
cbm_iec_release(fd, IEC_ATN);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Releasing RESET"));
cbm_iec_release(fd, IEC_RESET);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Setting DATA and ATN"));
cbm_iec_set(fd, IEC_DATA | IEC_ATN);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Setting CLOCK, releasing ATN"));
cbm_iec_setrelease(fd, IEC_ATN | IEC_CLOCK, IEC_CLOCK);
read_line_status(fd);
DBG_PRINT((DBG_PREFIX ""));
DBG_PRINT((DBG_PREFIX "Releasing all lines"));
cbm_iec_release(fd, IEC_CLOCK | IEC_DATA | IEC_ATN | IEC_RESET);
read_line_status(fd);
} while (0);
if (rv == 0)
cbm_driver_close(fd);
FUNC_LEAVE_INT(0);
}
int main(int argc, char **argv)
{
int ret, n;
unsigned char drive = 8;
CBM_FILE f;
char buffer[80];
char *devicetype_str;
const char *drivername;
enum cbm_device_type_e devicetype;
int checklines = 0;
int checkiohook = 0;
if (argc>1)
{
int i;
for (i=0; i < argc; i++)
{
switch (argv[i][0])
{
case '-':
checklines = 1;
break;
case '+':
checkiohook = 1;
break;
default:
drive = atoi(argv[i]);
}
}
}
printf("VDDTEST " __DATE__ " " __TIME__ ", using drive %u\n", drive);
if (vdd_init())
{
printf("Could not initialize the VDD, aborting!\n");
exit(1);
}
drivername = cbm_get_driver_name(0);
printf("cbm_get_driver_name() returned %s.\n", drivername);
ret = cbm_driver_open(&f, 0);
if (ret)
{
printf("cbm_driver_open FAILED!\n");
exit(1);
}
printf("cbm_driver_open success!\n\n");
n = cbm_reset(f);
printf("cbm_reset %s\n", n==0 ? "success" : "FAILED");
if (checklines)
{
changelines(f);
}
n = cbm_device_status(f, drive, buffer, sizeof(buffer));
printf("cbm_device_status returned: %u\n%s\n\n", n, buffer);
n = cbm_open(f, drive, 15, "I0", 0);
printf("cbm_open %u,15,\"I0\" %s!\n", drive, n == 0 ? "success" : "FAILED");
n = cbm_close(f, drive, 15);
printf("cbm_close %s!\n", n == 0 ? "success" : "FAILED");
n = own_device_status(f, drive, buffer, sizeof(buffer));
printf("own_device_status returned: %u\n%s\n\n", n, buffer);
n = cbm_identify(f, drive, &devicetype, &devicetype_str);
printf("cbm_identify %s!\n", n==0 ? "success" : "FAILED");
printf("cbm_identify returned: %u - '%s'.\n\n", (unsigned int) devicetype,
devicetype_str);
n = cbm_exec_command(f, drive, "S0:OPENCBM.VDD", 0);
printf("cbm_exec_command(scratch) %s!\n", n==0 ? "success" : "FAILED");
writefile(f, drive, "OPENCBM.VDD,S,W");
readfile(f, drive, "OPENCBM.VDD,S,R");
morse(f, drive);
if (checkiohook)
{
unsigned int base = 0x0fc0;
printf("trying to install iohook at 0x%08x ", base);
if (vdd_install_iohook(f, base, 1))
{
int i;
printf("success\n");
for (i=0; i<15; i++)
{
outportb(base + 2, i);
sleep(1);
}
printf("trying to uninstall iohook ");
if (vdd_uninstall_iohook(f))
{
printf("success\n");
}
else
{
printf("FAILED\n");
}
}
else
{
printf("FAILED\n");
}
}
cbm_driver_close(f);
printf("cbm_driver_close success!\n");
return 0;
}
static int
main_testtransfer(int argc, char **argv)
{
/* CBM_FILE fd; */
unsigned char compare_buffer[0x8000];
unsigned char buffer[0x8000];
unsigned int error = 0;
int rv;
#if DBG
DbgFlags = 0x0;
#endif
printf(" libtransfer sample: " __DATE__ " " __TIME__ "\n");
if (argc > 1)
{
processParameter(argc, argv);
}
rv = cbm_driver_open(&fd, 0);
if(rv != 0)
{
DBG_ERROR((DBG_PREFIX "cbm_driver_open() failed!"));
return 1;
}
DBG_PRINT((DBG_PREFIX "before install"));
libopencbmtransfer_install(fd, drive);
memset(buffer, 0, sizeof(buffer));
if (compare)
read_from_file(compare_buffer, sizeof(compare_buffer), "rom.image");
DBG_PRINT((DBG_PREFIX "before read_mem"));
#if 0
transferlength = 0x100;
printf("write $0300\n");
libopencbmtransfer_write_mem(fd, drive, compare_buffer, 0x300, transferlength);
printf("read $0300\n");
libopencbmtransfer_read_mem(fd, drive, buffer, 0x300, transferlength);
printf("compare\n");
if (memcmp(buffer, compare_buffer, transferlength) != 0)
{
printf("differing!\n");
}
#else
while (count--)
{
printf("read: %i, error = %u: \n", count+1, error);
libopencbmtransfer_read_mem(fd, drive, buffer, 0x8000, transferlength);
if (compare)
{
if (memcmp(buffer, compare_buffer, transferlength) != 0)
{
char filename[128];
int n;
printf("\n\n***** ERROR COMPARING DATA! *****\n\n");
++error;
strcpy(filename, "image.err.");
n = strlen(filename);
if (error > 9999) filename[n++] = ((error / 10000) % 10) + '0';
if (error > 999) filename[n++] = ((error / 1000) % 10) + '0';
if (error > 99) filename[n++] = ((error / 100) % 10) + '0';
if (error > 9) filename[n++] = ((error / 10) % 10) + '0';
if (error > 0) filename[n++] = ((error / 1) % 10) + '0';
filename[n] = 0;
write_to_file(buffer, transferlength, filename);
}
else
{
printf(" compare success\n");
}
}
printf("write: %i, error = %u: \n", count+1, error);
libopencbmtransfer_write_mem(fd, drive, compare_buffer, 0x8000, transferlength);
}
#endif
if (outputdump)
DBG_MEMDUMP("8000:", buffer, transferlength + 0x10);
if (writedumpfile)
write_to_file(buffer, transferlength, "image.bin");
DBG_PRINT((DBG_PREFIX "before remove"));
libopencbmtransfer_remove(fd, drive);
cbm_driver_close(fd);
FUNC_LEAVE_INT(0);
}
