void ftape_log_vendor_id(void)
{
TRACE_FUN(5, "ftape_log_vendor_id");
int vendor_index;
ftape_report_vendor_id(&drive_type.vendor_id);
vendor_index = lookup_vendor_id(drive_type.vendor_id);
if (drive_type.vendor_id == UNKNOWN_VENDOR &&
drive_type.wake_up == wake_up_colorado) {
vendor_index = 0;
drive_type.vendor_id = 0; /* hack to get rid of all this mail */
}
if (vendor_index < 0) {
/* Unknown vendor id, first time opening device.
* The drive_type remains set to type found at wakeup time, this
* will probably keep the driver operating for this new vendor.
*/
TRACE(-1, "============ unknown vendor id ===========");
TRACE(-1, "A new, yet unsupported tape drive is found");
TRACE(-1, "Please report the following values:");
TRACEx1(-1, " Vendor id : 0x%04x", drive_type.vendor_id);
TRACEx1(-1, " Wakeup method : %s", methods[drive_type.wake_up].name);
TRACE(-1, "And a description of your tape drive to:");
TRACE(-1, "Claus Heine <*****@*****.**>");
TRACE(-1, "==========================================");
drive_type.speed = 500; /* deci-ips: very safe value */
} else {
drive_type.name = vendors[vendor_index].name;
drive_type.speed = vendors[vendor_index].speed;
TRACEx1(3, "tape drive type: %s", drive_type.name);
/* scan all methods for this vendor_id in table */
while (drive_type.wake_up != vendors[vendor_index].wake_up) {
if (vendor_index < NR_ITEMS(vendors) - 1 &&
vendors[vendor_index + 1].vendor_id == drive_type.vendor_id) {
++vendor_index;
} else {
break;
}
}
if (drive_type.wake_up != vendors[vendor_index].wake_up) {
TRACE(-1, "==========================================");
TRACE(-1, "wakeup type mismatch:");
TRACEx2(-1, "found: %s, expected: %s",
methods[drive_type.wake_up].name,
methods[vendors[vendor_index].wake_up].name);
TRACE(-1, "please report this to <*****@*****.**>");
TRACE(-1, "==========================================");
}
}
TRACE_EXIT;
}
/* Called by modules package when removing the driver
*/
void cleanup_module(void)
{
int n;
int order;
TRACE_FUN(5, "cleanup_module");
if (unregister_chrdev(QIC117_TAPE_MAJOR, "ft") != 0) {
TRACE(3, "failed");
} else {
TRACE(3, "successful");
}
order = __get_order(BUFF_SIZE);
for (n = 0; n < NR_BUFFERS; n++) {
if (tape_buffer[n]) {
dmafree(tape_buffer[n], order);
tape_buffer[n] = NULL;
TRACEx1(3, "removed dma-buffer #%d", n);
} else {
TRACEx1(1, "dma-buffer #%d == NULL (bug?)", n);
}
}
TRACE_EXIT;
}
/* Write as much as fits from buffer to the given segment on tape
* and handle retries.
* Return the number of bytes written (>= 0), or:
* -EIO write failed
* -EINTR interrupted by signal
* -ENOSPC device full
*/
int _write_segment(unsigned int segment_id, byte * buffer, int flush)
{
TRACE_FUN(5, "_write_segment");
int retry = 0;
int result;
history.used |= 2;
for (;;) {
if (segment_id > ftape_last_segment.id && !flush) {
result = -ENOSPC; /* tape full */
break;
}
result = write_segment(segment_id, buffer, flush);
if (result < 0) {
if (result == -EAGAIN) {
if (++retry > 100) {
TRACE(1, "write failed, >100 retries in segment");
result = -EIO; /* give up */
break;
} else {
TRACEx1(2, "write error, retry %d", retry);
}
} else {
TRACEi(1, "write_segment failed, error:", -result);
break;
}
} else { /* success */
if (result == 0) { /* empty segment */
TRACE(4, "empty segment, nothing written");
}
break;
}
/* Allow escape from loop when signaled !
*/
if (current->signal & _DONT_BLOCK) {
TRACE(2, "interrupted by signal");
TRACE_EXIT;
result = -EINTR; /* is this the right return value ? */
break;
}
}
TRACE_EXIT;
return result;
}
int ftape_init(void)
{
int n;
int order;
TRACE_FUN(5, "ftape_init");
#ifdef MODULE
printk(KERN_INFO "ftape-2.08 960314\n"
KERN_INFO " (c) 1993-1995 Bas Laarhoven ([email protected])\n"
KERN_INFO " (c) 1995-1996 Kai Harrekilde-Petersen ([email protected])\n"
KERN_INFO " QIC-117 driver for QIC-40/80/3010/3020 tape drives\n"
KERN_INFO " Compiled for kernel version %s"
#ifdef MODVERSIONS
" with versioned symbols"
#endif
"\n", kernel_version);
#else /* !MODULE */
/* print a short no-nonsense boot message */
printk("ftape-2.08 960314 for Linux 1.3.70\n");
#endif /* MODULE */
TRACE(3, "installing QIC-117 ftape driver...");
if (register_chrdev(QIC117_TAPE_MAJOR, "ft", &ftape_cdev)) {
TRACE(1, "register_chrdev failed");
TRACE_EXIT;
return -EIO;
}
TRACEx1(3, "ftape_init @ 0x%p", ftape_init);
/*
* Allocate the DMA buffers. They are deallocated at cleanup() time.
*/
order = __get_order(BUFF_SIZE);
for (n = 0; n < NR_BUFFERS; n++) {
tape_buffer[n] = (byte *) dmaalloc(order);
if (!tape_buffer[n]) {
TRACE(1, "dmaalloc() failed");
for (n = 0; n < NR_BUFFERS; n++) {
if (tape_buffer[n]) {
dmafree(tape_buffer[n], order);
tape_buffer[n] = NULL;
}
}
current->blocked = old_sigmask; /* restore mask */
if (unregister_chrdev(QIC117_TAPE_MAJOR, "ft") != 0) {
TRACE(3, "unregister_chrdev failed");
}
TRACE_EXIT;
return -ENOMEM;
} else {
TRACEx2(3, "dma-buffer #%d @ %p", n, tape_buffer[n]);
}
}
busy_flag = 0;
ftape_unit = -1;
ftape_failure = 1; /* inhibit any operation but open */
udelay_calibrate(); /* must be before fdc_wait_calibrate ! */
fdc_wait_calibrate();
TRACE_EXIT;
#ifdef MODULE
register_symtab(0); /* remove global ftape symbols */
#endif
return 0;
}
void extract_bad_sector_map(byte * buffer)
{
TRACE_FUN(8, "extract_bad_sector_map");
/* Fill the bad sector map with the contents of buffer.
*/
if (format_code == 4) {
/* QIC-3010/3020 and wide QIC-80 tapes no longer have a failed
* sector log but use this area to extend the bad sector map.
*/
memcpy(bad_sector_map, buffer + 256, sizeof(bad_sector_map));
} else {
/* non-wide QIC-80 tapes have a failed sector log area that
* mustn't be included in the bad sector map.
*/
memcpy(bad_sector_map, buffer + 256 + FAILED_SECTOR_LOG_SIZE,
sizeof(bad_sector_map) - FAILED_SECTOR_LOG_SIZE);
}
#if 0
/* for testing of bad sector handling at end of tape
*/
((unsigned long *) bad_sector_map)[segments_per_track * tracks_per_tape - 3] = 0x000003e0;
((unsigned long *) bad_sector_map)[segments_per_track * tracks_per_tape - 2] = 0xff3fffff;
((unsigned long *) bad_sector_map)[segments_per_track * tracks_per_tape - 1] = 0xffffe000;
#endif
#if 0
/* Enable to test bad sector handling
*/
((unsigned long *) bad_sector_map)[30] = 0xfffffffe;
((unsigned long *) bad_sector_map)[32] = 0x7fffffff;
((unsigned long *) bad_sector_map)[34] = 0xfffeffff;
((unsigned long *) bad_sector_map)[36] = 0x55555555;
((unsigned long *) bad_sector_map)[38] = 0xffffffff;
((unsigned long *) bad_sector_map)[50] = 0xffff0000;
((unsigned long *) bad_sector_map)[51] = 0xffffffff;
((unsigned long *) bad_sector_map)[52] = 0xffffffff;
((unsigned long *) bad_sector_map)[53] = 0x0000ffff;
#endif
#if 0
/* Enable when testing multiple volume tar dumps.
*/
for (i = first_data_segment; i <= ftape_last_segment.id - 7; ++i) {
((unsigned long *) bad_sector_map)[i] = EMPTY_SEGMENT;
}
#endif
#if 0
/* Enable when testing bit positions in *_error_map
*/
for (i = first_data_segment; i <= ftape_last_segment.id; ++i) {
((unsigned long *) bad_sector_map)[i] |= 0x00ff00ff;
}
#endif
if (tracing > 2) {
unsigned int map;
int good_sectors = 0;
int bad_sectors;
unsigned int total_bad = 0;
int i;
if (format_code == 4 || format_code == 3) {
byte *ptr = bad_sector_map;
unsigned sector;
do {
sector = get_sector(&ptr, forward);
if (sector != 0) {
if (format_code == 4 && sector & 0x800000) {
total_bad += SECTORS_PER_SEGMENT - 3;
TRACEx1(6, "bad segment at sector: %6d", sector & 0x7fffff);
} else {
++total_bad;
TRACEx1(6, "bad sector: %6d", sector);
}
}
} while (sector != 0);
/* Display end-of-file marks
*/
do {
sector = *((unsigned short *) ptr)++;
if (sector) {
TRACEx2(4, "eof mark: %4d/%2d", sector,
*((unsigned short *) ptr)++);
}
} while (sector);
} else {
for (i = first_data_segment;
i < segments_per_track * tracks_per_tape; ++i) {
map = ((unsigned long *) bad_sector_map)[i];
bad_sectors = count_ones(map);
if (bad_sectors > 0) {
TRACEx2(6, "bsm for segment %4d: 0x%08x", i, map);
if (bad_sectors > SECTORS_PER_SEGMENT - 3) {
bad_sectors = SECTORS_PER_SEGMENT - 3;
}
total_bad += bad_sectors;
}
}
}
good_sectors = ((segments_per_track * tracks_per_tape - first_data_segment)
* (SECTORS_PER_SEGMENT - 3)) - total_bad;
TRACEx1(3, "%d Kb usable on this tape",
good_sectors - ftape_last_segment.free);
if (total_bad == 0) {
TRACE(1, "WARNING: this tape has no bad blocks registered !");
} else {
TRACEx1(2, "%d bad sectors", total_bad);
}
}
TRACE_EXIT;
}
/* IOCTL routine called by kernel-interface code
*/
int _ftape_ioctl(unsigned int command, void *arg)
{
TRACE_FUN(8, "ftape_ioctl");
int result = EINVAL;
union {
struct mtop mtop;
struct mtget mtget;
} krnl_arg;
int arg_size = (command & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
/* This check will only catch arguments that are too large !
*/
if ((command & IOC_INOUT) && arg_size > sizeof(krnl_arg)) {
TRACEi(1, "bad argument size:", arg_size);
TRACE_EXIT;
return -EINVAL;
}
if (command & IOC_IN) {
int error = verify_area(VERIFY_READ, arg, arg_size);
if (error) {
TRACE_EXIT;
return error;
}
memcpy_fromfs(&krnl_arg.mtop, arg, arg_size);
}
TRACEx1(5, "called with ioctl command: 0x%08x", command);
switch (command) {
/* cpio compatibility
* mtrasx and mtreset are mt extension by Hennus Bergman
* mtseek and mttell are mt extension by eddy olk
*/
case MTIOCTOP:
TRACEx1(5, "calling MTIOCTOP command: 0x%08x", krnl_arg.mtop.mt_op);
switch (krnl_arg.mtop.mt_op) {
case MTNOP:
/* gnu mt calls MTNOP before MTIOCGET to set status */
result = 0;
break;
case MTRESET:
result = ftape_reset_drive();
init_drive_needed = 1;
if (result < 0 || ftape_offline) {
break;
}
result = ftape_seek_to_bot();
ftape_reset_position();
break;
case MTREW:
case MTOFFL:
if (ftape_offline) {
result = -EIO;
break;
}
ftape_flush_buffers();
ftape_update_header_segments(NULL, 1);
result = ftape_seek_to_bot();
ftape_reset_position();
if (krnl_arg.mtop.mt_op == MTOFFL) {
going_offline = 1;
TRACE(4, "Putting tape drive offline");
}
result = 0;
break;
case MTRETEN:
if (ftape_offline) {
result = -EIO;
break;
}
result = ftape_seek_to_eot();
if (result >= 0) {
result = ftape_seek_to_bot();
}
ftape_reset_position();
break;
case MTERASE:
if (ftape_offline) {
result = -EIO;
break;
}
result = ftape_erase();
break;
case MTEOM:
if (ftape_offline) {
result = -EIO;
break;
}
result = ftape_seek_eom();
break;
case MTFSFM:
if (ftape_offline) {
result = -EIO;
break;
}
eof_mark = 1; /* position ready to extend */
case MTFSF:
if (ftape_offline) {
result = -EIO;
break;
}
result = ftape_seek_eof(krnl_arg.mtop.mt_count);
break;
case MTBSFM:
if (ftape_offline) {
result = -EIO;
break;
}
eof_mark = 1; /* position ready to extend */
case MTBSF:
if (ftape_offline) {
result = -EIO;
break;
}
result = ftape_seek_eof(-krnl_arg.mtop.mt_count);
break;
case MTFSR:
if (ftape_offline) {
result = -EIO;
break;
}
tracing = krnl_arg.mtop.mt_count;
TRACEx1(2, "tracing set to %d", tracing);
result = 0;
break;
case MTBSR:
if (ftape_offline) {
result = -EIO;
break;
}
#if 0
result = ftape_fix();
#else
result = 0;
#endif
break;
case MTWEOF:
if (ftape_offline) {
result = -EIO;
break;
}
result = ftape_weof(krnl_arg.mtop.mt_count, ftape_seg_pos, 1);
if (result >= 0) {
ftape_seg_pos += krnl_arg.mtop.mt_count - 1;
}
break;
/* MTRASx and MTRESET are mt extension by Hennus Bergman
*/
case MTRAS1:
case MTRAS2:
case MTRAS3:
case MTSEEK:
case MTTELL:
default:
TRACEi(1, "MTIOCTOP sub-command not implemented:", krnl_arg.mtop.mt_op);
result = -EIO;
break;
}
break;
case MTIOCGET:
krnl_arg.mtget.mt_type = drive_type.vendor_id + 0x800000;
krnl_arg.mtget.mt_resid = 0; /* not implemented */
krnl_arg.mtget.mt_dsreg = 0; /* status register */
krnl_arg.mtget.mt_gstat = /* device independent status */
((ftape_offline) ? 0 : GMT_ONLINE(-1L)) |
((write_protected) ? GMT_WR_PROT(-1L) : 0) |
((no_tape) ? GMT_DR_OPEN(-1L) : 0);
krnl_arg.mtget.mt_erreg = ftape_last_error; /* error register */
result = ftape_file_no(&krnl_arg.mtget.mt_fileno,
&krnl_arg.mtget.mt_blkno);
break;
case MTIOCPOS:
TRACE(5, "Mag tape ioctl command: MTIOCPOS");
TRACE(1, "MTIOCPOS command not implemented");
break;
default:
result = -EINVAL;
break;
}
if (command & IOC_OUT) {
int error = verify_area(VERIFY_WRITE, arg, arg_size);
if (error) {
TRACE_EXIT;
return error;
}
memcpy_tofs(arg, &krnl_arg, arg_size);
}
TRACE_EXIT;
return result;
}
void ftape_calc_timeouts(void)
{
TRACE_FUN(8, "ftape_calc_timeouts");
int speed; /* deci-ips ! */
int length;
/* tape transport speed
* data rate: QIC-40 QIC-80 QIC-3010 QIC-3020
*
* 250 Kbps 25 ips n/a n/a n/a
* 500 Kbps 50 ips 34 ips 22.6 ips n/a
* 1 Mbps n/a 68 ips 45.2 ips 22.6 ips
* 2 Mbps n/a n/a n/a 45.2 ips
*
* fast tape transport speed is at least 68 ips.
*/
switch (qic_std) {
case QIC_TAPE_QIC40:
speed = (ftape_data_rate == 3) ? 250 : 500;
break;
case QIC_TAPE_QIC80:
speed = (ftape_data_rate == 2) ? 340 : 680;
break;
case QIC_TAPE_QIC3010:
speed = (ftape_data_rate == 2) ? 226 : 452;
break;
case QIC_TAPE_QIC3020:
speed = (ftape_data_rate == 1) ? 226 : 452;
break;
default:
TRACE(-1, "Unknown qic_std (bug) ?");
speed = 500;
break;
}
if (tape_len <= 0) {
/* Handle unknown length tapes as 1100 ft ones (worst case)
*/
TRACE(1, "Unknown tape length, using worst case timing values!");
length = 1100;
} else {
length = tape_len;
}
if (drive_type.speed == 0) {
unsigned long t0;
int dt;
ftape_seek_to_bot();
t0 = jiffies;
ftape_seek_to_eot();
ftape_seek_to_bot();
dt = (int) ((jiffies - t0) * MSPT);
drive_type.speed = (2 * 12 * length * 1000) / dt;
TRACE(-1, "==========================================");
TRACEx1(-1, "drive : %s", drive_type.name);
TRACEx2(-1, "delta time = %d, length = %d", dt, length);
TRACEx1(-1, "has max tape speed of %d ips", drive_type.speed);
TRACE(-1, "please report this to <*****@*****.**>");
TRACE(-1, "==========================================");
}
/* time to go from bot to eot at normal speed (data rate):
* time = (1+delta) * length (ft) * 12 (inch/ft) / speed (ips)
* delta = 10 % for seek speed, 20 % for rewind speed.
*/
timeout.seek = (length * 132 * SECOND) / speed;
timeout.rewind = (length * 144 * SECOND) / (10 * drive_type.speed);
timeout.reset = 20 * SECOND + timeout.rewind;
TRACEx2(4, "speed = %d, length = %d", speed, length);
TRACEx1(4, "seek timeout: %d sec", (timeout.seek + 500) / 1000);
TRACEx1(4, "rewind timeout: %d sec", (timeout.rewind + 500) / 1000);
TRACE_EXIT;
}
int ftape_activate_drive(vendor_struct * drive_type)
{
TRACE_FUN(5, "ftape_activate_drive");
int result = 0;
/* If we already know the drive type, wake it up.
* Else try to find out what kind of drive is attached.
*/
if (drive_type->wake_up != unknown_wake_up) {
TRACE(5, "enabling tape drive and fdc");
result = ftape_wakeup_drive(drive_type->wake_up);
if (result < 0) {
TRACE(1, "known wakeup method failed");
}
} else {
int old_tracing = tracing;
wake_up_types method;
/* Try to awaken the drive using all known methods.
* Lower tracing for a while.
*/
if (tracing <= 4) {
tracing = 0;
}
for (method = no_wake_up; method < NR_ITEMS(methods); ++method) {
drive_type->wake_up = method;
#if 0
/* Test setup for dual drive configuration in dodo.
* /dev/rft2 uses mountain wakeup only -> Archive QIC-80
* /dev/rft3 uses colorado wakeup only -> Jumbo QIC-40
* Other systems will use the normal scheme.
*/
if ((FTAPE_UNIT < 2) ||
(FTAPE_UNIT == 2 && method == wake_up_mountain) ||
(FTAPE_UNIT == 3 && method == wake_up_colorado)) {
result = ftape_wakeup_drive(drive_type->wake_up);
} else {
result = -EIO;
}
#else
result = ftape_wakeup_drive(drive_type->wake_up);
#endif
if (result >= 0) {
int tracing = old_tracing; /* fool TRACE */
TRACEx1(2, "drive wakeup method: %s",
methods[drive_type->wake_up].name);
break;
}
}
tracing = old_tracing;
if (method >= NR_ITEMS(methods)) {
/* no response at all, cannot open this drive */
drive_type->wake_up = unknown_wake_up;
TRACE(1, "no tape drive found !");
tracing = old_tracing;
result = -ENODEV;
}
}
TRACE_EXIT;
return result;
}
/* Write given segment from buffer at address onto tape.
*/
int write_segment(unsigned segment_id, byte * address, int flushing)
{
TRACE_FUN(5, "write_segment");
int result = 0;
int bytes_written = 0;
TRACEi(5, "segment_id =", segment_id);
if (ftape_state != writing) {
if (ftape_state == reading) {
TRACE(5, "calling ftape_abort_operation");
result = ftape_abort_operation();
if (result < 0) {
TRACE(1, "ftape_abort_operation failed");
}
}
ftape_zap_read_buffers();
ftape_zap_write_buffers();
ftape_state = writing;
}
/* if all buffers full we'll have to wait...
*/
wait_segment(writing);
if (buffer[tail].status == error) {
/* setup for a retry
*/
buffer[tail].status = waiting;
bytes_written = -EAGAIN; /* force retry */
if (buffer[tail].hard_error_map != 0) {
TRACEx1(1, "warning: %d hard error(s) in written segment",
count_ones(buffer[tail].hard_error_map));
TRACEx1(4, "hard_error_map = 0x%08lx", buffer[tail].hard_error_map);
/* Implement hard write error recovery here
*/
}
} else if (buffer[tail].status == done) {
history.defects += count_ones(buffer[tail].hard_error_map);
} else {
TRACE(1, "wait for empty segment failed");
result = -EIO;
}
/* If just passed last segment on tape: wait for BOT or EOT mark.
*/
if (result >= 0 && runner_status == logical_eot) {
int status;
result = ftape_ready_wait(timeout.seek, &status);
if (result < 0 || (status & (QIC_STATUS_AT_BOT | QIC_STATUS_AT_EOT)) == 0) {
TRACE(1, "eot/bot not reached");
} else {
runner_status = end_of_tape;
}
}
/* should runner stop ?
*/
if (result >= 0 &&
(runner_status == aborting || runner_status == buffer_underrun ||
runner_status == end_of_tape)) {
if (runner_status != end_of_tape) {
result = ftape_dumb_stop();
}
if (result >= 0) {
if (runner_status == aborting) {
if (buffer[head].status == writing) {
buffer[head].status = done; /* ????? */
}
}
runner_status = idle; /* aborted ? */
}
}
/* Don't start tape if runner idle and segment empty.
*/
if (result >= 0 && !(runner_status == idle &&
get_bad_sector_entry(segment_id) == EMPTY_SEGMENT)) {
if (buffer[tail].status == done) {
/* now at least one buffer is empty, fill it with our data.
* skip bad sectors and generate ecc.
* copy_and_gen_ecc return nr of bytes written,
* range 0..29 Kb inclusive !
*/
result = copy_and_gen_ecc(buffer[tail].address, address,
get_bad_sector_entry(segment_id));
if (result >= 0) {
bytes_written = result;
buffer[tail].segment_id = segment_id;
buffer[tail].status = waiting;
next_buffer(&tail);
}
}
/* Start tape only if all buffers full or flush mode.
* This will give higher probability of streaming.
*/
if (result >= 0 && runner_status != running &&
((head == tail && buffer[tail].status == waiting) || flushing)) {
result = start_writing(WRITE_MULTI);
}
}
TRACE_EXIT;
return (result < 0) ? result : bytes_written;
}
static void print_error_cause(int cause)
{
TRACE_FUN(8, "print_error_cause");
switch (cause) {
case no_data_error:
TRACE(4, "no data error");
break;
case id_am_error:
TRACE(4, "id am error");
break;
case id_crc_error:
TRACE(4, "id crc error");
break;
case data_am_error:
TRACE(4, "data am error");
break;
case data_crc_error:
TRACE(4, "data crc error");
break;
case overrun_error:
TRACE(4, "overrun error");
break;
default:
}
TRACE_EXIT;
}
static char *
get_fdc_mode_text(fdc_mode_enum fdc_mode)
{
switch (fdc_mode) {
case fdc_idle:
return "fdc_idle";
case fdc_reading_data:
return "fdc_reading_data";
case fdc_seeking:
return "fdc_seeking";
case fdc_writing_data:
return "fdc_writing_data";
case fdc_reading_id:
return "fdc_reading_id";
case fdc_recalibrating:
return "fdc_recalibrating";
default:
return "unknown";
}
}
static void
decode_irq_cause(fdc_mode_enum fdc_mode, byte st[],
char **fdc_mode_txt, error_cause * cause)
{
TRACE_FUN(8, "decode_irq_cause");
/* Valid st[], decode cause of interrupt.
*/
*fdc_mode_txt = get_fdc_mode_text(fdc_mode);
switch (st[0] & ST0_INT_MASK) {
case FDC_INT_NORMAL:
TRACEx1(fdc_mode == fdc_reading_id ? 6 : 5,
"normal completion: %s", *fdc_mode_txt);
*cause = no_error;
break;
case FDC_INT_ABNORMAL:
TRACEx1(5, "abnormal completion %s", *fdc_mode_txt);
TRACEx3(6, "ST0: 0x%02x, ST1: 0x%02x, ST2: 0x%02x",
st[0], st[1], st[2]);
TRACEx4(6, "C: 0x%02x, H: 0x%02x, R: 0x%02x, N: 0x%02x",
st[3], st[4], st[5], st[6]);
if (st[1] & 0x01) {
if (st[2] & 0x01) {
*cause = data_am_error;
} else {
*cause = id_am_error;
}
} else if (st[1] & 0x20) {
if (st[2] & 0x20) {
*cause = data_crc_error;
} else {
*cause = id_crc_error;
}
} else if (st[1] & 0x04) {
*cause = no_data_error;
} else if (st[1] & 0x10) {
*cause = overrun_error;
}
print_error_cause(*cause);
break;
case FDC_INT_INVALID:
TRACEx1(5, "invalid completion %s", *fdc_mode_txt);
*cause = no_error;
break;
case FDC_INT_READYCH:
TRACEx1(5, "ready change %s", *fdc_mode_txt);
*cause = no_error;
break;
default:
}
TRACE_EXIT;
}
static void update_history(error_cause cause)
{
switch (cause) {
case id_am_error:
history.id_am_errors++;
break;
case id_crc_error:
history.id_crc_errors++;
break;
case data_am_error:
history.data_am_errors++;
break;
case data_crc_error:
history.data_crc_errors++;
break;
case overrun_error:
history.overrun_errors++;
break;
case no_data_error:
history.no_data_errors++;
break;
default:
}
}
static void skip_bad_sector(buffer_struct * buff)
{
TRACE_FUN(8, "skip_bad_sector");
/* Mark sector as soft error and skip it
*/
if (buff->remaining > 0) {
++buff->sector_offset;
++buff->data_offset;
--buff->remaining;
buff->ptr += SECTOR_SIZE;
buff->bad_sector_map >>= 1;
} else {
