Subversion Repositories or1k

/*

 *      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: /home/marcus/revision_ctrl_test/oc_cvs/cvs/or1k/linux/linux-2.4/drivers/char/ftape/lowlevel/ftape-rw.c,v $

 * $Revision: 1.1.1.1 $

 * $Date: 2004-04-15 02:02:41 $

 *

 *      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);