static void ARCH_SIGNALDECL
handle_CTRL_C(int dummy)
{
CBM_FILE fd_cbm_local;
/*
* remember fd_cbm, and make the global one invalid
* so that no routine can call a cbm_...() routine
* once we have cancelled another one
*/
fd_cbm_local = fd;
fd = CBM_FILE_INVALID;
fprintf(stderr, "\nSIGINT caught, resetting IEC bus...\n");
DEBUG_PRINTDEBUGCOUNTERS();
arch_sleep(1);
cbm_reset(fd_cbm_local);
#if 0 // reset automatically restores the VIA shift register
arch_usleep(100000);
fprintf(stderr, "Emergency resetting VIA2 shift register to default.\n");
cbm_exec_command(fd, drive, CmdBuffer, sizeof(CmdBuffer));
#endif
cbm_driver_close(fd);
exit(1);
}
static void ARCH_SIGNALDECL reset(int dummy)
{
fprintf(stderr, "\nSIGINT caught X-( Resetting IEC bus...\n");
arch_sleep(1);
d64copy_cleanup();
cbm_reset(fd_cbm);
cbm_driver_close(fd_cbm);
exit(1);
}
static void ARCH_SIGNALDECL
reset(int dummy)
{
if (fd != CBM_FILE_INVALID)
{
cbm_reset(fd);
cbm_driver_close(fd);
}
exit(1);
}
static void ARCH_SIGNALDECL
handle_CTRL_C(int dummy)
{
fprintf(stderr, "\nSIGINT caught, resetting IEC bus...\n");
DEBUG_PRINTDEBUGCOUNTERS();
arch_sleep(1);
cbm_reset(fd);
cbm_driver_close(fd);
exit(1);
}
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;
}
static void ARCH_SIGNALDECL reset(int dummy)
{
CBM_FILE fd_cbm_local;
/*
* remember fd_cbm, and make the global one invalid
* so that no routine can call a cbm_...() routine
* once we have cancelled another one
*/
fd_cbm_local = fd_cbm;
fd_cbm = CBM_FILE_INVALID;
fprintf(stderr, "\nSIGINT caught X-( Resetting IEC bus...\n");
DEBUG_PRINTDEBUGCOUNTERS();
cbm_reset(fd_cbm_local);
cbm_driver_close(fd_cbm_local);
exit(1);
}
//
// abort signal trap
//
static void ARCH_SIGNALDECL reset(int dummy)
{
CBM_FILE fd_cbm_local;
/*
* remember fd_cbm, and make the global one invalid
* so that no routine can call a cbm_...() routine
* once we have cancelled another one
*/
fd_cbm_local = fd_cbm;
fd_cbm = CBM_FILE_INVALID;
fprintf(stderr, "\nSIGINT caught X-( Resetting IEC bus...\n");
#ifdef LIBIMGCOPY_DEBUG
printDebugLibImgCounters(my_message_cb);
#endif
imgcopy_cleanup();
cbm_reset(fd_cbm_local);
cbm_driver_close(fd_cbm_local);
exit(1);
}
int ARCH_MAINDECL main(int argc, char **argv)
{
CBM_FILE fd;
FILE *file;
char *fname;
int mode;
int c;
unsigned char *filedata;
size_t filesize;
char buf[48];
int num_entries;
int num_files;
int rv;
int i;
int write;
cbmcopy_settings *settings;
char auto_name[17];
char auto_type = '\0';
char output_type = '\0';
char *tail;
char *ext;
char *adapter = NULL;
unsigned char drive;
const char *tm = NULL;
const char *dt = NULL;
int force_raw = 0;
int address = -1;
const char *output_name = NULL;
const char *address_str = NULL;
char *fs_name;
input_reader *readers[] =
{
&cbmwrite_raw, /* must be first, as it is default */
&cbmwrite_pc64,
&cbmwrite_t64,
NULL
};
input_reader *rd;
struct option longopts[] =
{
{ "help" , no_argument , NULL, 'h' },
{ "verbose" , no_argument , NULL, 'v' },
{ "adapter" , required_argument, NULL, '@' },
{ "quiet" , no_argument , NULL, 'q' },
{ "version" , no_argument , NULL, 'V' },
{ "no-progress" , no_argument , NULL, 'n' },
{ "read" , no_argument , NULL, 'r' },
{ "write" , no_argument , NULL, 'w' },
{ "transfer" , required_argument, NULL, 't' },
{ "drive-type" , required_argument, NULL, 'd' },
{ "file-type" , required_argument, NULL, 'f' },
{ "output" , required_argument, NULL, 'o' },
{ "raw" , no_argument , NULL, 'R' },
{ "address" , no_argument , NULL, 'a' },
{ NULL , 0 , NULL, 0 }
};
const char shortopts[] ="hVqvrwnt:d:f:o:Ra:@:";
if(NULL == (tail = strrchr(argv[0], '/')))
{
tail = argv[0];
}
else
{
tail++;
}
if(strcmp(tail, "cbmread") == 0)
{
mode = 'r'; /* read */
}
else if(strcmp(tail, "cbmwrite") == 0)
{
mode = 'w'; /* write */
}
else
{
mode = EOF; /* mode must be given later */
}
settings = cbmcopy_get_default_settings();
/* loop over cmd line opts */
while((c=getopt_long(argc, argv, shortopts, longopts, NULL)) != -1)
{
switch(c)
{
case 'h': /* --help */
help(argv[0]);
return 0;
case 'V': /* --version */
printf("cbmcopy %s\n", OPENCBM_VERSION);
return 0;
case 'q': /* -- quiet */
if(verbosity > sev_fatal)
verbosity--;
break;
case 'v': /* --verbose */
if(verbosity < sev_debug)
verbosity++;
break;
case 'n': /* --no-progress */
no_progress = 1;
break;
case 'r': /* --read */
case 'w': /* --write */
if(mode != EOF)
{
my_message_cb(sev_fatal, "-r/-w given more than once");
hint(argv[0]);
return 1;
}
mode = c;
break;
case 't': /* --transfer */
char_star_opt_once(&tm, "--transfer", argv);
break;
case 'd': /* --drive-type */
char_star_opt_once(&dt, "--drive-type", argv);
break;
case 'o': /* --output */
char_star_opt_once(&output_name, "--output", argv);
break;
case 'f': /* --file-type */
output_type = (char) toupper(*optarg);
break;
case 'R': /* --raw */
force_raw = 1;
break;
case 'a': /* override-address */
char_star_opt_once(&address_str, "--address", argv);
break;
case '@': /* choose adapter */
if (adapter == NULL)
adapter = cbmlibmisc_strdup(optarg);
else {
my_message_cb(sev_fatal, "--adapter/-@ given more than once.");
hint(argv[0]);
exit(1);
}
break;
default : /* unknown */
hint(argv[0]);
return 1;
}
}
/* check -r/-w */
switch(mode)
{
case 'r' :
write = 0;
break;
case 'w' :
write = 1;
break;
default:
my_message_cb(sev_fatal,
"-r or -w must be given when started as `%s'",
argv[0]);
hint(argv[0]);
return 1;
}
/* check transfer mode */
settings->transfer_mode = cbmcopy_get_transfer_mode_index(tm);
if(settings->transfer_mode < 0)
{
my_message_cb(sev_fatal, "Unknown transfer mode: %s", tm);
return 1;
}
/* check device type */
if(dt)
{
const struct
{
const char *str;
enum cbm_device_type_e type;
}
*p, types[] =
{
{ "1541", cbm_dt_cbm1541 }, { "1571", cbm_dt_cbm1571 },
{ "1570", cbm_dt_cbm1570 }, { "1581", cbm_dt_cbm1581 },
{ NULL , cbm_dt_unknown }
};
for(p = types; p->str && strcmp(dt, p->str); p++)
; /* nothing */
if(!p->str)
{
my_message_cb(sev_fatal, "Unknown drive type: %s", dt);
return 1;
}
settings->drive_type = p->type;
}
/* check CBM file type */
if(output_type)
{
if(write)
{
if(strchr("DSPU", output_type) == NULL)
{
my_message_cb(sev_fatal, "Invalid file type : %c", output_type);
}
}
else
{
my_message_cb(sev_warning, "--file-type ignored");
}
}
/* check load address override */
if(address_str)
{
address = strtol(address_str, &tail, 0);
if(*tail || address < 0 || address > 0xffff)
{
my_message_cb(sev_fatal, "--address invalid: %s", address_str);
hint(argv[0]);
return 1;
}
}
/* first non-option is device number */
if(optind == argc)
{
my_message_cb(sev_fatal, "%s: No drive number given", argv[0]);
hint(argv[0]);
return 1;
}
drive = (unsigned char) strtol(argv[optind], &tail, 0);
if(drive < 8 || drive > 11 || *tail)
{
my_message_cb(sev_fatal, "invalid drive: `%s'", argv[optind]);
return 1;
}
/* remaining args are file names */
num_files = argc - optind - 1;
if(num_files == 0)
{
my_message_cb(sev_fatal, "%s: No files?", argv[0]);
hint(argv[0]);
return 1;
}
/* more than one file name given, avoid -o option */
if(num_files > 1 && output_name)
{
my_message_cb(sev_fatal, "--output requires exactly one file name");
return 1;
}
rv = cbm_driver_open_ex( &fd, adapter );
cbmlibmisc_strfree(adapter);
if(0 == rv)
{
fd_cbm = fd;
/*
* If the user specified auto transfer mode, find out
* which transfer mode to use.
*/
settings->transfer_mode =
cbmcopy_check_auto_transfer_mode(fd_cbm,
settings->transfer_mode,
drive);
arch_set_ctrlbreak_handler(reset);
while(++optind < argc)
{
fname = argv[optind];
if(write)
{
rd = readers[0];
file = fopen(fname, "rb");
if(file)
{
num_entries = 0;
if(!force_raw)
{
/* try to detect file format */
for(i = 1; readers[i] && !num_entries; i++)
{
num_entries =
readers[i]->probe( file, fname, my_message_cb );
if(num_entries)
rd = readers[i];
}
}
if(!num_entries) num_entries = 1; /* raw file */
for(i = 0; i < num_entries; i++)
{
my_message_cb( sev_debug,
"processing entry %d from %s",
i, fname );
if(rd->read(file, fname, i,
auto_name, &auto_type,
&filedata, &filesize, my_message_cb ) == 0)
{
buf[16] = '\0';
if(output_name)
{
strncpy(buf, output_name, 16);
cbm_ascii2petscii(buf);
}
else
{
/* no charset conversion */
strncpy(buf, auto_name, 16);
}
strcat(buf, ",x");
buf[strlen(buf)-1] =
output_type ? output_type : auto_type;
strcat(buf, ",W");
my_message_cb( sev_info,
"writing %s -> %s", fname, buf );
if(address >= 0 && filesize > 1)
{
filedata[0] = address % 0x100;
filedata[1] = address / 0x100;
my_message_cb( sev_debug,
"override address: $%02x%02x",
filedata[1], filedata[0] );
}
if(cbmcopy_write_file(fd, settings, drive,
buf, strlen(buf),
filedata, filesize,
my_message_cb,
my_status_cb) == 0)
{
printf("\n");
rv = cbm_device_status( fd, drive,
buf, sizeof(buf) );
my_message_cb( rv ? sev_warning : sev_info,
"%s", buf );
}
else
printf("\n");
if(filedata)
{
free(filedata);
}
}
else
{
my_message_cb( sev_warning,
"error processing entry %d from %s",
i, fname );
}
}
}
else
{
my_message_cb( sev_warning,
"warning could not read %s: %s",
fname, arch_strerror(arch_get_errno()) );
}
}
else
{
strncpy(buf, fname, 16);
buf[16] = '\0';
cbm_ascii2petscii(buf);
if(output_name)
{
fs_name = arch_strdup(output_name);
}
else
{
for(tail = fname; *tail && *tail != ','; tail++);
ext = "prg"; /* default */
if(*tail)
{
tail++;
switch(*tail)
{
case 'D': ext = "del"; break;
case 'S': ext = "seq"; break;
case 'U': ext = "usr"; break;
}
}
fs_name = malloc(strlen(fname) + strlen(ext) + 2);
if(fs_name) sprintf(fs_name, "%s.%s", fname, ext);
}
if(fs_name)
{
for(tail = fs_name; *tail; tail++)
{
if(*tail == '/') *tail = '_';
}
}
else
{
/* should not happen... */
cbm_driver_close( fd );
my_message_cb(sev_fatal, "Out of memory");
exit(1);
}
my_message_cb( sev_info, "reading %s -> %s", buf, fs_name );
if(cbmcopy_read_file(fd, settings, drive, buf, strlen(buf),
&filedata, &filesize,
my_message_cb, my_status_cb) == 0)
{
rv = cbm_device_status( fd, drive, buf, sizeof(buf) );
my_message_cb( rv ? sev_warning : sev_info, "%s", buf );
file = fopen(fs_name, "wb");
if(file)
{
if(filedata)
{
if(address >= 0 && filesize > 1)
{
filedata[0] = address % 0x100;
filedata[1] = address / 0x100;
my_message_cb( sev_debug,
"override address: $%02x%02x",
filedata[1], filedata[0] );
}
if(fwrite(filedata, filesize, 1, file) != 1)
{
my_message_cb(sev_warning,
"could not write %s: %s",
fs_name, arch_strerror(arch_get_errno()));
}
}
fclose(file);
}
else
{
my_message_cb(sev_warning,
"could not open %s: %s",
fs_name, arch_strerror(arch_get_errno()));
}
if(filedata)
{
free(filedata);
}
}
else
{
my_message_cb(sev_warning, "error reading %s", buf);
}
if(fs_name)
{
free(fs_name);
}
}
}
cbm_driver_close( fd );
if(rv)
{
my_message_cb(sev_warning, "there was at least one error" );
}
}
return rv;
}
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;
}
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;
}
int ARCH_MAINDECL
main(int argc, char *argv[])
{
int status = 0;
char cmd[40];
unsigned char job = 1, begintrack = 1, endtrack = 35, retries = 5;
char c, *arg;
char *adapter = NULL;
int sector = 0, berror = 0;
struct option longopts[] =
{
{ "help" , no_argument , NULL, 'h' },
{ "version" , no_argument , NULL, 'V' },
{ "adapter" , required_argument, NULL, '@' },
{ "job" , no_argument , NULL, 'j' },
{ "retries" , required_argument, NULL, 'r' },
{ "extended" , no_argument , NULL, 'x' },
{ "retries" , required_argument, NULL, 'r' },
{ "begin-track", required_argument, NULL, 'b' },
{ "end-track" , required_argument, NULL, 'e' },
{ "sector" , required_argument, NULL, 'c' },
/*
{ "quiet" , no_argument , NULL, 'q' },
{ "verbose" , no_argument , NULL, 'v' },
{ "no-progress", no_argument , NULL, 'n' },
*/
{ NULL , 0 , NULL, 0 }
};
// const char shortopts[] ="hVj:sr:xb:e:c:qvn";
const char shortopts[] ="hVj:sxr:b:e:c:@:";
while((c=(unsigned char)getopt_long(argc, argv, shortopts, longopts, NULL)) != -1)
{
switch(c)
{
case 'h': help();
return 0;
case 'V': printf("cbmrpm41 Version %s\n", OPENCBM_VERSION ", built on " __DATE__ " at " __TIME__ "\n");
return 0;
case 'j': job = arch_atoc(optarg);
break;
case 's': status = 1;
break;
case 'x': begintrack = 1;
endtrack = 40;
break;
case 'r': retries = arch_atoc(optarg);
if(retries<1) retries = 1;
else if(retries>63) retries = 63;
break;
case 'b': begintrack = arch_atoc(optarg);
break;
case 'e': endtrack = arch_atoc(optarg);
break;
case 'c': sector = atoi(optarg);
break;
case '@': if (adapter == NULL)
adapter = cbmlibmisc_strdup(optarg);
else
{
fprintf(stderr, "--adapter/-@ given more than once.");
help();
return 0;
}
break;
default : hint(argv[0]);
return 1;
}
}
if(optind + 1 != argc)
{
fprintf(stderr, "Usage: %s [OPTION]... DRIVE\n", argv[0]);
hint(argv[0]);
return 1;
}
arg = argv[optind++];
drive = arch_atoc(arg);
if(drive < 8 || drive > 11)
{
fprintf(stderr, "Invalid drive number (%s)\n", arg);
return 1;
}
if(begintrack < 1)
{
fprintf(stderr, "Beginning track is less than 1, it should be 1 or greater.\n");
return 1;
}
if(endtrack > 42)
{
fprintf(stderr, "Ending track is greater than 42, it should be 42 or less.\n");
return 1;
}
if(begintrack > endtrack)
{
fprintf(stderr, "Beginning track is greater than ending track, it should be less or equal.");
return 1;
}
if(sector < 0)
{
fprintf(stderr, "Sector numbers less than zero are not allowed.");
return 1;
}
SETSTATEDEBUG((void)0);
printf("Please remove any diskettes used with production data on it. Insert a freshly\n"
"formatted disk into drive %d; you can format a disk with e.g. the command:\n\n"
" cbmforng -o -v %d freshdisk,fd\n\n"
"If you desperately need to examine a production disk or even an original\n"
"diskette, then please protect the disk with a write protect adhesive label.\n\n"
"Press <Enter>, when ready or press <CTRL>-C to abort.\r", drive, drive);
getchar();
if(cbm_driver_open_ex(&fd, adapter) == 0) do
{
arch_set_ctrlbreak_handler(handle_CTRL_C);
SETSTATEDEBUG((void)0);
if( cbm_upload(fd, drive, sizeof(cbmDev_StartAddress), cbmrpm41, sizeof(cbmrpm41))
!= sizeof(cbmrpm41)) break;
// location of the new U vector user commands table
sprintf(cmd, "%c%c", UcmdTblAddr & 0xFF, UcmdTblAddr >> 8);
// install the new U vector table
SETSTATEDEBUG((void)0);
if( cbm_upload(fd, drive, sizeof(cbmDev_UxCMDtVector), cmd, 2)
!= 2) break;
// execute Ux command behind the symbolic name Init23_BitTimersStd
SETSTATEDEBUG((void)0);
if( cbm_sendUxCommand(fd, drive, Init23_BitTimersStd)
!= 0) break;
// read disk ID and initialise other parameters
// from the currently inserted disk into the
// drive's RAM locations
SETSTATEDEBUG((void)0);
if( cbm_exec_command(fd, drive, "I0", 2)
!= 0) break;
SETSTATEDEBUG((void)0);
berror = cbm_device_status(fd, drive, cmd, sizeof(cmd));
if(berror && status)
{
printf("%s\n", cmd);
}
switch(job)
{
case 4:
if( do_RPMadjustment (begintrack, endtrack, sector, retries)
!= 0 ) continue; // jump to begin of do{}while(0);
break;
case 3:
if( do_RPMregression (begintrack, endtrack, sector, retries)
!= 0 ) continue; // jump to begin of do{}while(0);
break;
case 2:
if( do_SKEWmeasurment(begintrack, endtrack, sector, retries)
!= 0 ) continue; // jump to begin of do{}while(0);
break;
default:
if( do_RPMmeasurment (begintrack, endtrack, sector, retries)
!= 0 ) continue; // jump to begin of do{}while(0);
}
if( cbm_sendUxCommand(fd, drive, ResetVIA2ShiftRegConfig)
!= 0 ) break;
if( cbm_sendUxCommand(fd, drive, ResetUxVectorTable)
!= 0 ) break;
if( cbm_exec_command(fd, drive, "I", 2)
!= 0 ) break;
if(!berror && status)
{
cbm_device_status(fd, drive, cmd, sizeof(cmd));
printf("%s\n", cmd);
}
cbm_driver_close(fd);
cbmlibmisc_strfree(adapter);
return 0;
} while(0);
else
{
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);
}
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);
}
int ARCH_MAINDECL main(int argc, char *argv[])
{
CBM_FILE fd;
__int32 Status, FuncRes, RetVal = 0;
printf("\ntapcontrol v1.00 - Commodore 1530/1531 tape control\n");
printf("Copyright 2012 Arnd Menge\n\n");
if ((RetVal = EvaluateCommandlineParams(argc, argv)) == -1)
{
usage();
goto exit;
}
if (cbm_driver_open_ex(&fd, NULL) != 0)
{
printf("\nDriver error.\n");
RetVal = -1;
goto exit;
}
// Check tape firmware version compatibility.
// Status value:
// - tape firmware version
// - XUM1541_Error_NoTapeSupport
// - XUM1541_Error_NoDiskTapeMode
// - XUM1541_Error_TapeCmdInDiskMode
FuncRes = cbm_tap_get_ver(fd, &Status);
if (FuncRes != 1)
{
printf("\nReturned error [get_ver]: %d\n", FuncRes);
RetVal = -1;
goto exit2;
}
if (Status < 0)
{
printf("\nReturned error [get_ver]: ");
if (OutputError(Status) < 0)
if (OutputFuncError(Status) < 0)
printf("%d\n", Status);
RetVal = -1;
goto exit2;
}
if (Status != TapeFirmwareVersion)
{
printf("\nError [get_ver]: ");
OutputError(Tape_Status_ERROR_Wrong_Tape_Firmware);
RetVal = -1;
goto exit2;
}
if (MotorOn == 1)
{
// Status values:
// - Tape_Status_OK_Motor_On
// - Tape_Status_ERROR_Device_Disconnected
// - XUM1541_Error_NoTapeSupport
// - XUM1541_Error_NoDiskTapeMode
// - XUM1541_Error_TapeCmdInDiskMode
FuncRes = cbm_tap_motor_on(fd, &Status);
if (FuncRes != 1)
{
printf("\nReturned error [motor_on]: %d\n", FuncRes);
RetVal = -1;
}
if (Status != Tape_Status_OK_Motor_On)
{
printf("\nReturned error [motor_on]: ");
if (OutputError(Status) < 0)
if (OutputFuncError(Status) < 0)
printf("%d\n", Status);
RetVal = -1;
}
}
if (MotorOff == 1)
{
// Status values:
// - Tape_Status_OK_Motor_Off
// - Tape_Status_ERROR_Device_Disconnected
// - XUM1541_Error_NoTapeSupport
// - XUM1541_Error_NoDiskTapeMode
// - XUM1541_Error_TapeCmdInDiskMode
FuncRes = cbm_tap_motor_off(fd, &Status);
if (FuncRes != 1)
{
printf("\nReturned error [motor_off]: %d\n", FuncRes);
RetVal = -1;
}
if (Status != Tape_Status_OK_Motor_Off)
{
printf("\nReturned error [motor_off]: ");
if (OutputError(Status) < 0)
if (OutputFuncError(Status) < 0)
printf("%d\n", Status);
RetVal = -1;
}
}
exit2:
cbm_driver_close(fd);
exit:
printf("\n");
return RetVal;
}