/*
 *      Copyright (C) 1993-1996 Bas Laarhoven,
 *                (C) 1996-1997 Claus-Justus Heine.

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; see the file COPYING.  If not, write to
 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 *
 * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-rw.c,v $
 * $Revision: 1.7 $
 * $Date: 1997/10/28 14:26:49 $
 *
 *      This file contains some common code for the segment read and
 *      segment write routines for the QIC-117 floppy-tape driver for
 *      Linux.
 */

#include <linux/string.h>
#include <linux/errno.h>

#include <linux/ftape.h>
#include <linux/qic117.h>
#include "../lowlevel/ftape-tracing.h"
#include "../lowlevel/ftape-rw.h"
#include "../lowlevel/fdc-io.h"
#include "../lowlevel/ftape-init.h"
#include "../lowlevel/ftape-io.h"
#include "../lowlevel/ftape-ctl.h"
#include "../lowlevel/ftape-read.h"
#include "../lowlevel/ftape-ecc.h"
#include "../lowlevel/ftape-bsm.h"

/*      Global vars.
 */
int ft_nr_buffers;
buffer_struct *ft_buffer[FT_MAX_NR_BUFFERS];
static volatile int ft_head;
static volatile int ft_tail;    /* not volatile but need same type as head */
int fdc_setup_error;
location_record ft_location = {-1, 0};
volatile int ftape_tape_running;

/*      Local vars.
 */
static int overrun_count_offset;
static int inhibit_correction;

/*  maxmimal allowed overshoot when fast seeking
 */
#define OVERSHOOT_LIMIT 10

/*      Increment cyclic buffer nr.
 */
buffer_struct *ftape_next_buffer(ft_buffer_queue_t pos)
{
        switch (pos) {
        case ft_queue_head:
                if (++ft_head >= ft_nr_buffers) {
                        ft_head = 0;
                }
                return ft_buffer[ft_head];
        case ft_queue_tail:
                if (++ft_tail >= ft_nr_buffers) {
                        ft_tail = 0;
                }
                return ft_buffer[ft_tail];
        default:
                return NULL;
        }
}
int ftape_buffer_id(ft_buffer_queue_t pos)
{
        switch(pos) {
        case ft_queue_head: return ft_head;
        case ft_queue_tail: return ft_tail;
        default: return -1;
        }
}
buffer_struct *ftape_get_buffer(ft_buffer_queue_t pos)
{
        switch(pos) {
        case ft_queue_head: return ft_buffer[ft_head];
        case ft_queue_tail: return ft_buffer[ft_tail];
        default: return NULL;
        }
}
void ftape_reset_buffer(void)
{
        ft_head = ft_tail = 0;
}

buffer_state_enum ftape_set_state(buffer_state_enum new_state)
{
        buffer_state_enum old_state = ft_driver_state;

        ft_driver_state = new_state;
        return old_state;
}
/*      Calculate Floppy Disk Controller and DMA parameters for a segment.
 *      head:   selects buffer struct in array.
 *      offset: number of physical sectors to skip (including bad ones).
 *      count:  number of physical sectors to handle (including bad ones).
 */
static int setup_segment(buffer_struct * buff, 
                         int segment_id,
                         unsigned int sector_offset, 
                         unsigned int sector_count, 
                         int retry)
{
        SectorMap offset_mask;
        SectorMap mask;
        TRACE_FUN(ft_t_any);

        buff->segment_id = segment_id;
        buff->sector_offset = sector_offset;
        buff->remaining = sector_count;
        buff->head = segment_id / ftape_segments_per_head;
        buff->cyl = (segment_id % ftape_segments_per_head) / ftape_segments_per_cylinder;
        buff->sect = (segment_id % ftape_segments_per_cylinder) * FT_SECTORS_PER_SEGMENT + 1;
        buff->deleted = 0;
        offset_mask = (1 << buff->sector_offset) - 1;
        mask = ftape_get_bad_sector_entry(segment_id) & offset_mask;
        while (mask) {
                if (mask & 1) {
                        offset_mask >>= 1;      /* don't count bad sector */
                }
                mask >>= 1;
        }
        buff->data_offset = count_ones(offset_mask);    /* good sectors to skip */
        buff->ptr = buff->address + buff->data_offset * FT_SECTOR_SIZE;
        TRACE(ft_t_flow, "data offset = %d sectors", buff->data_offset);
        if (retry) {
                buff->soft_error_map &= offset_mask;    /* keep skipped part */
        } else {
                buff->hard_error_map = buff->soft_error_map = 0;
        }
        buff->bad_sector_map = ftape_get_bad_sector_entry(buff->segment_id);
        if (buff->bad_sector_map != 0) {
                TRACE(ft_t_noise, "segment: %d, bad sector map: %08lx",
                        buff->segment_id, (long)buff->bad_sector_map);
        } else {
                TRACE(ft_t_flow, "segment: %d", buff->segment_id);
        }
        if (buff->sector_offset > 0) {
                buff->bad_sector_map >>= buff->sector_offset;
        }
        if (buff->sector_offset != 0 || buff->remaining != FT_SECTORS_PER_SEGMENT) {
                TRACE(ft_t_flow, "sector offset = %d, count = %d",
                        buff->sector_offset, buff->remaining);
        }
        /*    Segments with 3 or less sectors are not written with valid
         *    data because there is no space left for the ecc.  The
         *    data written is whatever happens to be in the buffer.
         *    Reading such a segment will return a zero byte-count.
         *    To allow us to read/write segments with all bad sectors
         *    we fake one readable sector in the segment. This
         *    prevents having to handle these segments in a very
         *    special way.  It is not important if the reading of this
         *    bad sector fails or not (the data is ignored). It is
         *    only read to keep the driver running.
         *
         *    The QIC-40/80 spec. has no information on how to handle
         *    this case, so this is my interpretation.  
         */
        if (buff->bad_sector_map == EMPTY_SEGMENT) {
                TRACE(ft_t_flow, "empty segment %d, fake first sector good",
                      buff->segment_id);
                if (buff->ptr != buff->address) {
                        TRACE(ft_t_bug, "This is a bug: %p/%p",
                              buff->ptr, buff->address);
                }
                buff->bad_sector_map = FAKE_SEGMENT;
        }
        fdc_setup_error = 0;
        buff->next_segment = segment_id + 1;
        TRACE_EXIT 0;
}

/*      Calculate Floppy Disk Controller and DMA parameters for a new segment.
 */
int ftape_setup_new_segment(buffer_struct * buff, int segment_id, int skip)
{
        int result = 0;
        static int old_segment_id = -1;
        static buffer_state_enum old_ft_driver_state = idle;
        int retry = 0;
        unsigned offset = 0;
        int count = FT_SECTORS_PER_SEGMENT;
        TRACE_FUN(ft_t_flow);

        TRACE(ft_t_flow, "%s segment %d (old = %d)",
              (ft_driver_state == reading || ft_driver_state == verifying) 
              ? "reading" : "writing",
              segment_id, old_segment_id);
        if (ft_driver_state != old_ft_driver_state) {   /* when verifying */
                old_segment_id = -1;
                old_ft_driver_state = ft_driver_state;
        }
        if (segment_id == old_segment_id) {
                ++buff->retry;
                ++ft_history.retries;
                TRACE(ft_t_flow, "setting up for retry nr %d", buff->retry);
                retry = 1;
                if (skip && buff->skip > 0) {   /* allow skip on retry */
                        offset = buff->skip;
                        count -= offset;
                        TRACE(ft_t_flow, "skipping %d sectors", offset);
                }
        } else {
                buff->retry = 0;
                buff->skip = 0;
                old_segment_id = segment_id;
        }
        result = setup_segment(buff, segment_id, offset, count, retry);
        TRACE_EXIT result;
}

/*      Determine size of next cluster of good sectors.
 */
int ftape_calc_next_cluster(buffer_struct * buff)
{
        /* Skip bad sectors.
         */
        while (buff->remaining > 0 && (buff->bad_sector_map & 1) != 0) {
                buff->bad_sector_map >>= 1;
                ++buff->sector_offset;
                --buff->remaining;
        }
        /* Find next cluster of good sectors
         */
        if (buff->bad_sector_map == 0) {        /* speed up */
                buff->sector_count = buff->remaining;
        } else {
                SectorMap map = buff->bad_sector_map;

                buff->sector_count = 0;
                while (buff->sector_count < buff->remaining && (map & 1) == 0) {
                        ++buff->sector_count;
                        map >>= 1;
                }
        }
        return buff->sector_count;
}

/*  if just passed the last segment on a track, wait for BOT
 *  or EOT mark.
 */
int ftape_handle_logical_eot(void)
{
        TRACE_FUN(ft_t_flow);

        if (ft_runner_status == logical_eot) {
                int status;

                TRACE(ft_t_noise, "tape at logical EOT");
                TRACE_CATCH(ftape_ready_wait(ftape_timeout.seek, &status),);
                if ((status & (QIC_STATUS_AT_BOT | QIC_STATUS_AT_EOT)) == 0) {
                        TRACE_ABORT(-EIO, ft_t_err, "eot/bot not reached");
                }
                ft_runner_status = end_of_tape;
        }
        if (ft_runner_status == end_of_tape) {
                TRACE(ft_t_noise, "runner stopped because of logical EOT");
                ft_runner_status = idle;
        }
        TRACE_EXIT 0;
}

static int check_bot_eot(int status)
{
        TRACE_FUN(ft_t_flow);

        if (status & (QIC_STATUS_AT_BOT | QIC_STATUS_AT_EOT)) {
                ft_location.bot = ((ft_location.track & 1) == 0 ?
                                (status & QIC_STATUS_AT_BOT) != 0:
                                (status & QIC_STATUS_AT_EOT) != 0);
                ft_location.eot = !ft_location.bot;
                ft_location.segment = (ft_location.track +
                        (ft_location.bot ? 0 : 1)) * ft_segments_per_track - 1;
                ft_location.sector = -1;
                ft_location.known  = 1;
                TRACE(ft_t_flow, "tape at logical %s",
                      ft_location.bot ? "bot" : "eot");
                TRACE(ft_t_flow, "segment = %d", ft_location.segment);
        } else {
                ft_location.known = 0;
        }
        TRACE_EXIT ft_location.known;
}

/*      Read Id of first sector passing tape head.
 */
int ftape_read_id(void)
{
        int status;
        __u8 out[2];
        TRACE_FUN(ft_t_any);

        /* Assume tape is running on entry, be able to handle
         * situation where it stopped or is stopping.
         */
        ft_location.known = 0;  /* default is location not known */
        out[0] = FDC_READID;
        out[1] = ft_drive_sel;
        TRACE_CATCH(fdc_command(out, 2),);
        switch (fdc_interrupt_wait(20 * FT_SECOND)) {
        case 0:
                if (fdc_sect == 0) {
                        if (ftape_report_drive_status(&status) >= 0 &&
                            (status & QIC_STATUS_READY)) {
                                ftape_tape_running = 0;
                                TRACE(ft_t_flow, "tape has stopped");
                                check_bot_eot(status);
                        }
                } else {
                        ft_location.known = 1;
                        ft_location.segment = (ftape_segments_per_head
                                               * fdc_head
                                               + ftape_segments_per_cylinder
                                               * fdc_cyl
                                               + (fdc_sect - 1)
                                               / FT_SECTORS_PER_SEGMENT);
                        ft_location.sector = ((fdc_sect - 1)
                                              % FT_SECTORS_PER_SEGMENT);
                        ft_location.eot = ft_location.bot = 0;
                }
                break;
        case -ETIME:
                /*  Didn't find id on tape, must be near end: Wait
                 *  until stopped.
                 */
                if (ftape_ready_wait(FT_FOREVER, &status) >= 0) {
                        ftape_tape_running = 0;
                        TRACE(ft_t_flow, "tape has stopped");
                        check_bot_eot(status);
                }
                break;
        default:
                /*  Interrupted or otherwise failing
                 *  fdc_interrupt_wait() 
                 */
                TRACE(ft_t_err, "fdc_interrupt_wait failed");
                break;
        }
        if (!ft_location.known) {
                TRACE_ABORT(-EIO, ft_t_flow, "no id found");
        }
        if (ft_location.sector == 0) {
                TRACE(ft_t_flow, "passing segment %d/%d",
                      ft_location.segment, ft_location.sector);
        } else {
                TRACE(ft_t_fdc_dma, "passing segment %d/%d",
                      ft_location.segment, ft_location.sector);
        }
        TRACE_EXIT 0;
}

static int logical_forward(void)
{
        ftape_tape_running = 1;
        return ftape_command(QIC_LOGICAL_FORWARD);
}

int ftape_stop_tape(int *pstatus)
{
        int retry = 0;
        int result;
        TRACE_FUN(ft_t_flow);

        do {
                result = ftape_command_wait(QIC_STOP_TAPE,
                                            ftape_timeout.stop, pstatus);
                if (result == 0) {
                        if ((*pstatus & QIC_STATUS_READY) == 0) {
                                result = -EIO;
                        } else {
                                ftape_tape_running = 0;
                        }
                }
        } while (result < 0 && ++retry <= 3);
        if (result < 0) {
                TRACE(ft_t_err, "failed ! (fatal)");
        }
        TRACE_EXIT result;
}

int ftape_dumb_stop(void)
{
        int result;
        int status;
        TRACE_FUN(ft_t_flow);

        /*  Abort current fdc operation if it's busy (probably read
         *  or write operation pending) with a reset.
         */
        if (fdc_ready_wait(100 /* usec */) < 0) {
                TRACE(ft_t_noise, "aborting fdc operation");
                fdc_reset();
        }
        /*  Reading id's after the last segment on a track may fail
         *  but eventually the drive will become ready (logical eot).
         */
        result = ftape_report_drive_status(&status);
        ft_location.known = 0;
        do {
                if (result == 0 && status & QIC_STATUS_READY) {
                        /* Tape is not running any more.
                         */
                        TRACE(ft_t_noise, "tape already halted");
                        check_bot_eot(status);
                        ftape_tape_running = 0;
                } else if (ftape_tape_running) {
                        /*  Tape is (was) still moving.
                         */
#ifdef TESTING
                        ftape_read_id();
#endif
                        result = ftape_stop_tape(&status);
                } else {
                        /*  Tape not yet ready but stopped.
                         */
                        result = ftape_ready_wait(ftape_timeout.pause,&status);
                }
        } while (ftape_tape_running
                 && !(sigtestsetmask(&current->pending.signal, _NEVER_BLOCK)));
#ifndef TESTING
        ft_location.known = 0;
#endif
        if (ft_runner_status == aborting || ft_runner_status == do_abort) {
                ft_runner_status = idle;
        }
        TRACE_EXIT result;
}

/*      Wait until runner has finished tail buffer.
 *
 */
int ftape_wait_segment(buffer_state_enum state)
{
        int status;
        int result = 0;
        TRACE_FUN(ft_t_flow);

        while (ft_buffer[ft_tail]->status == state) {
                TRACE(ft_t_flow, "state: %d", ft_buffer[ft_tail]->status);
                /*  First buffer still being worked on, wait up to timeout.
                 *
                 *  Note: we check two times for being killed. 50
                 *  seconds are quite long. Note that
                 *  fdc_interrupt_wait() is not killable by any
                 *  means. ftape_read_segment() wants us to return
                 *  -EINTR in case of a signal.  
                 */
                FT_SIGNAL_EXIT(_DONT_BLOCK);
                result = fdc_interrupt_wait(50 * FT_SECOND);
                FT_SIGNAL_EXIT(_DONT_BLOCK);
                if (result < 0) {
                        TRACE_ABORT(result,
                                    ft_t_err, "fdc_interrupt_wait failed");
                }
                if (fdc_setup_error) {
                        /* recover... FIXME */
                        TRACE_ABORT(-EIO, ft_t_err, "setup error");
                }
        }
        if (ft_buffer[ft_tail]->status != error) {
                TRACE_EXIT 0;
        }
        TRACE_CATCH(ftape_report_drive_status(&status),);
        TRACE(ft_t_noise, "ftape_report_drive_status: 0x%02x", status);
        if ((status & QIC_STATUS_READY) && 
            (status & QIC_STATUS_ERROR)) {
                unsigned int error;
                qic117_cmd_t command;
                
                /*  Report and clear error state.
                 *  In case the drive can't operate at the selected
                 *  rate, select the next lower data rate.
                 */
                ftape_report_error(&error, &command, 1);
                if (error == 31 && command == QIC_LOGICAL_FORWARD) {
                        /* drive does not accept this data rate */
                        if (ft_data_rate > 250) {
                                TRACE(ft_t_info,
                                      "Probable data rate conflict");
                                TRACE(ft_t_info,
                                      "Lowering data rate to %d Kbps",
                                      ft_data_rate / 2);
                                ftape_half_data_rate();
                                if (ft_buffer[ft_tail]->retry > 0) {
                                        /* give it a chance */
                                        --ft_buffer[ft_tail]->retry;
                                }
                        } else {
                                /* no rate is accepted... */
                                TRACE(ft_t_err, "We're dead :(");
                        }
                } else {
                        TRACE(ft_t_err, "Unknown error");
                }
                TRACE_EXIT -EIO;   /* g.p. error */
        }
        TRACE_EXIT 0;
}

/* forward */ static int seek_forward(int segment_id, int fast);

static int fast_seek(int count, int reverse)
{
        int result = 0;
        int status;
        TRACE_FUN(ft_t_flow);

        if (count > 0) {
                /*  If positioned at begin or end of tape, fast seeking needs
                 *  special treatment.
                 *  Starting from logical bot needs a (slow) seek to the first
                 *  segment before the high speed seek. Most drives do this
                 *  automatically but some older don't, so we treat them
                 *  all the same.
                 *  Starting from logical eot is even more difficult because
                 *  we cannot (slow) reverse seek to the last segment.
                 *  TO BE IMPLEMENTED.
                 */
                inhibit_correction = 0;
                if (ft_location.known &&
                    ((ft_location.bot && !reverse) ||
                     (ft_location.eot && reverse))) {
                        if (!reverse) {
                                /*  (slow) skip to first segment on a track
                                 */
                                seek_forward(ft_location.track * ft_segments_per_track, 0);
                                --count;
                        } else {
                                /*  When seeking backwards from
                                 *  end-of-tape the number of erased
                                 *  gaps found seems to be higher than
                                 *  expected.  Therefor the drive must
                                 *  skip some more segments than
                                 *  calculated, but we don't know how
                                 *  many.  Thus we will prevent the
                                 *  re-calculation of offset and
                                 *  overshoot when seeking backwards.
                                 */
                                inhibit_correction = 1;
                                count += 3;     /* best guess */
                        }
                }
        } else {
                TRACE(ft_t_flow, "warning: zero or negative count: %d", count);
        }
        if (count > 0) {
                int i;
                int nibbles = count > 255 ? 3 : 2;

                if (count > 4095) {
                        TRACE(ft_t_noise, "skipping clipped at 4095 segment");
                        count = 4095;
                }
                /* Issue this tape command first. */
                if (!reverse) {
                        TRACE(ft_t_noise, "skipping %d segment(s)", count);
                        result = ftape_command(nibbles == 3 ?
                           QIC_SKIP_EXTENDED_FORWARD : QIC_SKIP_FORWARD);
                } else {
                        TRACE(ft_t_noise, "backing up %d segment(s)", count);
                        result = ftape_command(nibbles == 3 ?
                           QIC_SKIP_EXTENDED_REVERSE : QIC_SKIP_REVERSE);
                }
                if (result < 0) {
                        TRACE(ft_t_noise, "Skip command failed");
                } else {
                        --count;        /* 0 means one gap etc. */
                        for (i = 0; i < nibbles; ++i) {
                                if (result >= 0) {
                                        result = ftape_parameter(count & 15);
                                        count /= 16;
                                }
                        }
                        result = ftape_ready_wait(ftape_timeout.rewind, &status);
                        if (result >= 0) {
                                ftape_tape_running = 0;
                        }
                }
        }
        TRACE_EXIT result;
}

static int validate(int id)
{
        /* Check to see if position found is off-track as reported
         *  once.  Because all tracks in one direction lie next to
         *  each other, if off-track the error will be approximately
         *  2 * ft_segments_per_track.
         */
        if (ft_location.track == -1) {
                return 1; /* unforseen situation, don't generate error */
        } else {
                /* Use margin of ft_segments_per_track on both sides
                 * because ftape needs some margin and the error we're
                 * looking for is much larger !
                 */
                int lo = (ft_location.track - 1) * ft_segments_per_track;
                int hi = (ft_location.track + 2) * ft_segments_per_track;

                return (id >= lo && id < hi);
        }
}

static int seek_forward(int segment_id, int fast)
{
        int failures = 0;
        int count;
        static int margin = 1;  /* fixed: stop this before target */
        static int overshoot = 1;
        static int min_count = 8;
        int expected = -1;
        int target = segment_id - margin;
        int fast_seeking;
        int prev_segment = ft_location.segment;
        TRACE_FUN(ft_t_flow);

        if (!ft_location.known) {
                TRACE_ABORT(-EIO, ft_t_err,
                            "fatal: cannot seek from unknown location");
        }
        if (!validate(segment_id)) {
                ftape_sleep(1 * FT_SECOND);
                ft_failure = 1;
                TRACE_ABORT(-EIO, ft_t_err,
                            "fatal: head off track (bad hardware?)");
        }
        TRACE(ft_t_noise, "from %d/%d to %d/0 - %d",
              ft_location.segment, ft_location.sector,segment_id,margin);
        count = target - ft_location.segment - overshoot;
        fast_seeking = (fast &&
                        count > (min_count + (ft_location.bot ? 1 : 0)));
        if (fast_seeking) {
                TRACE(ft_t_noise, "fast skipping %d segments", count);
                expected = segment_id - margin;
                fast_seek(count, 0);
        }
        if (!ftape_tape_running) {
                logical_forward();
        }
        while (ft_location.segment < segment_id) {
                /*  This requires at least one sector in a (bad) segment to
                 *  have a valid and readable sector id !
                 *  It looks like this is not guaranteed, so we must try
                 *  to find a way to skip an EMPTY_SEGMENT. !!! FIXME !!!
                 */
                if (ftape_read_id() < 0 || !ft_location.known ||
                    sigtestsetmask(&current->pending.signal, _DONT_BLOCK)) {
                        ft_location.known = 0;
                        if (!ftape_tape_running ||
                            ++failures > FT_SECTORS_PER_SEGMENT) {
                                TRACE_ABORT(-EIO, ft_t_err,
                                            "read_id failed completely");
                        }
                        FT_SIGNAL_EXIT(_DONT_BLOCK);
                        TRACE(ft_t_flow, "read_id failed, retry (%d)",
                              failures);
                        continue;
                }
                if (fast_seeking) {
                        TRACE(ft_t_noise, "ended at %d/%d (%d,%d)",
                              ft_location.segment, ft_location.sector,
                              overshoot, inhibit_correction);
                        if (!inhibit_correction &&
                            (ft_location.segment < expected ||
                             ft_location.segment > expected + margin)) {
                                int error = ft_location.segment - expected;
                                TRACE(ft_t_noise,
                                      "adjusting overshoot from %d to %d",
                                      overshoot, overshoot + error);
                                overshoot += error;
                                /*  All overshoots have the same
                                 *  direction, so it should never
                                 *  become negative, but who knows.
                                 */
                                if (overshoot < -5 ||
                                    overshoot > OVERSHOOT_LIMIT) {
                                        if (overshoot < 0) {
                                                /* keep sane value */
                                                overshoot = -5;
                                        } else {
                                                /* keep sane value */
                                                overshoot = OVERSHOOT_LIMIT;
                                        }
                                        TRACE(ft_t_noise,
                                              "clipped overshoot to %d",
                                              overshoot);
                                }
                        }
                        fast_seeking = 0;
                }
                if (ft_location.known) {
                        if (ft_location.segment > prev_segment + 1) {
                                TRACE(ft_t_noise,
                                      "missed segment %d while skipping",
                                      prev_segment + 1);
                        }
                        prev_segment = ft_location.segment;
                }
        }
        if (ft_location.segment > segment_id) {
                TRACE_ABORT(-EIO,
                            ft_t_noise, "failed: skip ended at segment %d/%d",
                            ft_location.segment, ft_location.sector);
        }
        TRACE_EXIT 0;
}

static int skip_reverse(int segment_id, int *pstatus)
{
        int failures = 0;
        static int overshoot = 1;
        static int min_rewind = 2;      /* 1 + overshoot */
        static const int margin = 1;    /* stop this before target */
        int expected = 0;
        int count = 1;
        int short_seek;
        int target = segment_id - margin;
        TRACE_FUN(ft_t_flow);

        if (ft_location.known && !validate(segment_id)) {
                ftape_sleep(1 * FT_SECOND);
                ft_failure = 1;
                TRACE_ABORT(-EIO, ft_t_err,
                            "fatal: head off track (bad hardware?)");
        }
        do {
                if (!ft_location.known) {
                        TRACE(ft_t_warn, "warning: location not known");
                }
                TRACE(ft_t_noise, "from %d/%d to %d/0 - %d",
                      ft_location.segment, ft_location.sector,
                      segment_id, margin);
                /*  min_rewind == 1 + overshoot_when_doing_minimum_rewind
                 *  overshoot  == overshoot_when_doing_larger_rewind
                 *  Initially min_rewind == 1 + overshoot, optimization
                 *  of both values will be done separately.
                 *  overshoot and min_rewind can be negative as both are
                 *  sums of three components:
                 *  any_overshoot == rewind_overshoot - 
                 *                   stop_overshoot   -
                 *                   start_overshoot
                 */
                if (ft_location.segment - target - (min_rewind - 1) < 1) {
                        short_seek = 1;
                } else {
                        count = ft_location.segment - target - overshoot;
                        short_seek = (count < 1);
                }
                if (short_seek) {
                        count = 1;      /* do shortest rewind */
                        expected = ft_location.segment - min_rewind;
                        if (expected/ft_segments_per_track != ft_location.track) {
                                expected = (ft_location.track * 
                                            ft_segments_per_track);
                        }
                } else {
                        expected = target;
                }
                fast_seek(count, 1);
                logical_forward();
                if (ftape_read_id() < 0 || !ft_location.known ||
                    (sigtestsetmask(&current->pending.signal, _DONT_BLOCK))) {
                        if ((!ftape_tape_running && !ft_location.known) ||
                            ++failures > FT_SECTORS_PER_SEGMENT) {
                                TRACE_ABORT(-EIO, ft_t_err,
                                            "read_id failed completely");
                        }
                        FT_SIGNAL_EXIT(_DONT_BLOCK);
                        TRACE_CATCH(ftape_report_drive_status(pstatus),);
                        TRACE(ft_t_noise, "ftape_read_id failed, retry (%d)",
                              failures);
                        continue;
                }
                TRACE(ft_t_noise, "ended at %d/%d (%d,%d,%d)", 
                      ft_location.segment, ft_location.sector,
                      min_rewind, overshoot, inhibit_correction);
                if (!inhibit_correction &&
                    (ft_location.segment < expected ||
                     ft_location.segment > expected + margin)) {
                        int error = expected - ft_location.segment;
                        if (short_seek) {
                                TRACE(ft_t_noise,
                                      "adjusting min_rewind from %d to %d",
                                      min_rewind, min_rewind + error);
                                min_rewind += error;
                                if (min_rewind < -5) {
                                        /* is this right ? FIXME ! */
                                        /* keep sane value */
                                        min_rewind = -5;
                                        TRACE(ft_t_noise, 
                                              "clipped min_rewind to %d",
                                              min_rewind);
                                }
                        } else {
                                TRACE(ft_t_noise,
                                      "adjusting overshoot from %d to %d",
                                      overshoot, overshoot + error);
                                overshoot += error;
                                if (overshoot < -5 ||
                                    overshoot > OVERSHOOT_LIMIT) {
                                        if (overshoot < 0) {
                                                /* keep sane value */
                                                overshoot = -5;
                                        } else {
                                                /* keep sane value */
                                                overshoot = OVERSHOOT_LIMIT;
                                        }
                                        TRACE(ft_t_noise,
                                              "clipped overshoot to %d",
                                              overshoot);
                                }
                        }
                }
        } while (ft_location.segment > segment_id);
        if (ft_location.known) {
                TRACE(ft_t_noise, "current location: %d/%d",
                      ft_location.segment, ft_location.sector);
        }
        TRACE_EXIT 0;
}

static int determine_position(void)
{
        int retry = 0;
        int status;
        int result;
        TRACE_FUN(ft_t_flow);

        if (!ftape_tape_running) {
                /*  This should only happen if tape is stopped by isr.
                 */
                TRACE(ft_t_flow, "waiting for tape stop");
                if (ftape_ready_wait(ftape_timeout.pause, &status) < 0) {
                        TRACE(ft_t_flow, "drive still running (fatal)");
                        ftape_tape_running = 1; /* ? */
                }
        } else {
                ftape_report_drive_status(&status);
        }
        if (status & QIC_STATUS_READY) {
                /*  Drive must be ready to check error state !
                 */
                TRACE(ft_t_flow, "drive is ready");
                if (status & QIC_STATUS_ERROR) {
                        unsigned int error;
                        qic117_cmd_t command;

                        /*  Report and clear error state, try to continue.
                         */
                        TRACE(ft_t_flow, "error status set");
                        ftape_report_error(&error, &command, 1);
                        ftape_ready_wait(ftape_timeout.reset, &status);
                        ftape_tape_running = 0; /* ? */
                }
                if (check_bot_eot(status)) {
                        if (ft_location.bot) {
                                if ((status & QIC_STATUS_READY) == 0) {
                                        /* tape moving away from
                                         * bot/eot, let's see if we
                                         * can catch up with the first
                                         * segment on this track.
                                         */
                                } else {
                                        TRACE(ft_t_flow,
                                              "start tape from logical bot");
                                        logical_forward();      /* start moving */
                                }
                        } else {
                                if ((status & QIC_STATUS_READY) == 0) {
                                        TRACE(ft_t_noise, "waiting for logical end of track");
                                        result = ftape_ready_wait(ftape_timeout.reset, &status);
                                        /* error handling needed ? */
                                } else {
                                        TRACE(ft_t_noise,
                                              "tape at logical end of track");
                                }
                        }
                } else {
                        TRACE(ft_t_flow, "start tape");
                        logical_forward();      /* start moving */
                        ft_location.known = 0;  /* not cleared by logical forward ! */
                }
        }
        /* tape should be moving now, start reading id's
         */
        while (!ft_location.known &&
               retry++ < FT_SECTORS_PER_SEGMENT &&
               (result = ftape_read_id()) < 0) {

                TRACE(ft_t_flow, "location unknown");

                /* exit on signal
                 */
                FT_SIGNAL_EXIT(_DONT_BLOCK);

                /*  read-id somehow failed, tape may
                 *  have reached end or some other
                 *  error happened.
                 */
                TRACE(ft_t_flow, "read-id failed");
                TRACE_CATCH(ftape_report_drive_status(&status),);
                TRACE(ft_t_err, "ftape_report_drive_status: 0x%02x", status);
                if (status & QIC_STATUS_READY) {
                        ftape_tape_running = 0;
                        TRACE(ft_t_noise, "tape stopped for unknown reason! "
                              "status = 0x%02x", status);
                        if (status & QIC_STATUS_ERROR ||
                            !check_bot_eot(status)) {
                                /* oops, tape stopped but not at end!
                                 */
                                TRACE_EXIT -EIO;
                        }
                }
        }
        TRACE(ft_t_flow,
              "tape is positioned at segment %d", ft_location.segment);
        TRACE_EXIT ft_location.known ? 0 : -EIO;
}

/*      Get the tape running and position it just before the
 *      requested segment.
 *      Seek tape-track and reposition as needed.
 */
int ftape_start_tape(int segment_id, int sector_offset)
{
        int track = segment_id / ft_segments_per_track;
        int result = -EIO;
        int status;
        static int last_segment = -1;
        static int bad_bus_timing = 0;
        /* number of segments passing the head between starting the tape
         * and being able to access the first sector.
         */
        static int start_offset = 1;
        int retry;
        TRACE_FUN(ft_t_flow);

        /* If sector_offset > 0, seek into wanted segment instead of
         * into previous.
         * This allows error recovery if a part of the segment is bad
         * (erased) causing the tape drive to generate an index pulse
         * thus causing a no-data error before the requested sector
         * is reached.
         */
        ftape_tape_running = 0;
        TRACE(ft_t_noise, "target segment: %d/%d%s", segment_id, sector_offset,
                ft_buffer[ft_head]->retry > 0 ? " retry" : "");
        if (ft_buffer[ft_head]->retry > 0) {    /* this is a retry */
                int dist = segment_id - last_segment;

                if ((int)ft_history.overrun_errors < overrun_count_offset) {
                        overrun_count_offset = ft_history.overrun_errors;
                } else if (dist < 0 || dist > 50) {
                        overrun_count_offset = ft_history.overrun_errors;
                } else if ((ft_history.overrun_errors -
                            overrun_count_offset) >= 8) {
                        if (ftape_increase_threshold() >= 0) {
                                --ft_buffer[ft_head]->retry;
                                overrun_count_offset =
                                        ft_history.overrun_errors;
                                TRACE(ft_t_warn, "increased threshold because "
                                      "of excessive overrun errors");
                        } else if (!bad_bus_timing && ft_data_rate >= 1000) {
                                ftape_half_data_rate();
                                --ft_buffer[ft_head]->retry;
                                bad_bus_timing = 1;
                                overrun_count_offset =
                                        ft_history.overrun_errors;
                                TRACE(ft_t_warn, "reduced datarate because "
                                      "of excessive overrun errors");
                        }
                }
        }
        last_segment = segment_id;
        if (ft_location.track != track ||
            (ftape_might_be_off_track && ft_buffer[ft_head]->retry== 0)) {
                /* current track unknown or not equal to destination
                 */
                ftape_ready_wait(ftape_timeout.seek, &status);
                ftape_seek_head_to_track(track);
                /* overrun_count_offset = ft_history.overrun_errors; */
        }
        result = -EIO;

        retry = 0;
        while (result < 0     &&
               retry++ <= 5   &&
               !ft_failure &&
               !(sigtestsetmask(&current->pending.signal, _DONT_BLOCK))) {
                
                if (retry && start_offset < 5) {
                        start_offset ++;
                }
                /*  Check if we are able to catch the requested
                 *  segment in time.
                 */
                if ((ft_location.known || (determine_position() == 0)) &&
                    ft_location.segment >=
                    (segment_id -
                     ((ftape_tape_running || ft_location.bot)
                      ? 0 : start_offset))) {
                        /*  Too far ahead (in or past target segment).
                         */
                        if (ftape_tape_running) {
                                if ((result = ftape_stop_tape(&status)) < 0) {
                                        TRACE(ft_t_err,
                                              "stop tape failed with code %d",
                                              result);
                                        break;
                                }
                                TRACE(ft_t_noise, "tape stopped");
                                ftape_tape_running = 0;
                        }
                        TRACE(ft_t_noise, "repositioning");
                        ++ft_history.rewinds;
                        if (segment_id % ft_segments_per_track < start_offset){
                                TRACE(ft_t_noise, "end of track condition\n"
                                      KERN_INFO "segment_id        : %d\n"
                                      KERN_INFO "ft_segments_per_track: %d\n"
                                      KERN_INFO "start_offset      : %d",
                                      segment_id, ft_segments_per_track, 
                                      start_offset);
                                      
                                /*  If seeking to first segments on
                                 *  track better do a complete rewind
                                 *  to logical begin of track to get a
                                 *  more steady tape motion.  
                                 */
                                result = ftape_command_wait(
                                        (ft_location.track & 1)
                                        ? QIC_PHYSICAL_FORWARD
                                        : QIC_PHYSICAL_REVERSE,
                                        ftape_timeout.rewind, &status);
                                check_bot_eot(status);  /* update location */
                        } else {
                                result= skip_reverse(segment_id - start_offset,
                                                     &status);
                        }
                }
                if (!ft_location.known) {
                        TRACE(ft_t_bug, "panic: location not known");
                        result = -EIO;
                        continue; /* while() will check for failure */
                }
                TRACE(ft_t_noise, "current segment: %d/%d",
                      ft_location.segment, ft_location.sector);
                /*  We're on the right track somewhere before the
                 *  wanted segment.  Start tape movement if needed and
                 *  skip to just before or inside the requested
                 *  segment. Keep tape running.  
                 */
                result = 0;
                if (ft_location.segment < 
                    (segment_id - ((ftape_tape_running || ft_location.bot)
                                   ? 0 : start_offset))) {
                        if (sector_offset > 0) {
                                result = seek_forward(segment_id,
                                                      retry <= 3);
                        } else {
                                result = seek_forward(segment_id - 1,
                                                      retry <= 3);
                        }
                }
                if (result == 0 &&
                    ft_location.segment !=
                    (segment_id - (sector_offset > 0 ? 0 : 1))) {
                        result = -EIO;
                }
        }
        if (result < 0) {
                TRACE(ft_t_err, "failed to reposition");
        } else {
                ft_runner_status = running;
        }
        TRACE_EXIT result;
}