URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [block/] [ide-tape.c] - Blame information for rev 1772

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * linux/drivers/block/ide-tape.c       Version 1.91            May  21, 1998
 *
 * Copyright (C) 1995, 1996 Gadi Oxman <gadio@netvision.net.il>
 *
 * This driver was constructed as a student project in the software laboratory
 * of the faculty of electrical engineering in the Technion - Israel's
 * Institute Of Technology, with the guide of Avner Lottem and Dr. Ilana David.
 *
 * It is hereby placed under the terms of the GNU general public license.
 * (See linux/COPYING).
 */
 
/*
 * IDE ATAPI streaming tape driver.
 *
 * This driver is a part of the Linux ide driver and works in co-operation
 * with linux/drivers/block/ide.c.
 *
 * The driver, in co-operation with ide.c, basically traverses the
 * request-list for the block device interface. The character device
 * interface, on the other hand, creates new requests, adds them
 * to the request-list of the block device, and waits for their completion.
 *
 * Pipelined operation mode is now supported on both reads and writes.
 *
 * The block device major and minor numbers are determined from the
 * tape's relative position in the ide interfaces, as explained in ide.c.
 *
 * The character device interface consists of two devices:
 *
 * ht0          major=37,minor=0        first IDE tape, rewind on close.
 * nht0         major=37,minor=128      first IDE tape, no rewind on close.
 *
 * Run /usr/src/linux/scripts/MAKEDEV.ide to create the above entries.
 * We currently support only one ide tape drive.
 *
 * The general magnetic tape commands compatible interface, as defined by
 * include/linux/mtio.h, is accessible through the character device.
 *
 * General ide driver configuration options, such as the interrupt-unmask
 * flag, can be configured by issuing an ioctl to the block device interface,
 * as any other ide device.
 *
 * Our own ide-tape ioctl's can be issued to either the block device or
 * the character device interface.
 *
 * Maximal throughput with minimal bus load will usually be achieved in the
 * following scenario:
 *
 *      1.      ide-tape is operating in the pipelined operation mode.
 *      2.      All character device read/write requests consist of an
 *              integral number of the tape's recommended data transfer unit
 *              (which is shown on initialization and can be received with
 *               an ioctl).
 *              As of version 1.3 of the driver, this is no longer as critical
 *              as it used to be.
 *      3.      No buffering is performed by the user backup program.
 *
 * Testing was done with a 2 GB CONNER CTMA 4000 IDE ATAPI Streaming Tape Drive.
 *
 * Ver 0.1   Nov  1 95   Pre-working code :-)
 * Ver 0.2   Nov 23 95   A short backup (few megabytes) and restore procedure
 *                        was successful ! (Using tar cvf ... on the block
 *                        device interface).
 *                       A longer backup resulted in major swapping, bad
 *                        overall Linux performance and eventually failed as
 *                        we received non serial read-ahead requests from the
 *                        buffer cache.
 * Ver 0.3   Nov 28 95   Long backups are now possible, thanks to the
 *                        character device interface. Linux's responsiveness
 *                        and performance doesn't seem to be much affected
 *                        from the background backup procedure.
 *                       Some general mtio.h magnetic tape operations are
 *                        now supported by our character device. As a result,
 *                        popular tape utilities are starting to work with
 *                        ide tapes :-)
 *                       The following configurations were tested:
 *                              1. An IDE ATAPI TAPE shares the same interface
 *                                 and irq with an IDE ATAPI CDROM.
 *                              2. An IDE ATAPI TAPE shares the same interface
 *                                 and irq with a normal IDE disk.
 *                        Both configurations seemed to work just fine !
 *                        However, to be on the safe side, it is meanwhile
 *                        recommended to give the IDE TAPE its own interface
 *                        and irq.
 *                       The one thing which needs to be done here is to
 *                        add a "request postpone" feature to ide.c,
 *                        so that we won't have to wait for the tape to finish
 *                        performing a long media access (DSC) request (such
 *                        as a rewind) before we can access the other device
 *                        on the same interface. This effect doesn't disturb
 *                        normal operation most of the time because read/write
 *                        requests are relatively fast, and once we are
 *                        performing one tape r/w request, a lot of requests
 *                        from the other device can be queued and ide.c will
 *                        service all of them after this single tape request.
 * Ver 1.0   Dec 11 95   Integrated into Linux 1.3.46 development tree.
 *                       On each read / write request, we now ask the drive
 *                        if we can transfer a constant number of bytes
 *                        (a parameter of the drive) only to its buffers,
 *                        without causing actual media access. If we can't,
 *                        we just wait until we can by polling the DSC bit.
 *                        This ensures that while we are not transferring
 *                        more bytes than the constant referred to above, the
 *                        interrupt latency will not become too high and
 *                        we won't cause an interrupt timeout, as happened
 *                        occasionally in the previous version.
 *                       While polling for DSC, the current request is
 *                        postponed and ide.c is free to handle requests from
 *                        the other device. This is handled transparently to
 *                        ide.c. The hwgroup locking method which was used
 *                        in the previous version was removed.
 *                       Use of new general features which are provided by
 *                        ide.c for use with atapi devices.
 *                        (Programming done by Mark Lord)
 *                       Few potential bug fixes (Again, suggested by Mark)
 *                       Single character device data transfers are now
 *                        not limited in size, as they were before.
 *                       We are asking the tape about its recommended
 *                        transfer unit and send a larger data transfer
 *                        as several transfers of the above size.
 *                        For best results, use an integral number of this
 *                        basic unit (which is shown during driver
 *                        initialization). I will soon add an ioctl to get
 *                        this important parameter.
 *                       Our data transfer buffer is allocated on startup,
 *                        rather than before each data transfer. This should
 *                        ensure that we will indeed have a data buffer.
 * Ver 1.1   Dec 14 95   Fixed random problems which occurred when the tape
 *                        shared an interface with another device.
 *                        (poll_for_dsc was a complete mess).
 *                       Removed some old (non-active) code which had
 *                        to do with supporting buffer cache originated
 *                        requests.
 *                       The block device interface can now be opened, so
 *                        that general ide driver features like the unmask
 *                        interrupts flag can be selected with an ioctl.
 *                        This is the only use of the block device interface.
 *                       New fast pipelined operation mode (currently only on
 *                        writes). When using the pipelined mode, the
 *                        throughput can potentially reach the maximum
 *                        tape supported throughput, regardless of the
 *                        user backup program. On my tape drive, it sometimes
 *                        boosted performance by a factor of 2. Pipelined
 *                        mode is enabled by default, but since it has a few
 *                        downfalls as well, you may want to disable it.
 *                        A short explanation of the pipelined operation mode
 *                        is available below.
 * Ver 1.2   Jan  1 96   Eliminated pipelined mode race condition.
 *                       Added pipeline read mode. As a result, restores
 *                        are now as fast as backups.
 *                       Optimized shared interface behavior. The new behavior
 *                        typically results in better IDE bus efficiency and
 *                        higher tape throughput.
 *                       Pre-calculation of the expected read/write request
 *                        service time, based on the tape's parameters. In
 *                        the pipelined operation mode, this allows us to
 *                        adjust our polling frequency to a much lower value,
 *                        and thus to dramatically reduce our load on Linux,
 *                        without any decrease in performance.
 *                       Implemented additional mtio.h operations.
 *                       The recommended user block size is returned by
 *                        the MTIOCGET ioctl.
 *                       Additional minor changes.
 * Ver 1.3   Feb  9 96   Fixed pipelined read mode bug which prevented the
 *                        use of some block sizes during a restore procedure.
 *                       The character device interface will now present a
 *                        continuous view of the media - any mix of block sizes
 *                        during a backup/restore procedure is supported. The
 *                        driver will buffer the requests internally and
 *                        convert them to the tape's recommended transfer
 *                        unit, making performance almost independent of the
 *                        chosen user block size.
 *                       Some improvements in error recovery.
 *                       By cooperating with triton.c, bus mastering DMA can
 *                        now sometimes be used with IDE tape drives as well.
 *                        Bus mastering DMA has the potential to dramatically
 *                        reduce the CPU's overhead when accessing the device,
 *                        and can be enabled by using hdparm -d1 on the tape's
 *                        block device interface. For more info, read the
 *                        comments in triton.c.
 * Ver 1.4   Mar 13 96   Fixed serialize support.
 * Ver 1.5   Apr 12 96   Fixed shared interface operation, broken in 1.3.85.
 *                       Fixed pipelined read mode inefficiency.
 *                       Fixed nasty null dereferencing bug.
 * Ver 1.6   Aug 16 96   Fixed FPU usage in the driver.
 *                       Fixed end of media bug.
 * Ver 1.7   Sep 10 96   Minor changes for the CONNER CTT8000-A model.
 * Ver 1.8   Sep 26 96   Attempt to find a better balance between good
 *                        interactive response and high system throughput.
 * Ver 1.9   Nov  5 96   Automatically cross encountered filemarks rather
 *                        than requiring an explicit FSF command.
 *                       Abort pending requests at end of media.
 *                       MTTELL was sometimes returning incorrect results.
 *                       Return the real block size in the MTIOCGET ioctl.
 *                       Some error recovery bug fixes.
 * Ver 1.91  May 21 98   Add support for INTERRUPT DRQ devices.
 *                       Add "speed == 0" work-around for HP COLORADO 5GB
 *
 * Here are some words from the first releases of hd.c, which are quoted
 * in ide.c and apply here as well:
 *
 * | Special care is recommended.  Have Fun!
 *
 */
 
/*
 * An overview of the pipelined operation mode.
 *
 * In the pipelined write mode, we will usually just add requests to our
 * pipeline and return immediately, before we even start to service them. The
 * user program will then have enough time to prepare the next request while
 * we are still busy servicing previous requests. In the pipelined read mode,
 * the situation is similar - we add read-ahead requests into the pipeline,
 * before the user even requested them.
 *
 * The pipeline can be viewed as a "safety net" which will be activated when
 * the system load is high and prevents the user backup program from keeping up
 * with the current tape speed. At this point, the pipeline will get
 * shorter and shorter but the tape will still be streaming at the same speed.
 * Assuming we have enough pipeline stages, the system load will hopefully
 * decrease before the pipeline is completely empty, and the backup program
 * will be able to "catch up" and refill the pipeline again.
 *
 * When using the pipelined mode, it would be best to disable any type of
 * buffering done by the user program, as ide-tape already provides all the
 * benefits in the kernel, where it can be done in a more efficient way.
 * As we will usually not block the user program on a request, the most
 * efficient user code will then be a simple read-write-read-... cycle.
 * Any additional logic will usually just slow down the backup process.
 *
 * Using the pipelined mode, I get a constant over 400 KBps throughput,
 * which seems to be the maximum throughput supported by my tape.
 *
 * However, there are some downfalls:
 *
 *      1.      We use memory (for data buffers) in proportional to the number
 *              of pipeline stages (each stage is about 26 KB with my tape).
 *      2.      In the pipelined write mode, we cheat and postpone error codes
 *              to the user task. In read mode, the actual tape position
 *              will be a bit further than the last requested block.
 *
 * Concerning (1):
 *
 *      1.      We allocate stages dynamically only when we need them. When
 *              we don't need them, we don't consume additional memory. In
 *              case we can't allocate stages, we just manage without them
 *              (at the expense of decreased throughput) so when Linux is
 *              tight in memory, we will not pose additional difficulties.
 *
 *      2.      The maximum number of stages (which is, in fact, the maximum
 *              amount of memory) which we allocate is limited by the compile
 *              time parameter IDETAPE_MAX_PIPELINE_STAGES.
 *
 *      3.      The maximum number of stages is a controlled parameter - We
 *              don't start from the user defined maximum number of stages
 *              but from the lower IDETAPE_MIN_PIPELINE_STAGES (again, we
 *              will not even allocate this amount of stages if the user
 *              program can't handle the speed). We then implement a feedback
 *              loop which checks if the pipeline is empty, and if it is, we
 *              increase the maximum number of stages as necessary until we
 *              reach the optimum value which just manages to keep the tape
 *              busy with minimum allocated memory or until we reach
 *              IDETAPE_MAX_PIPELINE_STAGES.
 *
 * Concerning (2):
 *
 *      In pipelined write mode, ide-tape can not return accurate error codes
 *      to the user program since we usually just add the request to the
 *      pipeline without waiting for it to be serviced. In case an error
 *      occurs, I will report it on the next user request.
 *
 *      In the pipelined read mode, subsequent read requests or forward
 *      filemark spacing will perform correctly, as we preserve all blocks
 *      and filemarks which we encountered during our excess read-ahead.
 *
 *      For accurate tape positioning and error reporting, disabling
 *      pipelined mode might be the best option.
 *
 * You can enable/disable/tune the pipelined operation mode by adjusting
 * the compile time parameters in ide-tape.h.
 */
 
/*
 *      Possible improvements.
 *
 *      1.      Support for the ATAPI overlap protocol.
 *
 *              In order to maximize bus throughput, we currently use the DSC
 *              overlap method which enables ide.c to service requests from the
 *              other device while the tape is busy executing a command. The
 *              DSC overlap method involves polling the tape's status register
 *              for the DSC bit, and servicing the other device while the tape
 *              isn't ready.
 *
 *              In the current QIC development standard (December 1995),
 *              it is recommended that new tape drives will *in addition*
 *              implement the ATAPI overlap protocol, which is used for the
 *              same purpose - efficient use of the IDE bus, but is interrupt
 *              driven and thus has much less CPU overhead.
 *
 *              ATAPI overlap is likely to be supported in most new ATAPI
 *              devices, including new ATAPI cdroms, and thus provides us
 *              a method by which we can achieve higher throughput when
 *              sharing a (fast) ATA-2 disk with any (slow) new ATAPI device.
 */
 
#include <linux/config.h>
#include <linux/hdreg.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/major.h>
#include <linux/blkdev.h>
#include <linux/errno.h>
#include <linux/hdreg.h>
#include <linux/genhd.h>
#include <linux/malloc.h>
 
#include <asm/byteorder.h>
#include <asm/irq.h>
#include <asm/segment.h>
#include <asm/io.h>
 
/*
 *      Main Linux ide driver include file
 *
 *      Automatically includes our include file - ide-tape.h.
 */
 
#include "ide.h"                
 
/*
 *      Supported ATAPI tape drives packet commands
 */
 
#define IDETAPE_TEST_UNIT_READY_CMD     0x00
#define IDETAPE_REWIND_CMD              0x01
#define IDETAPE_REQUEST_SENSE_CMD       0x03
#define IDETAPE_READ_CMD                0x08
#define IDETAPE_WRITE_CMD               0x0a
#define IDETAPE_WRITE_FILEMARK_CMD      0x10
#define IDETAPE_SPACE_CMD               0x11
#define IDETAPE_INQUIRY_CMD             0x12
#define IDETAPE_ERASE_CMD               0x19
#define IDETAPE_MODE_SENSE_CMD          0x1a
#define IDETAPE_LOAD_UNLOAD_CMD         0x1b
#define IDETAPE_LOCATE_CMD              0x2b
#define IDETAPE_READ_POSITION_CMD       0x34
 
/*
 *      Some defines for the SPACE command
 *
 *      (The code field in the SPACE packet command).
 */
 
#define IDETAPE_SPACE_OVER_FILEMARK     1
#define IDETAPE_SPACE_TO_EOD            3
 
/*
 *      Some defines for the LOAD UNLOAD command
 */
 
#define IDETAPE_LU_LOAD_MASK            1
#define IDETAPE_LU_RETENSION_MASK       2
#define IDETAPE_LU_EOT_MASK             4
 
/*
 *      Our ioctls - We will use 0x034n and 0x035n
 *
 *      Nothing special meanwhile.
 *      mtio.h MTIOCTOP compatible commands are supported on the character
 *      device interface.
 */
 
/*
 *      Special requests for our block device strategy routine.
 *
 *      In order to service a character device command, we add special
 *      requests to the tail of our block device request queue and wait
 *      for their completion.
 *
 */
 
#define IDETAPE_FIRST_REQUEST                   90
 
/*
 *      IDETAPE_PACKET_COMMAND_REQUEST_TYPE1 is used to queue a packet command
 *      in the request queue. We will wait for DSC before issuing the command
 *      if it is still not set. In that case, we will temporary replace the
 *      cmd field to type 2 and restore it back to type 1 when we receive DSC
 *      and can start with sending the command.
 */
 
#define IDETAPE_PACKET_COMMAND_REQUEST_TYPE1    90
#define IDETAPE_PACKET_COMMAND_REQUEST_TYPE2    91
 
/*
 *      IDETAPE_READ_REQUEST and IDETAPE_WRITE_REQUEST are used by our
 *      character device interface to request read/write operations from
 *      our block device interface.
 *
 *      In case a read or write request was requested by the buffer cache
 *      and not by our character device interface, the cmd field in the
 *      request will contain READ and WRITE instead.
 *
 *      We handle both cases in a similar way. The main difference is that
 *      in our own requests, buffer head is NULL and idetape_end_request
 *      will update the errors field if the request was not completed.
 */
 
#define IDETAPE_READ_REQUEST                    92
#define IDETAPE_WRITE_REQUEST                   93
#define IDETAPE_ABORTED_WRITE_REQUEST           94
 
#define IDETAPE_LAST_REQUEST                    94
 
/*
 *      A macro which can be used to check if a we support a given
 *      request command.
 */
 
#define IDETAPE_REQUEST_CMD(cmd)        ((cmd >= IDETAPE_FIRST_REQUEST) && (cmd <= IDETAPE_LAST_REQUEST))
 
/*
 *      We are now able to postpone an idetape request in the stage
 *      where it is polling for DSC and service requests from the other
 *      ide device meanwhile.
 */
 
#define IDETAPE_RQ_POSTPONED            0x1234
 
/*
 *      Error codes which are returned in rq->errors to the higher part
 *      of the driver.
 */
 
#define IDETAPE_RQ_ERROR_GENERAL        1 
#define IDETAPE_RQ_ERROR_FILEMARK       2
#define IDETAPE_RQ_ERROR_EOD            3
 
/*
 *      ATAPI Task File Registers (Re-definition of the ATA Task File
 *      Registers for an ATAPI packet command).
 *      From Table 3-2 of QIC-157C.
 */
 
/* Read Access */
 
#define IDETAPE_DATA_OFFSET             (0)
#define IDETAPE_ERROR_OFFSET            (1)
#define IDETAPE_IREASON_OFFSET          (2)
#define IDETAPE_RESERVED3_OFFSET        (3)
#define IDETAPE_BCOUNTL_OFFSET          (4)
#define IDETAPE_BCOUNTH_OFFSET          (5)
#define IDETAPE_DRIVESEL_OFFSET         (6)
#define IDETAPE_STATUS_OFFSET           (7)
 
#define IDETAPE_DATA_REG                (HWIF(drive)->io_base+IDETAPE_DATA_OFFSET)
#define IDETAPE_ERROR_REG               (HWIF(drive)->io_base+IDETAPE_ERROR_OFFSET)
#define IDETAPE_IREASON_REG             (HWIF(drive)->io_base+IDETAPE_IREASON_OFFSET)
#define IDETAPE_RESERVED3_REG           (HWIF(drive)->io_base+IDETAPE_RESERVED3_OFFSET)
#define IDETAPE_BCOUNTL_REG             (HWIF(drive)->io_base+IDETAPE_BCOUNTL_OFFSET)
#define IDETAPE_BCOUNTH_REG             (HWIF(drive)->io_base+IDETAPE_BCOUNTH_OFFSET)
#define IDETAPE_DRIVESEL_REG            (HWIF(drive)->io_base+IDETAPE_DRIVESEL_OFFSET)
#define IDETAPE_STATUS_REG              (HWIF(drive)->io_base+IDETAPE_STATUS_OFFSET)
 
/* Write Access */
 
#define IDETAPE_FEATURES_OFFSET         (1)
#define IDETAPE_ATACOMMAND_OFFSET       (7)
 
#define IDETAPE_FEATURES_REG            (HWIF(drive)->io_base+IDETAPE_FEATURES_OFFSET)
#define IDETAPE_ATACOMMAND_REG          (HWIF(drive)->io_base+IDETAPE_ATACOMMAND_OFFSET)
#define IDETAPE_CONTROL_REG             (HWIF(drive)->ctl_port)
 
 
/*
 *      Structure of the various task file registers
 */
 
/*
 *      The ATAPI Status Register.
 */
 
typedef union {
        unsigned all                    :8;
        struct {
                unsigned check          :1;     /* Error occurred */
                unsigned idx            :1;     /* Reserved */
                unsigned corr           :1;     /* Correctable error occurred */
                unsigned drq            :1;     /* Data is request by the device */
                unsigned dsc            :1;     /* Set when a media access command is finished */
                                                /* Reads / Writes are NOT media access commands */
                unsigned reserved5      :1;     /* Reserved */
                unsigned drdy           :1;     /* Ignored for ATAPI commands */
                                                /* (The device is ready to accept ATA command) */
                unsigned bsy            :1;     /* The device has access to the command block */
        } b;
} idetape_status_reg_t;
 
/*
 *      The ATAPI error register.
 */
 
typedef union {
        unsigned all                    :8;
        struct {
                unsigned ili            :1;     /* Illegal Length Indication */
                unsigned eom            :1;     /* End Of Media Detected */
                unsigned abrt           :1;     /* Aborted command - As defined by ATA */
                unsigned mcr            :1;     /* Media Change Requested - As defined by ATA */
                unsigned sense_key      :4;     /* Sense key of the last failed packet command */
        } b;
} idetape_error_reg_t;
 
/*
 *      ATAPI Feature Register
 */
 
typedef union {
        unsigned all                    :8;
        struct {
                unsigned dma            :1;     /* Using DMA of PIO */
                unsigned reserved321    :3;     /* Reserved */
                unsigned reserved654    :3;     /* Reserved (Tag Type) */
                unsigned reserved7      :1;     /* Reserved */
        } b;
} idetape_feature_reg_t;
 
/*
 *      ATAPI Byte Count Register.
 */
 
typedef union {
        unsigned all                    :16;
        struct {
                unsigned low            :8;     /* LSB */
                unsigned high           :8;     /* MSB */
        } b;
} idetape_bcount_reg_t;
 
/*
 *      ATAPI Interrupt Reason Register.
 */
 
typedef union {
        unsigned all                    :8;
        struct {
                unsigned cod            :1;     /* Information transferred is command (1) or data (0) */
                unsigned io             :1;     /* The device requests us to read (1) or write (0) */
                unsigned reserved       :6;     /* Reserved */
        } b;
} idetape_ireason_reg_t;
 
/*
 *      ATAPI Drive Select Register
 */
 
typedef union {
        unsigned all                    :8;
        struct {
                unsigned sam_lun        :4;     /* Should be zero with ATAPI (not used) */
                unsigned drv            :1;     /* The responding drive will be drive 0 (0) or drive 1 (1) */
                unsigned one5           :1;     /* Should be set to 1 */
                unsigned reserved6      :1;     /* Reserved */
                unsigned one7           :1;     /* Should be set to 1 */
        } b;
} idetape_drivesel_reg_t;
 
/*
 *      ATAPI Device Control Register
 */
 
typedef union {
        unsigned all                    :8;
        struct {
                unsigned zero0          :1;     /* Should be set to zero */
                unsigned nien           :1;     /* Device interrupt is disabled (1) or enabled (0) */
                unsigned srst           :1;     /* ATA software reset. ATAPI devices should use the new ATAPI srst. */
                unsigned one3           :1;     /* Should be set to 1 */
                unsigned reserved4567   :4;     /* Reserved */
        } b;
} idetape_control_reg_t;
 
/*
 *      idetape_chrdev_t provides the link between out character device
 *      interface and our block device interface and the corresponding
 *      ide_drive_t structure.
 *
 *      We currently support only one tape drive.
 *
 */
 
typedef struct {
        ide_drive_t *drive;
        int major,minor;
        char name[4];
} idetape_chrdev_t;
 
/*
 *      The following is used to format the general configuration word of
 *      the ATAPI IDENTIFY DEVICE command.
 */
 
struct idetape_id_gcw {
 
        unsigned packet_size    :2;     /* Packet Size */
        unsigned reserved2      :1;     /* Reserved */
        unsigned reserved3      :1;     /* Reserved */
        unsigned reserved4      :1;     /* Reserved */
        unsigned drq_type       :2;     /* Command packet DRQ type */
        unsigned removable      :1;     /* Removable media */
        unsigned device_type    :5;     /* Device type */
        unsigned reserved13     :1;     /* Reserved */
        unsigned protocol       :2;     /* Protocol type */
};
 
/*
 *      INQUIRY packet command - Data Format (From Table 6-8 of QIC-157C)
 */
 
typedef struct {
        unsigned device_type    :5;     /* Peripheral Device Type */
        unsigned reserved0_765  :3;     /* Peripheral Qualifier - Reserved */
        unsigned reserved1_6t0  :7;     /* Reserved */
        unsigned rmb            :1;     /* Removable Medium Bit */
        unsigned ansi_version   :3;     /* ANSI Version */
        unsigned ecma_version   :3;     /* ECMA Version */
        unsigned iso_version    :2;     /* ISO Version */
        unsigned response_format :4;    /* Response Data Format */
        unsigned reserved3_45   :2;     /* Reserved */
        unsigned reserved3_6    :1;     /* TrmIOP - Reserved */
        unsigned reserved3_7    :1;     /* AENC - Reserved */
        byte additional_length;         /* Additional Length (total_length-4) */
        byte reserved_5;                /* Reserved */
        byte reserved_6;                /* Reserved */
        unsigned reserved7_0    :1;     /* SftRe - Reserved */
        unsigned reserved7_1    :1;     /* CmdQue - Reserved */
        unsigned reserved7_2    :1;     /* Reserved */
        unsigned reserved7_3    :1;     /* Linked - Reserved */
        unsigned reserved7_4    :1;     /* Sync - Reserved */
        unsigned reserved7_5    :1;     /* WBus16 - Reserved */
        unsigned reserved7_6    :1;     /* WBus32 - Reserved */
        unsigned reserved7_7    :1;     /* RelAdr - Reserved */
        byte vendor_id [8];             /* Vendor Identification */
        byte product_id [16];           /* Product Identification */
        byte revision_level [4];        /* Revision Level */
        byte vendor_specific [20];      /* Vendor Specific - Optional */
        byte reserved56t95 [40];        /* Reserved - Optional */
 
                                        /* Additional information may be returned */
} idetape_inquiry_result_t;
 
/*
 *      READ POSITION packet command - Data Format (From Table 6-57)
 */
 
typedef struct {
        unsigned reserved0_10   :2;     /* Reserved */
        unsigned bpu            :1;     /* Block Position Unknown */
        unsigned reserved0_543  :3;     /* Reserved */
        unsigned eop            :1;     /* End Of Partition */
        unsigned bop            :1;     /* Beginning Of Partition */
        byte partition_num;             /* Partition Number */
        byte reserved_2;                /* Reserved */
        byte reserved_3;                /* Reserved */
        unsigned long first_block;      /* First Block Location */
        unsigned long last_block;       /* Last Block Location (Optional) */
        byte reserved_12;               /* Reserved */
        byte blocks_in_buffer_2;        /* Blocks In Buffer - MSB (Optional) */
        byte blocks_in_buffer_1;
        byte blocks_in_buffer_0;        /* Blocks In Buffer - LSB (Optional) */
        unsigned long bytes_in_buffer;  /* Bytes In Buffer (Optional) */
} idetape_read_position_result_t;
 
/*
 *      REQUEST SENSE packet command result - Data Format.
 */
 
typedef struct {
        unsigned error_code     :7;     /* Current of deferred errors */
        unsigned valid          :1;     /* The information field conforms to QIC-157C */
        unsigned reserved_1     :8;     /* Segment Number - Reserved */
        unsigned sense_key      :4;     /* Sense Key */
        unsigned reserved2_4    :1;     /* Reserved */
        unsigned ili            :1;     /* Incorrect Length Indicator */
        unsigned eom            :1;     /* End Of Medium */
        unsigned filemark       :1;     /* Filemark */
 
        /*
         *      We can't use a 32 bit variable, since it will be re-aligned
         *      by GCC, as we are not on a 32 bit boundary.
         */
 
        byte information1;              /* MSB - Information - Command specific */
        byte information2;
        byte information3;
        byte information4;              /* LSB */
        byte asl;                       /* Additional sense length (n-7) */
        unsigned long command_specific; /* Additional command specific information */
        byte asc;                       /* Additional Sense Code */
        byte ascq;                      /* Additional Sense Code Qualifier */
        byte replaceable_unit_code;     /* Field Replaceable Unit Code */
        unsigned sk_specific1   :7;     /* Sense Key Specific */
        unsigned sksv           :1;     /* Sense Key Specific information is valid */
        byte sk_specific2;              /* Sense Key Specific */
        byte sk_specific3;              /* Sense Key Specific */
        byte pad [2];                   /* Padding to 20 bytes */
} idetape_request_sense_result_t;
 
/*
 *      Follows structures which are related to the SELECT SENSE / MODE SENSE
 *      packet commands. Those packet commands are still not supported
 *      by ide-tape.
 */
 
#define IDETAPE_CAPABILITIES_PAGE       0x2a
 
/*
 *      Mode Parameter Header for the MODE SENSE packet command
 */
 
typedef struct {
        byte mode_data_length;          /* The length of the following data that is */
                                        /* available to be transferred */
        byte medium_type;               /* Medium Type */
        byte dsp;                       /* Device Specific Parameter */
        byte bdl;                       /* Block Descriptor Length */
} idetape_mode_parameter_header_t;
 
/*
 *      Mode Parameter Block Descriptor the MODE SENSE packet command
 *
 *      Support for block descriptors is optional.
 */
 
typedef struct {
        byte density_code;              /* Medium density code */
        byte blocks1;                   /* Number of blocks - MSB */
        byte blocks2;                   /* Number of blocks - Middle byte */
        byte blocks3;                   /* Number of blocks - LSB */
        byte reserved4;                 /* Reserved */
        byte length1;                   /* Block Length - MSB */
        byte length2;                   /* Block Length - Middle byte */
        byte length3;                   /* Block Length - LSB */
} idetape_parameter_block_descriptor_t;
 
/*
 *      The Data Compression Page, as returned by the MODE SENSE packet command.
 */
 
typedef struct {
        unsigned page_code      :6;     /* Page Code - Should be 0xf */
        unsigned reserved       :1;     /* Reserved */
        unsigned ps             :1;
        byte page_length;               /* Page Length - Should be 14 */
        unsigned reserved2      :6;     /* Reserved */
        unsigned dcc            :1;     /* Data Compression Capable */
        unsigned dce            :1;     /* Data Compression Enable */
        unsigned reserved3      :5;     /* Reserved */
        unsigned red            :2;     /* Report Exception on Decompression */
        unsigned dde            :1;     /* Data Decompression Enable */
        unsigned long ca;               /* Compression Algorithm */
        unsigned long da;               /* Decompression Algorithm */
        byte reserved_12;               /* Reserved */
        byte reserved_13;               /* Reserved */
        byte reserved_14;               /* Reserved */
        byte reserved_15;               /* Reserved */
} idetape_data_compression_page_t;
 
/*
 *      The Medium Partition Page, as returned by the MODE SENSE packet command.
 */
 
typedef struct {
        unsigned page_code      :6;     /* Page Code - Should be 0x11 */
        unsigned reserved1_6    :1;     /* Reserved */
        unsigned ps             :1;
        byte page_length;               /* Page Length - Should be 6 */
        byte map;                       /* Maximum Additional Partitions - Should be 0 */
        byte apd;                       /* Additional Partitions Defined - Should be 0 */
        unsigned reserved4_012  :3;     /* Reserved */
        unsigned psum           :2;     /* Should be 0 */
        unsigned idp            :1;     /* Should be 0 */
        unsigned sdp            :1;     /* Should be 0 */
        unsigned fdp            :1;     /* Fixed Data Partitions */
        byte mfr;                       /* Medium Format Recognition */
        byte reserved6;                 /* Reserved */
        byte reserved7;                 /* Reserved */
} idetape_medium_partition_page_t;
 
/*
 *      Prototypes of various functions in ide-tape.c
 *
 *      The following functions are called from ide.c, and their prototypes
 *      are available in ide.h:
 *
 *              idetape_identify_device
 *              idetape_setup
 *              idetape_blkdev_ioctl
 *              idetape_do_request
 *              idetape_blkdev_open
 *              idetape_blkdev_release
 *              idetape_register_chrdev (void);
 */
 
/*
 *      The following functions are used to transfer data from / to the
 *      tape's data register.
 */
 
void idetape_input_data (ide_drive_t *drive,void *buffer, unsigned long bcount);
void idetape_output_data (ide_drive_t *drive,void *buffer, unsigned long bcount);
void idetape_discard_data (ide_drive_t *drive, unsigned long bcount);
 
/*
 *      Packet command related functions.
 */
 
void idetape_issue_packet_command  (ide_drive_t *drive,idetape_packet_command_t *pc,ide_handler_t *handler);
void idetape_pc_intr (ide_drive_t *drive);
 
/*
 *      DSC handling functions.
 */
 
void idetape_postpone_request (ide_drive_t *drive);
void idetape_poll_for_dsc (unsigned long data);
void idetape_poll_for_dsc_direct (unsigned long data);
void idetape_put_back_postponed_request (ide_drive_t *drive);
void idetape_media_access_finished (ide_drive_t *drive);
 
/*
 *      Some more packet command related functions.
 */
 
void idetape_pc_callback (ide_drive_t *drive);
void idetape_retry_pc (ide_drive_t *drive);
void idetape_zero_packet_command (idetape_packet_command_t *pc);
void idetape_queue_pc_head (ide_drive_t *drive,idetape_packet_command_t *pc,struct request *rq);
void idetape_analyze_error (ide_drive_t *drive,idetape_request_sense_result_t *result);
 
idetape_packet_command_t *idetape_next_pc_storage (ide_drive_t *drive);
struct request *idetape_next_rq_storage (ide_drive_t *drive);
 
/*
 *      Various packet commands
 */
 
void idetape_create_inquiry_cmd (idetape_packet_command_t *pc);
void idetape_inquiry_callback (ide_drive_t *drive);
void idetape_create_locate_cmd (idetape_packet_command_t *pc,unsigned long block,byte partition);
void idetape_create_rewind_cmd (idetape_packet_command_t *pc);
void idetape_create_write_filemark_cmd (idetape_packet_command_t *pc,int write_filemark);
void idetape_create_load_unload_cmd (idetape_packet_command_t *pc,int cmd);
void idetape_create_space_cmd (idetape_packet_command_t *pc,long count,byte cmd);
void idetape_create_erase_cmd (idetape_packet_command_t *pc);
void idetape_create_test_unit_ready_cmd (idetape_packet_command_t *pc);
void idetape_create_read_position_cmd (idetape_packet_command_t *pc);
void idetape_read_position_callback (ide_drive_t *drive);
void idetape_create_read_cmd (idetape_packet_command_t *pc,unsigned long length);
void idetape_read_callback (ide_drive_t *drive);
void idetape_create_write_cmd (idetape_packet_command_t *pc,unsigned long length);
void idetape_write_callback (ide_drive_t *drive);
void idetape_create_request_sense_cmd (idetape_packet_command_t *pc);
void idetape_create_mode_sense_cmd (idetape_packet_command_t *pc,byte page_code);
void idetape_request_sense_callback (ide_drive_t *drive);
 
void idetape_display_inquiry_result (byte *buffer);
 
/*
 *      Character device callback functions.
 *
 *      We currently support:
 *
 *              OPEN, RELEASE, READ, WRITE and IOCTL.
 */
 
int idetape_chrdev_read (struct inode *inode, struct file *file, char *buf, int count);
int idetape_chrdev_write (struct inode *inode, struct file *file, const char *buf, int count);
int idetape_chrdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
int idetape_chrdev_open (struct inode *inode, struct file *file);
void idetape_chrdev_release (struct inode *inode,struct file *file);
 
/*
 *      idetape_mtioctop implements general magnetic tape io control
 *      commands, as defined in include/linux/mtio.h. Those commands are
 *      accessed through the character device interface, using the MTIOCTOP
 *      ioctl.
 */
 
int idetape_mtioctop (ide_drive_t *drive,short mt_op,int mt_count);
 
/*
 *      idetape_space_over_filemarks handles the MTFSF, MTFSFM, ... mtio.h
 *      commands.
 */
 
int idetape_space_over_filemarks (ide_drive_t *drive,short mt_op,int mt_count);
 
/*
 *      idetape_add_chrdev_read_request is called from idetape_chrdev_read
 *      to service a character device read request and add read-ahead
 *      requests to our pipeline.
 */
 
int idetape_add_chrdev_read_request (ide_drive_t *drive,int blocks,char *buffer);
 
/*
 *      idetape_add_chrdev_write_request adds a character device write
 *      request to the pipeline.
 */
 
int idetape_add_chrdev_write_request (ide_drive_t *drive,int blocks,char *buffer);
 
/*
 *      idetape_queue_rw_tail will add a command to the tail of the device
 *      request queue and wait for it to finish. This is used when we
 *      can not allocate pipeline stages (or in non-pipelined mode).
 */
 
int idetape_queue_rw_tail (ide_drive_t *drive,int cmd,int blocks,char *buffer);
 
/*
 *      Adds a packet command request to the tail of the device request
 *      queue and waits for it to be serviced.
 */
 
int idetape_queue_pc_tail (ide_drive_t *drive,idetape_packet_command_t *pc);
 
int idetape_position_tape (ide_drive_t *drive,unsigned long block);
int idetape_rewind_tape (ide_drive_t *drive);
int idetape_flush_tape_buffers (ide_drive_t *drive);
 
/*
 *      Used to get device information
 */
 
void idetape_get_mode_sense_results (ide_drive_t *drive);
 
/*
 *      General utility functions
 */
 
unsigned long idetape_swap_long (unsigned long temp);
unsigned short idetape_swap_short (unsigned short temp);
 
#define IDETAPE_MIN(a,b)        ((a)<(b) ? (a):(b))
 
/*
 *      Pipeline related functions
 */
 
idetape_pipeline_stage_t *idetape_kmalloc_stage (ide_drive_t *drive);
void idetape_kfree_stage (idetape_pipeline_stage_t *stage);
void idetape_copy_buffer_from_stage (idetape_pipeline_stage_t *stage,char *buffer);
void idetape_copy_buffer_to_stage (idetape_pipeline_stage_t *stage,char *buffer);
void idetape_increase_max_pipeline_stages (ide_drive_t *drive);
void idetape_add_stage_tail (ide_drive_t *drive,idetape_pipeline_stage_t *stage);
void idetape_remove_stage_head (ide_drive_t *drive);
void idetape_active_next_stage (ide_drive_t *drive);
void idetape_wait_for_pipeline (ide_drive_t *drive);
void idetape_discard_read_pipeline (ide_drive_t *drive);
void idetape_empty_write_pipeline (ide_drive_t *drive);
void idetape_insert_pipeline_into_queue (ide_drive_t *drive);
 
/*
 *      For general magnetic tape device compatibility.
 */
 
#include <linux/mtio.h>
 
/*
 *      Global variables
 *
 *      The variables below are used for the character device interface.
 *
 *      Additional state variables are defined in our ide_drive_t structure.
 */
 
idetape_chrdev_t idetape_chrdev;                /* Character device interface information */
byte idetape_drive_already_found=0;              /* 1 when the above data structure is initialized */
 
/*
 *      Our character device supporting functions, passed to register_chrdev.
 */
 
static struct file_operations idetape_fops = {
        NULL,                   /* lseek - default */
        idetape_chrdev_read,    /* read  */
        idetape_chrdev_write,   /* write */
        NULL,                   /* readdir - bad */
        NULL,                   /* select */
        idetape_chrdev_ioctl,   /* ioctl */
        NULL,                   /* mmap */
        idetape_chrdev_open,    /* open */
        idetape_chrdev_release, /* release */
        NULL,                   /* fsync */
        NULL,                   /* fasync */
        NULL,                   /* check_media_change */
        NULL                    /* revalidate */
};
 
 
/*
 *      idetape_identify_device is called by do_identify in ide.c during
 *      the device probing stage to check the contents of the ATAPI IDENTIFY
 *      command results, in case the device type is tape. We return:
 *
 *      1       If the tape can be supported by us, based on the information
 *              we have so far.
 *
 *      0       If this tape driver is not currently supported by us.
 *
 *      In case we decide to support the tape, we store the current drive
 *      pointer in our character device global variables, so that we can
 *      pass between both interfaces.
 */
 
int idetape_identify_device (ide_drive_t *drive,struct hd_driveid *id)
 
{
        struct idetape_id_gcw gcw;
        unsigned short *ptr;
        int support=1;
#if IDETAPE_DEBUG_LOG
        unsigned short mask,i;
#endif /* IDETAPE_DEBUG_LOG */
 
        ptr=(unsigned short *) &gcw;
        *ptr=id->config;
 
#if IDETAPE_DEBUG_LOG
        printk ("Dumping ATAPI Identify Device tape parameters\n");
 
        printk ("Protocol Type: ");
        switch (gcw.protocol) {
                case 0: case 1: printk ("ATA\n");break;
                case 2: printk ("ATAPI\n");break;
                case 3: printk ("Reserved (Unknown to ide-tape)\n");break;
        }
 
        printk ("Device Type: %x - ",gcw.device_type);
        switch (gcw.device_type) {
                case 0: printk ("Direct-access Device\n");break;
                case 1: printk ("Streaming Tape Device\n");break;
                case 2: case 3: case 4: printk ("Reserved\n");break;
                case 5: printk ("CD-ROM Device\n");break;
                case 6: printk ("Reserved\n");
                case 7: printk ("Optical memory Device\n");break;
                case 0x1f: printk ("Unknown or no Device type\n");break;
                default: printk ("Reserved\n");
        }
        printk ("Removable: %s",gcw.removable ? "Yes\n":"No\n");
 
        printk ("Command Packet DRQ Type: ");
        switch (gcw.drq_type) {
                case 0: printk ("Microprocessor DRQ\n");break;
                case 1: printk ("Interrupt DRQ\n");break;
                case 2: printk ("Accelerated DRQ\n");break;
                case 3: printk ("Reserved\n");break;
        }
 
        printk ("Command Packet Size: ");
        switch (gcw.packet_size) {
                case 0: printk ("12 bytes\n");break;
                case 1: printk ("16 bytes\n");break;
                default: printk ("Reserved\n");break;
        }
        printk ("Model: %s\n",id->model);
        printk ("Firmware Revision: %s\n",id->fw_rev);
        printk ("Serial Number: %s\n",id->serial_no);
        printk ("Write buffer size: %d bytes\n",id->buf_size*512);
        printk ("DMA: %s",id->capability & 0x01 ? "Yes\n":"No\n");
        printk ("LBA: %s",id->capability & 0x02 ? "Yes\n":"No\n");
        printk ("IORDY can be disabled: %s",id->capability & 0x04 ? "Yes\n":"No\n");
        printk ("IORDY supported: %s",id->capability & 0x08 ? "Yes\n":"Unknown\n");
        printk ("ATAPI overlap supported: %s",id->capability & 0x20 ? "Yes\n":"No\n");
        printk ("PIO Cycle Timing Category: %d\n",id->tPIO);
        printk ("DMA Cycle Timing Category: %d\n",id->tDMA);
        printk ("Single Word DMA supported modes: ");
        for (i=0,mask=1;i<8;i++,mask=mask << 1) {
                if (id->dma_1word & mask)
                        printk ("%d ",i);
                if (id->dma_1word & (mask << 8))
                        printk ("(active) ");
        }
        printk ("\n");
 
        printk ("Multi Word DMA supported modes: ");
        for (i=0,mask=1;i<8;i++,mask=mask << 1) {
                if (id->dma_mword & mask)
                        printk ("%d ",i);
                if (id->dma_mword & (mask << 8))
                        printk ("(active) ");
        }
        printk ("\n");
 
        if (id->field_valid & 0x0002) {
                printk ("Enhanced PIO Modes: %s\n",id->eide_pio_modes & 1 ? "Mode 3":"None");
                printk ("Minimum Multi-word DMA cycle per word: ");
                if (id->eide_dma_min == 0)
                        printk ("Not supported\n");
                else
                        printk ("%d ns\n",id->eide_dma_min);
 
                printk ("Manufacturer\'s Recommended Multi-word cycle: ");
                if (id->eide_dma_time == 0)
                        printk ("Not supported\n");
                else
                        printk ("%d ns\n",id->eide_dma_time);
 
                printk ("Minimum PIO cycle without IORDY: ");
                if (id->eide_pio == 0)
                        printk ("Not supported\n");
                else
                        printk ("%d ns\n",id->eide_pio);
 
                printk ("Minimum PIO cycle with IORDY: ");
                if (id->eide_pio_iordy == 0)
                        printk ("Not supported\n");
                else
                        printk ("%d ns\n",id->eide_pio_iordy);
 
        }
 
        else {
                printk ("According to the device, fields 64-70 are not valid.\n");
        }
#endif /* IDETAPE_DEBUG_LOG */
 
        /* Check that we can support this device */
 
        if (gcw.protocol !=2 ) {
                printk ("ide-tape: Protocol is not ATAPI\n");support=0;
        }
 
        if (gcw.device_type != 1) {
                printk ("ide-tape: Device type is not set to tape\n");support=0;
        }
 
        if (!gcw.removable) {
                printk ("ide-tape: The removable flag is not set\n");support=0;
        }
 
        if (gcw.packet_size != 0) {
                printk ("ide-tape: Packet size is not 12 bytes long\n");
                if (gcw.packet_size == 1)
                        printk ("ide-tape: Sorry, padding to 16 bytes is still not supported\n");
                support=0;
        }
 
        if (idetape_drive_already_found) {
                printk ("ide-tape: Sorry, only one ide tape drive is supported by the driver\n");
                support=0;
        }
        else {
                idetape_drive_already_found=1;
                idetape_chrdev.drive=drive;
                idetape_chrdev.major=IDETAPE_MAJOR;
                idetape_chrdev.minor=0;
                idetape_chrdev.name[0]='h';
                idetape_chrdev.name[1]='t';
                idetape_chrdev.name[2]='0';
                idetape_chrdev.name[3]=0;
        }
 
        return (support);               /* In case support=0, we will not install the driver */
}
 
/*
 *      idetape_register_chrdev calls register_chrdev to register our character
 *      device interface. The connection to the ide_drive_t structure, which
 *      is used by the entire ide driver is provided by our global variable
 *      idetape_chrdev.drive, which was initialized earlier, during the device
 *      probing stage.
 */
 
void idetape_register_chrdev (void)
 
{
        int major,minor;
        ide_drive_t *drive;
 
        if (!idetape_drive_already_found)
                return;
 
        drive=idetape_chrdev.drive;
        major=idetape_chrdev.major;
        minor=idetape_chrdev.minor;
 
        if (register_chrdev (major,idetape_chrdev.name,&idetape_fops)) {
                printk ("Unable to register character device interface !\n");
                /* ??? */
        }
}
 
/*
 *      idetape_setup is called from the ide driver in the partition table
 *      identification stage, to:
 *
 *              1.      Initialize our various state variables.
 *              2.      Ask the tape for its capabilities.
 *              3.      Allocate a buffer which will be used for data
 *                      transfer. The buffer size is chosen based on
 *                      the recommendation which we received in step (2).
 *
 *      Note that at this point ide.c already assigned us an irq, so that
 *      we can queue requests here and wait for their completion.
 */
 
void idetape_setup (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        unsigned int allocation_length;
        struct idetape_id_gcw gcw;
 
#if IDETAPE_ANTICIPATE_READ_WRITE_DSC
        ide_hwif_t *hwif = HWIF(drive);
        unsigned long t1, tmid, tn;
#endif /* IDETAPE_ANTICIPATE_READ_WRITE_DSC */
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Reached idetape_setup\n");
#endif /* IDETAPE_DEBUG_LOG */  
 
        drive->ready_stat = 0;                   /* With an ATAPI device, we can issue packet commands */
                                                /* regardless of the state of DRDY */
        HWIF(drive)->tape_drive=drive;
 
        tape->block_address=0;
        tape->block_address_valid=0;
        tape->pc_stack_index=0;
        tape->failed_pc=NULL;
        tape->postponed_rq=NULL;
        tape->busy=0;
        tape->active_data_request=NULL;
        tape->current_number_of_stages=0;
        tape->first_stage=tape->next_stage=tape->last_stage=NULL;
        tape->error_in_pipeline_stage=0;
        tape->request_status=0;
        tape->chrdev_direction=idetape_direction_none;
        tape->reset_issued=0;
        tape->pc=&(tape->pc_stack [0]);
 
        *((unsigned short *) &gcw) = drive->id->config;
        tape->drq_interrupt = (gcw.drq_type == 1) ? 1 : 0;
 
#if IDETAPE_PIPELINE
        tape->max_number_of_stages=IDETAPE_MIN_PIPELINE_STAGES;
#else
        tape->max_number_of_stages=0;
#endif /* IDETAPE_PIPELINE */
 
        idetape_get_mode_sense_results (drive);
 
        tape->data_buffer_size = tape->capabilities.ctl * tape->tape_block_size;
        while (tape->data_buffer_size > 0xffff) {
                tape->capabilities.ctl /= 2;
                tape->data_buffer_size = tape->capabilities.ctl * tape->tape_block_size;
        }
        allocation_length=tape->data_buffer_size;
        if (tape->data_buffer_size % IDETAPE_ALLOCATION_BLOCK)
                allocation_length+=IDETAPE_ALLOCATION_BLOCK;
 
#if IDETAPE_MINIMIZE_IDLE_MEMORY_USAGE
        tape->data_buffer=tape->merge_buffer=NULL;
#else
        tape->data_buffer=kmalloc (allocation_length,GFP_KERNEL);
        tape->merge_buffer=kmalloc (allocation_length,GFP_KERNEL);
        if (tape->data_buffer == NULL || tape->merge_buffer == NULL) {
                printk ("ide-tape: FATAL - Can not allocate 2 buffers of %d bytes each\n",allocation_length);
                printk ("ide-tape: Aborting character device installation\n");
                idetape_drive_already_found=0;
                unregister_chrdev (idetape_chrdev.major,idetape_chrdev.name);
                return;
        }
#endif /* IDETAPE_MINIMIZE_IDLE_MEMORY_USAGE */
 
        tape->merge_buffer_size=tape->merge_buffer_offset=0;
 
#if IDETAPE_ANTICIPATE_READ_WRITE_DSC
 
        /*
         *      Cleverly select the DSC read/write polling frequency, based
         *      on the tape's speed, its recommended transfer unit, its
         *      internal buffer size and our operation mode.
         *
         *      In the pipelined operation mode we aim for "catching" the
         *      tape when its internal buffer is about 50% full. This will
         *      dramatically reduce our polling frequency and will also
         *      leave enough time for the ongoing request of the other device
         *      to complete before the buffer is completely empty. We will
         *      then completely refill the buffer with requests from our
         *      internal pipeline.
         *
         *      When operating in the non-pipelined operation mode, we
         *      can't allow ourself this luxury. Instead, we will try to take
         *      full advantage of the internal tape buffer by waiting only
         *      for one request to complete. This will increase our load
         *      on linux but will usually still fail to keep the tape
         *      constantly streaming.
         */
 
        /*
         *      We will ignore the above algorithm for now, as it can have
         *      a bad effect on interactive response under some conditions.
         *      The following attempts to find a balance between good latency
         *      and good system throughput. It will be nice to have all this
         *      configurable in run time at some point.
         */
        t1 = (tape->data_buffer_size * HZ) / (tape->capabilities.speed * 1000);
        tmid = (tape->capabilities.buffer_size * 32 * HZ) / (tape->capabilities.speed * 125);
        tn = (IDETAPE_FIFO_THRESHOLD * tape->data_buffer_size * HZ) / (tape->capabilities.speed * 1000);
 
        if (tape->max_number_of_stages) {
                if (drive->using_dma)
                        tape->best_dsc_rw_frequency = tmid;
                else {
                        if (hwif->drives[drive->select.b.unit ^ 1].present || hwif->next != hwif)
                                tape->best_dsc_rw_frequency = IDETAPE_MIN ((tn + tmid) / 2, tmid);
                        else
                                tape->best_dsc_rw_frequency = IDETAPE_MIN (tn, tmid);
                }
        } else
                tape->best_dsc_rw_frequency = t1;
 
        /*
         *      Ensure that the number we got makes sense.
         */
 
        if (tape->best_dsc_rw_frequency > IDETAPE_DSC_READ_WRITE_LOWEST_FREQUENCY) {
                printk ("ide-tape: Although the recommended polling period is %lu jiffies, \n",tape->best_dsc_rw_frequency);
                printk ("ide-tape: we will use %u jiffies\n",IDETAPE_DSC_READ_WRITE_LOWEST_FREQUENCY);
                printk ("ide-tape: (It may well be that we are wrong here)\n");
                tape->best_dsc_rw_frequency = IDETAPE_DSC_READ_WRITE_LOWEST_FREQUENCY;
        }
 
        if (tape->best_dsc_rw_frequency < IDETAPE_DSC_READ_WRITE_FALLBACK_FREQUENCY) {
                printk ("ide-tape: Although the recommended polling period is %lu jiffies, \n",tape->best_dsc_rw_frequency);
                printk ("ide-tape: we will use %u jiffies\n",IDETAPE_DSC_READ_WRITE_FALLBACK_FREQUENCY);
                tape->best_dsc_rw_frequency = IDETAPE_DSC_READ_WRITE_FALLBACK_FREQUENCY;
        }
 
#else
        tape->best_dsc_rw_frequency=IDETAPE_DSC_READ_WRITE_FALLBACK_FREQUENCY;
#endif /* IDETAPE_ANTICIPATE_READ_WRITE_DSC */
 
        printk (KERN_INFO "ide-tape: %s <-> %s, %dKBps, %d*%dkB buffer, %dkB pipeline, %lums tDSC%s\n",
                drive->name, "ht0", tape->capabilities.speed, (tape->capabilities.buffer_size * 512) / tape->data_buffer_size,
                tape->data_buffer_size / 1024, tape->max_number_of_stages * tape->data_buffer_size / 1024,
                tape->best_dsc_rw_frequency * 1000 / HZ, drive->using_dma ? ", DMA":"");
        return;
}
 
/*
 *      idetape_get_mode_sense_results asks the tape about its various
 *      parameters. In particular, we will adjust our data transfer buffer
 *      size to the recommended value as returned by the tape.
 */
 
void idetape_get_mode_sense_results (ide_drive_t *drive)
 
{
        int retval;
        idetape_tape_t *tape=&(drive->tape);
        idetape_mode_parameter_header_t *header;
        idetape_capabilities_page_t *capabilities;
        idetape_packet_command_t pc;
 
        idetape_create_mode_sense_cmd (&pc,IDETAPE_CAPABILITIES_PAGE);
        pc.buffer=pc.temp_buffer;
        pc.buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc.current_position=pc.temp_buffer;
        retval=idetape_queue_pc_tail (drive,&pc);
 
        header=(idetape_mode_parameter_header_t *) pc.buffer;
        capabilities=(idetape_capabilities_page_t *) (pc.buffer+sizeof (idetape_mode_parameter_header_t));
 
        capabilities->max_speed=idetape_swap_short (capabilities->max_speed);
        capabilities->ctl=idetape_swap_short (capabilities->ctl);
        capabilities->speed=idetape_swap_short (capabilities->speed);
        capabilities->buffer_size=idetape_swap_short (capabilities->buffer_size);
 
        if (!capabilities->speed) {
                printk("ide-tape: %s: overriding capabilities->speed (assuming 650KB/sec)\n", drive->name);
                capabilities->speed = 650;
        }
        if (!capabilities->max_speed) {
                printk("ide-tape: %s: overriding capabilities->max_speed (assuming 650KB/sec)\n", drive->name);
                capabilities->max_speed = 650;
        }
 
        tape->capabilities=*capabilities;               /* Save us a copy */
        tape->tape_block_size=capabilities->blk512 ? 512:1024;
 
        if (retval) {
                printk ("ide-tape: Can't get tape parameters\n");
                printk ("ide-tape: Assuming some default parameters\n");
                tape->tape_block_size=512;
                tape->capabilities.ctl=52;
                tape->capabilities.speed=450;
                tape->capabilities.buffer_size=6*52;
                return;
        }
 
#if IDETAPE_DEBUG_LOG
        printk ("Dumping the results of the MODE SENSE packet command\n");
        printk ("Mode Parameter Header:\n");
        printk ("Mode Data Length - %d\n",header->mode_data_length);
        printk ("Medium Type - %d\n",header->medium_type);
        printk ("Device Specific Parameter - %d\n",header->dsp);
        printk ("Block Descriptor Length - %d\n",header->bdl);
 
        printk ("Capabilities and Mechanical Status Page:\n");
        printk ("Page code - %d\n",capabilities->page_code);
        printk ("Page length - %d\n",capabilities->page_length);
        printk ("Read only - %s\n",capabilities->ro ? "Yes":"No");
        printk ("Supports reverse space - %s\n",capabilities->sprev ? "Yes":"No");
        printk ("Supports erase initiated formatting - %s\n",capabilities->efmt ? "Yes":"No");
        printk ("Supports QFA two Partition format - %s\n",capabilities->qfa ? "Yes":"No");
        printk ("Supports locking the medium - %s\n",capabilities->lock ? "Yes":"No");
        printk ("The volume is currently locked - %s\n",capabilities->locked ? "Yes":"No");
        printk ("The device defaults in the prevent state - %s\n",capabilities->prevent ? "Yes":"No");
        printk ("Supports ejecting the medium - %s\n",capabilities->eject ? "Yes":"No");
        printk ("Supports error correction - %s\n",capabilities->ecc ? "Yes":"No");
        printk ("Supports data compression - %s\n",capabilities->cmprs ? "Yes":"No");
        printk ("Supports 512 bytes block size - %s\n",capabilities->blk512 ? "Yes":"No");
        printk ("Supports 1024 bytes block size - %s\n",capabilities->blk1024 ? "Yes":"No");
        printk ("Restricted byte count for PIO transfers - %s\n",capabilities->slowb ? "Yes":"No");
        printk ("Maximum supported speed in KBps - %d\n",capabilities->max_speed);
        printk ("Continuous transfer limits in blocks - %d\n",capabilities->ctl);
        printk ("Current speed in KBps - %d\n",capabilities->speed);
        printk ("Buffer size - %d\n",capabilities->buffer_size*512);
#endif /* IDETAPE_DEBUG_LOG */
}
 
static void idetape_transfer_pc (ide_drive_t *drive)
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_packet_command_t *pc = tape->pc;
        idetape_ireason_reg_t ireason;
 
        if (ide_wait_stat (drive,DRQ_STAT,BUSY_STAT,WAIT_READY)) {
                printk (KERN_ERR "ide-tape: Strange, packet command initiated yet DRQ isn't asserted\n");
                return;
        }
        ireason.all=IN_BYTE (IDE_IREASON_REG);
        if (!ireason.b.cod || ireason.b.io) {
                printk (KERN_ERR "ide-tape: (IO,CoD) != (0,1) while issuing a packet command\n");
                ide_do_reset (drive);
                return;
        }
        ide_set_handler (drive, &idetape_pc_intr, WAIT_CMD);    /* Set the interrupt routine */
        ide_output_data (drive,pc->c,12/4);                     /* Send the actual packet */
}
 
/*
 *      Packet Command Interface
 *
 *      The current Packet Command is available in tape->pc, and will not
 *      change until we finish handling it. Each packet command is associated
 *      with a callback function that will be called when the command is
 *      finished.
 *
 *      The handling will be done in three stages:
 *
 *      1.      idetape_issue_packet_command will send the packet command to the
 *              drive, and will set the interrupt handler to idetape_pc_intr.
 *
 *      2.      On each interrupt, idetape_pc_intr will be called. This step
 *              will be repeated until the device signals us that no more
 *              interrupts will be issued.
 *
 *      3.      ATAPI Tape media access commands have immediate status with a
 *              delayed process. In case of a successful initiation of a
 *              media access packet command, the DSC bit will be set when the
 *              actual execution of the command is finished.
 *              Since the tape drive will not issue an interrupt, we have to
 *              poll for this event. In this case, we define the request as
 *              "low priority request" by setting rq_status to
 *              IDETAPE_RQ_POSTPONED,   set a timer to poll for DSC and exit
 *              the driver.
 *
 *              ide.c will then give higher priority to requests which
 *              originate from the other device, until will change rq_status
 *              to RQ_ACTIVE.
 *
 *      4.      When the packet command is finished, it will be checked for errors.
 *
 *      5.      In case an error was found, we queue a request sense packet command
 *              in front of the request queue and retry the operation up to
 *              IDETAPE_MAX_PC_RETRIES times.
 *
 *      6.      In case no error was found, or we decided to give up and not
 *              to retry again, the callback function will be called and then
 *              we will handle the next request.
 *
 */
 
void idetape_issue_packet_command  (ide_drive_t *drive,idetape_packet_command_t *pc,ide_handler_t *handler)
 
{
        idetape_tape_t *tape;
        idetape_bcount_reg_t bcount;
        int dma_ok=0;
 
        tape=&(drive->tape);
 
#if IDETAPE_DEBUG_BUGS
        if (tape->pc->c[0] == IDETAPE_REQUEST_SENSE_CMD && pc->c[0] == IDETAPE_REQUEST_SENSE_CMD) {
                printk ("ide-tape: possible ide-tape.c bug - Two request sense in serial were issued\n");
        }
#endif /* IDETAPE_DEBUG_BUGS */
 
        if (tape->failed_pc == NULL && pc->c[0] != IDETAPE_REQUEST_SENSE_CMD)
                tape->failed_pc=pc;
        tape->pc=pc;                                                    /* Set the current packet command */
 
        if (pc->retries > IDETAPE_MAX_PC_RETRIES || pc->abort) {
 
                /*
                 *      We will "abort" retrying a packet command in case
                 *      a legitimate error code was received (crossing a
                 *      filemark, or DMA error in the end of media, for
                 *      example).
                 */
 
                if (!pc->abort) {
                        printk ("ide-tape: %s: I/O error, ",drive->name);
                        printk ("pc = %x, key = %x, asc = %x, ascq = %x\n",pc->c[0],tape->sense_key,tape->asc,tape->ascq);
#if IDETAPE_DEBUG_LOG
                        printk ("ide-tape: Maximum retries reached - Giving up\n");
#endif /* IDETAPE_DEBUG_LOG */
                        pc->error=1;                                    /* Giving up */
                }
                tape->failed_pc=NULL;
#if IDETAPE_DEBUG_BUGS
                if (pc->callback==NULL)
                        printk ("ide-tape: ide-tape bug - Callback function not set !\n");
                else
#endif /* IDETAPE_DEBUG_BUGS */
                        (*pc->callback)(drive);
                return;
        }
 
#if IDETAPE_DEBUG_LOG
        printk ("Retry number - %d\n",pc->retries);
#endif /* IDETAPE_DEBUG_LOG */
 
        pc->retries++;
 
/*
 *      We no longer call ide_wait_stat to wait for the drive to be ready,
 *      as ide.c already does this for us in do_request.
 */
 
        pc->actually_transferred=0;                                      /* We haven't transferred any data yet */
        pc->current_position=pc->buffer;
        bcount.all=pc->request_transfer;                                /* Request to transfer the entire buffer at once */
 
#ifdef CONFIG_BLK_DEV_TRITON
        if (pc->dma_error) {
                printk ("ide-tape: DMA disabled, reverting to PIO\n");
                drive->using_dma=0;
                pc->dma_error=0;
        }
        if (pc->request_transfer && pc->dma_recommended && drive->using_dma) {
                dma_ok=!(HWIF(drive)->dmaproc(pc->writing ? ide_dma_write : ide_dma_read, drive));
        }
#endif /* CONFIG_BLK_DEV_TRITON */
 
        OUT_BYTE (drive->ctl,IDETAPE_CONTROL_REG);
        OUT_BYTE (dma_ok ? 1:0,IDETAPE_FEATURES_REG);                    /* Use PIO/DMA */
        OUT_BYTE (bcount.b.high,IDETAPE_BCOUNTH_REG);
        OUT_BYTE (bcount.b.low,IDETAPE_BCOUNTL_REG);
        OUT_BYTE (drive->select.all,IDETAPE_DRIVESEL_REG);
 
#ifdef CONFIG_BLK_DEV_TRITON
        if ((pc->dma_in_progress=dma_ok)) {                     /* Begin DMA, if necessary */
                pc->dma_error=0;
                (void) (HWIF(drive)->dmaproc(ide_dma_begin, drive));
        }
#endif /* CONFIG_BLK_DEV_TRITON */
 
        if (tape->drq_interrupt) {
                ide_set_handler (drive, &idetape_transfer_pc, WAIT_CMD);
                OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG);              /* Issue the packet command */
        } else {
                OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG);
                idetape_transfer_pc (drive);
        }
}
 
/*
 *      idetape_pc_intr is the usual interrupt handler which will be called
 *      during a packet command. We will transfer some of the data (as
 *      requested by the drive) and will re-point interrupt handler to us.
 *      When data transfer is finished, we will act according to the
 *      algorithm described before idetape_issue_packet_command.
 *
 */
 
 
void idetape_pc_intr (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_status_reg_t status;
        idetape_bcount_reg_t bcount;
        idetape_ireason_reg_t ireason;
        idetape_packet_command_t *pc=tape->pc;
        unsigned long temp;
 
#ifdef CONFIG_BLK_DEV_TRITON
        if (pc->dma_in_progress) {
                if ((pc->dma_error=HWIF(drive)->dmaproc(ide_dma_status_bad, drive)))
                        /*
                         *      We will currently correct the following in
                         *      idetape_analyze_error.
                         */
                        pc->actually_transferred=HWIF(drive)->dmaproc(ide_dma_transferred, drive);
                else
                        pc->actually_transferred=pc->request_transfer;
                (void) (HWIF(drive)->dmaproc(ide_dma_abort, drive));    /* End DMA */
#if IDETAPE_DEBUG_LOG
                printk ("ide-tape: DMA finished\n");
#endif /* IDETAPE_DEBUG_LOG */
        }
#endif /* CONFIG_BLK_DEV_TRITON */
 
        status.all=IN_BYTE (IDETAPE_STATUS_REG);                /* Clear the interrupt */
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Reached idetape_pc_intr interrupt handler\n");
#endif /* IDETAPE_DEBUG_LOG */  
 
        if (!status.b.drq) {                                    /* No more interrupts */
#if IDETAPE_DEBUG_LOG
                printk ("Packet command completed\n");
                printk ("Total bytes transferred: %lu\n",pc->actually_transferred);
#endif /* IDETAPE_DEBUG_LOG */
                pc->dma_in_progress=0;
 
                sti ();
 
                if (status.b.check || pc->dma_error) {                  /* Error detected */
#if IDETAPE_DEBUG_LOG
        /*
         *      Without debugging, we only log an error if we decided to
         *      give up retrying.
         */
                        printk ("ide-tape: %s: I/O error, ",drive->name);
#endif /* IDETAPE_DEBUG_LOG */
                        if (pc->c[0] == IDETAPE_REQUEST_SENSE_CMD) {
                                printk ("ide-tape: I/O error in request sense command\n");
                                ide_do_reset (drive);
                                return;
                        }
 
                        idetape_retry_pc (drive);                       /* Retry operation */
                        return;
                }
                pc->error=0;
                if (pc->wait_for_dsc && !status.b.dsc) {                                /* Media access command */
                        tape->dsc_polling_frequency=IDETAPE_DSC_FAST_MEDIA_ACCESS_FREQUENCY;
                        idetape_postpone_request (drive);               /* Allow ide.c to handle other requests */
                        return;
                }
                if (tape->failed_pc == pc)
                        tape->failed_pc=NULL;
#if IDETAPE_DEBUG_BUGS
                if (pc->callback==NULL)
                        printk ("ide-tape: ide-tape bug - Callback function not set !\n");
                else
#endif /* IDETAPE_DEBUG_BUGS */
                        (*pc->callback)(drive);                 /* Command finished - Call the callback function */
                return;
        }
#ifdef CONFIG_BLK_DEV_TRITON
        if (pc->dma_in_progress) {
                pc->dma_in_progress=0;
                printk ("ide-tape: The tape wants to issue more interrupts in DMA mode\n");
                printk ("ide-tape: DMA disabled, reverting to PIO\n");
                drive->using_dma=0;
                ide_do_reset (drive);
                return;
        }
#endif /* CONFIG_BLK_DEV_TRITON */
        bcount.b.high=IN_BYTE (IDETAPE_BCOUNTH_REG);                    /* Get the number of bytes to transfer */
        bcount.b.low=IN_BYTE (IDETAPE_BCOUNTL_REG);                     /* on this interrupt */
        ireason.all=IN_BYTE (IDETAPE_IREASON_REG);                      /* Read the interrupt reason register */
 
        if (ireason.b.cod) {
                printk ("ide-tape: CoD != 0 in idetape_pc_intr\n");
                ide_do_reset (drive);
                return;
        }
        if (ireason.b.io != !(pc->writing)) {                   /* Hopefully, we will never get here */
                printk ("ide-tape: We wanted to %s, ",pc->writing ? "Write":"Read");
                printk ("but the tape wants us to %s !\n",ireason.b.io ? "Read":"Write");
                ide_do_reset (drive);
                return;
        }
 
        if (!pc->writing) {                                     /* Reading - Check that we have enough space */
                temp=(unsigned long) pc->actually_transferred + bcount.all;
                if ( temp > pc->request_transfer) {
                        if (temp > pc->buffer_size) {
                                printk ("ide-tape: The tape wants to send us more data than requested - discarding data\n");
                                idetape_discard_data (drive,bcount.all);
                                ide_set_handler (drive,&idetape_pc_intr,WAIT_CMD);
                                return;
                        }
#if IDETAPE_DEBUG_LOG
                        printk ("ide-tape: The tape wants to send us more data than requested - allowing transfer\n");
#endif /* IDETAPE_DEBUG_LOG */
                }
        }
#if IDETAPE_DEBUG_BUGS  
        if (bcount.all && !pc->buffer) {
                printk ("ide-tape: ide-tape.c bug - Buffer not set in idetape_pc_intr. Discarding data.\n");
 
                if (!pc->writing) {
                        printk ("ide-tape: Discarding data\n");
                        idetape_discard_data (drive,bcount.all);
                        ide_set_handler (drive,&idetape_pc_intr,WAIT_CMD);
                        return;
                }
                else {  /* ??? */
                }
        }
#endif /* IDETAPE_DEBUG_BUGS */
        if (pc->writing)
                idetape_output_data (drive,pc->current_position,bcount.all);    /* Write the current buffer */
        else
                idetape_input_data (drive,pc->current_position,bcount.all);     /* Read the current buffer */
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: %s %d bytes\n",pc->writing ? "Wrote":"Received",bcount.all);
#endif /* IDETAPE_DEBUG_LOG */
        pc->actually_transferred+=bcount.all;                                   /* Update the current position */
        pc->current_position+=bcount.all;
 
        ide_set_handler (drive,&idetape_pc_intr,WAIT_CMD);              /* And set the interrupt handler again */
}
 
/*
 *      idetape_postpone_request postpones the current request so that
 *      ide.c will be able to service requests from another device on
 *      the same hwgroup while we are polling for DSC.
 */
 
void idetape_postpone_request (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        struct request *rq;
        idetape_status_reg_t status;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_postpone_request\n");
#endif /* IDETAPE_DEBUG_LOG */
#if IDETAPE_DEBUG_BUGS
        if (tape->postponed_rq != NULL)
                printk ("ide-tape.c bug - postponed_rq not NULL in idetape_postpone_request\n");
#endif /* IDETAPE_DEBUG_BUGS */
 
        tape->dsc_timer.expires=jiffies + tape->dsc_polling_frequency;  /* Set timer to poll for */
        tape->dsc_timeout=jiffies+IDETAPE_DSC_TIMEOUT;                  /* actual completion */
        tape->dsc_timer.data=(unsigned long) drive;
        tape->dsc_timer.function=&idetape_poll_for_dsc;
        init_timer (&(tape->dsc_timer));
 
        /*
         * Remove current request from the request queue:
         */
 
        tape->postponed_rq = rq = HWGROUP(drive)->rq;
        rq->rq_status = IDETAPE_RQ_POSTPONED;
        blk_dev[MAJOR(rq->rq_dev)].current_request = rq->next;
        HWGROUP(drive)->rq = NULL;
 
        /*
         *      Check the status again - Maybe we can save one polling period.
         */
 
        status.all=IN_BYTE (IDETAPE_STATUS_REG);
        tape->last_status=status.all;
        tape->request_status=1;
 
        tape->dsc_polling_start=jiffies;
        add_timer(&(tape->dsc_timer));          /* Activate the polling timer */
}
 
/*
 *      idetape_poll_for_dsc_direct is called from idetape_poll_for_dsc
 *      to handle the case in which we can safely communicate with the tape
 *      (since no other request for this hwgroup is active).
 */
 
void idetape_poll_for_dsc_direct (unsigned long data)
 
{
        ide_drive_t *drive=(ide_drive_t *) data;
        idetape_tape_t *tape=&(drive->tape);
        idetape_status_reg_t status;
 
#if IDETAPE_DEBUG_LOG
        printk ("%s: idetape_poll_for_dsc_direct called\n",drive->name);
#endif /* IDETAPE_DEBUG_LOG */  
 
        OUT_BYTE(drive->select.all,IDE_SELECT_REG);
        status.all=IN_BYTE (IDETAPE_STATUS_REG);
 
        if (status.b.dsc) {                                     /* DSC received */
                tape->dsc_received=1;
                del_timer (&(tape->dsc_timer));                 /* Stop polling and put back the postponed */
                idetape_put_back_postponed_request (drive);     /* request in the request queue */
                return;
        }
 
        if (jiffies > tape->dsc_timeout)        { /* Timeout */
                tape->dsc_received=0;
                del_timer (&(tape->dsc_timer));
                /* ??? */
                idetape_put_back_postponed_request (drive);
                return;
        }
 
        /* Poll again */
 
        if (jiffies - tape->dsc_polling_start > IDETAPE_FAST_SLOW_THRESHOLD)
                tape->dsc_timer.expires = jiffies + IDETAPE_DSC_SLOW_MEDIA_ACCESS_FREQUENCY;
        else
                tape->dsc_timer.expires = jiffies + tape->dsc_polling_frequency;
        add_timer(&(tape->dsc_timer));
        return;
}
 
/*
 *      idetape_poll_for_dsc gets invoked by a timer (which was set
 *      by idetape_postpone_request) to poll for the DSC bit
 *      in the status register.
 *
 *      We take care not to perform any tape access if the driver is
 *      accessing the other device. We will instead ask ide.c to sample
 *      the tape status register on our behalf in the next call to do_request,
 *      at the point in which the other device is idle, or assume that
 *      DSC was received even though we won't verify it (but when we assume
 *      that, it will usually have a solid basis).
 *
 *      The use of cli () below is a must, as we inspect and change
 *      the device request list while another request is active.
 */
 
void idetape_poll_for_dsc (unsigned long data)
 
{
        ide_drive_t *drive=(ide_drive_t *) data;
        unsigned int major = HWIF(drive)->major;
        idetape_tape_t *tape=&(drive->tape);
        struct blk_dev_struct *bdev = &blk_dev[major];
        struct request *next_rq;
        unsigned long flags;
        idetape_status_reg_t status;
 
#if IDETAPE_DEBUG_LOG
        printk ("%s: idetape_poll_for_dsc called\n",drive->name);
#endif /* IDETAPE_DEBUG_LOG */  
 
        save_flags (flags);cli ();
 
        /*
         *      Check if the other device is idle. If there are no requests,
         *      we can safely access the tape.
         */
 
        if (HWGROUP (drive)->rq == NULL) {
                sti ();
                idetape_poll_for_dsc_direct (data);
                return;
        }
 
        /*
         *      If DSC was received, re-insert our postponed request into
         *      the request queue (using ide_next).
         */
 
        status.all=tape->last_status;
 
        if (status.b.dsc) {                                     /* DSC received */
                tape->dsc_received=1;
                idetape_put_back_postponed_request (drive);
                del_timer (&(tape->dsc_timer));
                restore_flags (flags);
                return;
        }
 
        /*
         *      At this point, DSC may have been received, but we can't
         *      check it. We now have two options:
         *
         *              1.      The "simple" method - We can continue polling
         *                      until we know the value of DSC.
         *
         *      but we also have a more clever option :-)
         *
         *              2.      We can sometimes more or less anticipate in
         *                      advance how much time it will take for
         *                      the tape to perform the request. This is the
         *                      place to take advantage of this !
         *
         *                      We can assume that DSC was received, put
         *                      back our request, and hope that we will have
         *                      a "cache hit". This will only work when
         *                      we haven't initiated the packet command yet,
         *                      but this is the common read/write case. As
         *                      for the slower media access commands, fallback
         *                      to method 1 above.
         *
         *      When using method 2, we can also take advantage of the
         *      knowledge of the tape's internal buffer size - We can
         *      precalculate the time it will take for the tape to complete
         *      servicing not only one request, but rather, say, 50% of its
         *      internal buffer. The polling period will then be much larger,
         *      decreasing our load on Linux, and we will also call
         *      idetape_postpone_request less often, as there will usually
         *      be more room in the internal tape buffer while we are in
         *      idetape_do_request.
         *
         *      For this method to work well, the ongoing request of the
         *      other device should be serviced by the time the tape is
         *      still working on its remaining 50% internal buffer. This
         *      will usually happen when the other device is much faster
         *      than the tape.
         */
 
#if IDETAPE_ANTICIPATE_READ_WRITE_DSC
 
        /*
         *      Method 2.
         *
         *      There is a high chance that DSC was received, even though
         *      we couldn't verify it. Let's hope that it's a "cache hit"
         *      rather than a "cache miss". Someday I will probably add a
         *      feedback loop around the number of "cache hits" which will
         *      fine-tune the polling period.
         */
 
        if (tape->postponed_rq->cmd != IDETAPE_PACKET_COMMAND_REQUEST_TYPE1) {
 
                /*
                 *      We can use this method only when the packet command
                 *      was still not initiated.
                 */
 
                idetape_put_back_postponed_request (drive);
                del_timer (&(tape->dsc_timer));
                restore_flags (flags);
                return;
        }
#endif /* IDETAPE_ANTICIPATE_READ_WRITE_DSC */
 
        /*
         *      Fallback to method 1.
         */
 
        next_rq=bdev->current_request;
        if (next_rq == HWGROUP (drive)->rq)
                next_rq=next_rq->next;
 
        if (next_rq == NULL) {
 
                /*
                 *      There will not be another request after the currently
                 *      ongoing request, so ide.c won't be able to sample
                 *      the status register on our behalf in do_request.
                 *
                 *      In case we are waiting for DSC before the packet
                 *      command was initiated, we will put back our postponed
                 *      request and have another look at the status register
                 *      in idetape_do_request, as done in method 2 above.
                 *
                 *      In case we already initiated the command, we can't
                 *      put it back, but it is anyway a slow media access
                 *      command. We will just give up and poll again until
                 *      we are lucky.
                 */
 
                if (tape->postponed_rq->cmd == IDETAPE_PACKET_COMMAND_REQUEST_TYPE1) {
 
                        /*
                         *      Media access command - Poll again.
                         *
                         *      We set tape->request_status to 1, just in case
                         *      other requests are added while we are waiting.
                         */
 
                        tape->request_status=1;
                        restore_flags (flags);
                        tape->dsc_timer.expires = jiffies + tape->dsc_polling_frequency;
                        add_timer(&(tape->dsc_timer));
                        return;
                }
 
                /*
                 *      The packet command hasn't been sent to the tape yet -
                 *      We can safely put back the request and have another
                 *      look at the status register in idetape_do_request.
                 */
 
                idetape_put_back_postponed_request (drive);
                del_timer (&(tape->dsc_timer));
                restore_flags (flags);
                return;
        }
 
        /*
         *      There will be another request after the current request.
         *
         *      Request ide.c to sample for us the tape's status register
         *      before the next request.
         */
 
        tape->request_status=1;
        restore_flags (flags);
 
        if (jiffies > tape->dsc_timeout)        {               /* Timeout */
                tape->dsc_received=0;
                /* ??? */
                idetape_put_back_postponed_request (drive);
                del_timer (&(tape->dsc_timer));
                restore_flags (flags);
                return;
        }
 
        /* Poll again */
 
        if (jiffies - tape->dsc_polling_start > IDETAPE_FAST_SLOW_THRESHOLD)
                tape->dsc_timer.expires = jiffies + IDETAPE_DSC_SLOW_MEDIA_ACCESS_FREQUENCY;
        else
                tape->dsc_timer.expires = jiffies + tape->dsc_polling_frequency;
        add_timer(&(tape->dsc_timer));
        return;
}
 
/*
 *      idetape_put_back_postponed_request gets called when we decided to
 *      stop polling for DSC and continue servicing our postponed request.
 */
 
void idetape_put_back_postponed_request (ide_drive_t *drive)
 
{
        idetape_tape_t *tape = &(drive->tape);
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Putting back postponed request\n");
#endif /* IDETAPE_DEBUG_LOG */
#if IDETAPE_DEBUG_BUGS
        if (tape->postponed_rq == NULL) {
                printk ("tape->postponed_rq is NULL in put_back_postponed_request\n");
                return;
        }
#endif /* IDETAPE_DEBUG_BUGS */
        (void) ide_do_drive_cmd (drive, tape->postponed_rq, ide_next);
 
        /*
         *      Note that the procedure done here is different than the method
         *      we are using in idetape_queue_pc_head - There we are putting
         *      request(s) before our currently called request.
         *
         *      Here, on the other hand, HWGROUP(drive)->rq is not our
         *      request but rather a request to another device. Therefore,
         *      we will let it finish and only then service our postponed
         *      request --> We don't touch HWGROUP(drive)->rq.
         */
}
 
void idetape_media_access_finished (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_status_reg_t status;
        idetape_packet_command_t *pc;
 
        pc=tape->pc;
 
        status.all=IN_BYTE (IDETAPE_STATUS_REG);
 
        if (tape->dsc_received) {
#if IDETAPE_DEBUG_LOG
                printk ("DSC received\n");
#endif /* IDETAPE_DEBUG_LOG */
                if (status.b.check) {                                   /* Error detected */
                        printk ("ide-tape: %s: I/O error, ",drive->name);
                        idetape_retry_pc (drive);                       /* Retry operation */
                        return;
                }
                pc->error=0;
                if (tape->failed_pc == pc)
                        tape->failed_pc=NULL;
#if IDETAPE_DEBUG_BUGS
                if (pc->callback==NULL)
                        printk ("ide-tape: ide-tape bug - Callback function not set !\n");
                else
#endif /* IDETAPE_DEBUG_BUGS */
                        (*pc->callback)(drive);
 
                return;
        }
        else {
                printk ("ide-tape: %s: DSC timeout.\n",drive->name);
                /* ??? */
                pc->error=1;
                tape->failed_pc=NULL;
#if IDETAPE_DEBUG_BUGS
                if (pc->callback==NULL)
                        printk ("ide-tape: ide-tape bug - Callback function not set !\n");
                else
#endif /* IDETAPE_DEBUG_BUGS */
                        (*pc->callback)(drive);
                return;
        }
}
 
 
/*
 *      idetape_retry_pc is called when an error was detected during the
 *      last packet command. We queue a request sense packet command in
 *      the head of the request list.
 */
 
void idetape_retry_pc (ide_drive_t *drive)
 
{
        idetape_tape_t *tape = &drive->tape;
        idetape_packet_command_t *pc;
        struct request *new_rq;
 
        idetape_error_reg_t error;
        error.all=IN_BYTE (IDETAPE_ERROR_REG);
        pc=idetape_next_pc_storage (drive);
        new_rq=idetape_next_rq_storage (drive);
        idetape_create_request_sense_cmd (pc);
        pc->buffer=pc->temp_buffer;
        pc->buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc->current_position=pc->temp_buffer;
        tape->reset_issued = 1;
        idetape_queue_pc_head (drive,pc,new_rq);
}
 
/*
 *      General packet command callback function.
 */
 
void idetape_pc_callback (ide_drive_t *drive)
 
{
        idetape_tape_t *tape;
        struct request *rq;
 
        tape=&(drive->tape);
        rq=HWGROUP(drive)->rq;
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Reached idetape_pc_callback\n");
#endif /* IDETAPE_DEBUG_LOG */
        if (!tape->pc->error) {
#if IDETAPE_DEBUG_LOG
                printk ("Request completed\n");
#endif /* IDETAPE_DEBUG_LOG */
                idetape_end_request (1,HWGROUP (drive));
        }
        else {
                idetape_end_request (0,HWGROUP (drive));
        }
        return;
}
 
 
void idetape_read_callback (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        struct request *rq=HWGROUP(drive)->rq;
        int blocks_read=tape->pc->actually_transferred/tape->tape_block_size;
 
#if IDETAPE_DEBUG_LOG   
        printk ("ide-tape: Reached idetape_read_callback\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        tape->block_address+=blocks_read;
        rq->current_nr_sectors-=blocks_read;
 
        if (!tape->pc->error)
                idetape_end_request (1,HWGROUP (drive));
        else {
                rq->errors=tape->pc->error;
                switch (rq->errors) {
                        case IDETAPE_RQ_ERROR_FILEMARK:
                        case IDETAPE_RQ_ERROR_EOD:
                                break;
                }
                idetape_end_request (0,HWGROUP (drive));
        }
        return;
}
 
void idetape_write_callback (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        struct request *rq=HWGROUP(drive)->rq;
        int blocks_written=tape->pc->actually_transferred/tape->tape_block_size;
 
#if IDETAPE_DEBUG_LOG   
        printk ("ide-tape: Reached idetape_write_callback\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        tape->block_address+=blocks_written;
        rq->current_nr_sectors-=blocks_written;
 
        if (!tape->pc->error)
                idetape_end_request (1,HWGROUP (drive));
        else {
                rq->errors=tape->pc->error;
                idetape_end_request (0,HWGROUP (drive));
        }
        return;
}
 
void idetape_inquiry_callback (ide_drive_t *drive)
 
{
        idetape_tape_t *tape;
 
        tape=&(drive->tape);
 
        idetape_display_inquiry_result (tape->pc->buffer);
        idetape_pc_callback (drive);
        return;
}
 
/*
 *      idetape_input_data is called to read data from the tape's data
 *      register. We basically let ide_input_data do the job, but we also
 *      take care about the remaining bytes which can not be transferred
 *      in 32-bit data transfers.
 */
 
void idetape_input_data (ide_drive_t *drive,void *buffer, unsigned long bcount)
 
{
        unsigned long wcount;
 
        wcount=bcount >> 2;
        bcount -= 4*wcount;
 
        if (wcount)
                ide_input_data (drive,buffer,wcount);
 
        if (bcount) {
                ((byte *)buffer) += 4*wcount;
                insb (IDETAPE_DATA_REG,buffer,bcount);
        }
}
 
/*
 *      idetape_output_data is used to write data to the tape.
 */
 
void idetape_output_data (ide_drive_t *drive,void *buffer, unsigned long bcount)
 
{
        unsigned long wcount;
 
        wcount=bcount >> 2;
        bcount -= 4*wcount;
 
        if (wcount)
                ide_output_data (drive,buffer,wcount);
 
        if (bcount) {
                ((byte *)buffer) += 4*wcount;
                outsb (IDETAPE_DATA_REG,buffer,bcount);
        }
}
 
/*
 *      Too bad. The drive wants to send us data which we are not ready to accept.
 *      Just throw it away.
 */
 
void idetape_discard_data (ide_drive_t *drive, unsigned long bcount)
 
{
        unsigned long i;
 
        for (i=0;i<bcount;i++)
                IN_BYTE (IDETAPE_DATA_REG);
}
 
/*
 *      Issue an INQUIRY packet command.
 */
 
void idetape_create_inquiry_cmd (idetape_packet_command_t *pc)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating INQUIRY packet command\n");
#endif /* IDETAPE_DEBUG_LOG */  
        pc->request_transfer=36;
        pc->callback=&idetape_inquiry_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c[0]=IDETAPE_INQUIRY_CMD;
        pc->c[4]=255;
}
 
/*
 *      Format the INQUIRY command results.
 */
 
void idetape_display_inquiry_result (byte *buffer)
 
{
        idetape_inquiry_result_t *result;
 
        result=(idetape_inquiry_result_t *) buffer;
        ide_fixstring (result->vendor_id,8,0);
        ide_fixstring (result->product_id,16,0);
        ide_fixstring (result->revision_level,4,0);
 
        if (result->response_format != 2) {
                printk ("The INQUIRY Data Format is unknown to us !\n");
                printk ("Assuming QIC-157C format.\n");
        }
 
#if IDETAPE_DEBUG_LOG
        printk ("Dumping INQUIRY command results:\n");
        printk ("Response Data Format: %d - ",result->response_format);
        switch (result->response_format) {
                case 2:
                        printk ("As specified in QIC-157 Revision C\n");
                        break;
                default:
                        printk ("Unknown\n");
                        break;
        }
 
        printk ("Device Type: %x - ",result->device_type);
        switch (result->device_type) {
                case 0: printk ("Direct-access Device\n");break;
                case 1: printk ("Streaming Tape Device\n");break;
                case 2: case 3: case 4: printk ("Reserved\n");break;
                case 5: printk ("CD-ROM Device\n");break;
                case 6: printk ("Reserved\n");
                case 7: printk ("Optical memory Device\n");break;
                case 0x1f: printk ("Unknown or no Device type\n");break;
                default: printk ("Reserved\n");
        }
 
        printk ("Removable Medium: %s",result->rmb ? "Yes\n":"No\n");
 
        printk ("ANSI Version: %d - ",result->ansi_version);
        switch (result->ansi_version) {
                case 2:
                        printk ("QIC-157 Revision C\n");
                        break;
                default:
                        printk ("Unknown\n");
                        break;
        }
 
        printk ("ECMA Version: ");
        if (result->ecma_version)
                printk ("%d\n",result->ecma_version);
        else
                printk ("Not supported\n");
 
        printk ("ISO Version: ");
        if (result->iso_version)
                printk ("%d\n",result->iso_version);
        else
                printk ("Not supported\n");
 
        printk ("Additional Length: %d\n",result->additional_length);
        printk ("Vendor Identification: %s\n",result->vendor_id);
        printk ("Product Identification: %s\n",result->product_id);
        printk ("Product Revision Level: %s\n",result->revision_level);
#endif /* IDETAPE_DEBUG_LOG */
 
        if (result->device_type != 1)
                printk ("Device type is not set to tape\n");
 
        if (!result->rmb)
                printk ("The removable flag is not set\n");
 
        if (result->ansi_version != 2) {
                printk ("The Ansi Version is unknown to us !\n");
                printk ("Assuming compliance with QIC-157C specification.\n");
        }
}
 
void idetape_create_request_sense_cmd (idetape_packet_command_t *pc)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating REQUEST SENSE packet command\n");
#endif /* IDETAPE_DEBUG_LOG */  
        pc->request_transfer=18;
        pc->callback=&idetape_request_sense_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c[0]=IDETAPE_REQUEST_SENSE_CMD;
        pc->c[4]=255;
}
 
void idetape_request_sense_callback (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Reached idetape_request_sense_callback\n");
#endif /* IDETAPE_DEBUG_LOG */
        if (!tape->pc->error) {
#if IDETAPE_DEBUG_LOG
                printk ("Request completed\n");
#endif /* IDETAPE_DEBUG_LOG */
                idetape_analyze_error (drive,(idetape_request_sense_result_t *) tape->pc->buffer);
                idetape_end_request (1,HWGROUP (drive));
        }
        else {
                printk ("Error in REQUEST SENSE itself - Aborting request!\n");
                idetape_end_request (0,HWGROUP (drive));
        }
        return;
}
 
/*
 *      idetape_analyze_error is called on each failed packet command retry
 *      to analyze the request sense. We currently do not utilize this
 *      information.
 */
 
void idetape_analyze_error (ide_drive_t *drive,idetape_request_sense_result_t *result)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_packet_command_t *pc=tape->failed_pc;
 
        tape->sense_key=result->sense_key;
        tape->asc=result->asc;
        tape->ascq=result->ascq;
 
#if IDETAPE_DEBUG_LOG   
        /*
         *      Without debugging, we only log an error if we decided to
         *      give up retrying.
         */
        printk ("ide-tape: pc = %x, sense key = %x, asc = %x, ascq = %x\n",pc->c[0],result->sense_key,result->asc,result->ascq);
#endif /* IDETAPE_DEBUG_LOG */
 
        if (pc->c[0] == IDETAPE_READ_CMD) {
                if (result->filemark) {
                        pc->error=IDETAPE_RQ_ERROR_FILEMARK;
                        pc->abort=1;
                }
        }
        if (pc->c[0] == IDETAPE_WRITE_CMD) {
                if (result->eom || (result->sense_key == 0xd && result->asc == 0x0 && result->ascq == 0x2)) {
                        pc->error = IDETAPE_RQ_ERROR_EOD;
                        pc->abort = 1;
                }
        }
        if (pc->c[0] == IDETAPE_READ_CMD || pc->c[0] == IDETAPE_WRITE_CMD) {
                if (result->sense_key == 8) {
                        pc->error=IDETAPE_RQ_ERROR_EOD;
                        pc->abort=1;
                }
        }
 
#if 1
#ifdef CONFIG_BLK_DEV_TRITON
 
        /*
         *      Correct pc->actually_transferred by asking the tape.
         */
 
        if (pc->dma_error && pc->abort) {
                unsigned long *long_ptr=(unsigned long *) &(result->information1);
                pc->actually_transferred=pc->request_transfer-tape->tape_block_size*idetape_swap_long (*long_ptr);
        }
#endif /* CONFIG_BLK_DEV_TRITON */
#endif
}
 
void idetape_create_test_unit_ready_cmd (idetape_packet_command_t *pc)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating TEST UNIT READY packet command\n");
#endif /* IDETAPE_DEBUG_LOG */  
        pc->request_transfer=0;
        pc->buffer=NULL;
        pc->current_position=NULL;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c[0]=IDETAPE_TEST_UNIT_READY_CMD;
}
 
void idetape_create_locate_cmd (idetape_packet_command_t *pc,unsigned long block,byte partition)
 
{
        unsigned long *ptr;
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating LOCATE packet command\n");
#endif /* IDETAPE_DEBUG_LOG */
        pc->request_transfer=0;
        pc->buffer=NULL;
        pc->current_position=NULL;
        pc->buffer_size=0;
        pc->wait_for_dsc=1;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_LOCATE_CMD;
        pc->c [1]=2;
        ptr=(unsigned long *) &(pc->c[3]);
        *ptr=idetape_swap_long (block);
        pc->c[8]=partition;
}
 
void idetape_create_rewind_cmd (idetape_packet_command_t *pc)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating REWIND packet command\n");
#endif /* IDETAPE_DEBUG_LOG */
        pc->request_transfer=0;
        pc->buffer=NULL;
        pc->current_position=NULL;
        pc->buffer_size=0;
        pc->wait_for_dsc=1;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_REWIND_CMD;
}
 
/*
 *      A mode sense command is used to "sense" tape parameters.
 */
 
void idetape_create_mode_sense_cmd (idetape_packet_command_t *pc,byte page_code)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating MODE SENSE packet command - Page %d\n",page_code);
#endif /* IDETAPE_DEBUG_LOG */
 
        pc->wait_for_dsc=0;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        switch (page_code) {
                case IDETAPE_CAPABILITIES_PAGE:
                        pc->request_transfer=24;
        }
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_MODE_SENSE_CMD;
        pc->c [1]=8;                            /* DBD = 1 - Don't return block descriptors for now */
        pc->c [2]=page_code;
        pc->c [3]=255;                          /* Don't limit the returned information */
        pc->c [4]=255;                          /* (We will just discard data in that case) */
}
 
/*
 *      idetape_create_write_filemark_cmd will:
 *
 *              1.      Write a filemark if write_filemark=1.
 *              2.      Flush the device buffers without writing a filemark
 *                      if write_filemark=0.
 *
 */
 
void idetape_create_write_filemark_cmd (idetape_packet_command_t *pc,int write_filemark)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("Creating WRITE FILEMARK packet command\n");
        if (!write_filemark)
                printk ("which will only flush buffered data\n");
#endif /* IDETAPE_DEBUG_LOG */
        pc->request_transfer=0;
        pc->buffer=NULL;
        pc->current_position=NULL;
        pc->buffer_size=0;
        pc->wait_for_dsc=1;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_WRITE_FILEMARK_CMD;
        if (write_filemark)
                pc->c [4]=1;
}
 
void idetape_create_load_unload_cmd (idetape_packet_command_t *pc,int cmd)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("Creating LOAD UNLOAD packet command, cmd=%d\n",cmd);
#endif /* IDETAPE_DEBUG_LOG */
        pc->request_transfer=0;
        pc->buffer=NULL;
        pc->current_position=NULL;
        pc->buffer_size=0;
        pc->wait_for_dsc=1;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_LOAD_UNLOAD_CMD;
        pc->c [4]=cmd;
}
 
void idetape_create_erase_cmd (idetape_packet_command_t *pc)
 
{
 
#if IDETAPE_DEBUG_LOG
        printk ("Creating ERASE command\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        pc->request_transfer=0;
        pc->buffer=NULL;
        pc->current_position=NULL;
        pc->buffer_size=0;
        pc->wait_for_dsc=1;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_ERASE_CMD;
        pc->c [1]=1;
}
 
void idetape_create_read_cmd (idetape_packet_command_t *pc,unsigned long length)
 
{
        union convert {
                unsigned all    :32;
                struct {
                        unsigned b1     :8;
                        unsigned b2     :8;
                        unsigned b3     :8;
                        unsigned b4     :8;
                } b;
        } original;
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating READ packet command\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        original.all=length;
 
        pc->wait_for_dsc=0;
        pc->callback=&idetape_read_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
 
        pc->c [0]=IDETAPE_READ_CMD;
        pc->c [1]=1;
        pc->c [4]=original.b.b1;
        pc->c [3]=original.b.b2;
        pc->c [2]=original.b.b3;
 
        if (length)
                pc->dma_recommended=1;
 
        return;
}
 
void idetape_create_space_cmd (idetape_packet_command_t *pc,long count,byte cmd)
 
{
        union convert {
                unsigned all    :32;
                struct {
                        unsigned b1     :8;
                        unsigned b2     :8;
                        unsigned b3     :8;
                        unsigned b4     :8;
                } b;
        } original;
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating SPACE packet command\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        original.all=count;
 
        pc->request_transfer=0;
        pc->buffer=NULL;
        pc->current_position=NULL;
        pc->buffer_size=0;
        pc->wait_for_dsc=1;
        pc->callback=&idetape_pc_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_SPACE_CMD;
        pc->c [1]=cmd;
        pc->c [4]=original.b.b1;
        pc->c [3]=original.b.b2;
        pc->c [2]=original.b.b3;
 
        return;
}
 
void idetape_create_write_cmd (idetape_packet_command_t *pc,unsigned long length)
 
{
        union convert {
                unsigned all    :32;
                struct {
                        unsigned b1     :8;
                        unsigned b2     :8;
                        unsigned b3     :8;
                        unsigned b4     :8;
                } b;
        } original;
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating WRITE packet command\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        original.all=length;
 
        pc->wait_for_dsc=0;
        pc->callback=&idetape_write_callback;
        pc->writing=1;
 
        idetape_zero_packet_command (pc);
 
        pc->c [0]=IDETAPE_WRITE_CMD;
        pc->c [1]=1;
        pc->c [4]=original.b.b1;
        pc->c [3]=original.b.b2;
        pc->c [2]=original.b.b3;
 
        if (length)
                pc->dma_recommended=1;
 
        return;
}
 
void idetape_create_read_position_cmd (idetape_packet_command_t *pc)
 
{
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Creating READ POSITION packet command\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        pc->request_transfer=20;
        pc->wait_for_dsc=0;
        pc->callback=&idetape_read_position_callback;
        pc->writing=0;
 
        idetape_zero_packet_command (pc);
        pc->c [0]=IDETAPE_READ_POSITION_CMD;
        pc->c [1]=0;
}
 
void idetape_read_position_callback (ide_drive_t *drive)
 
{
        idetape_tape_t *tape;
        struct request *rq;
        idetape_read_position_result_t *result;
 
        tape=&(drive->tape);
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: Reached idetape_read_position_callback\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        rq=HWGROUP(drive)->rq;
 
        if (!tape->pc->error) {
                result=(idetape_read_position_result_t *) tape->pc->buffer;
#if IDETAPE_DEBUG_LOG
                printk ("Request completed\n");
                printk ("Dumping the results of the READ POSITION command\n");
                printk ("BOP - %s\n",result->bop ? "Yes":"No");
                printk ("EOP - %s\n",result->eop ? "Yes":"No");
#endif /* IDETAPE_DEBUG_LOG */
                if (result->bpu) {
                        printk ("ide-tape: Block location is unknown to the tape\n");
                        printk ("Aborting request\n");
                        tape->block_address_valid=0;
                        idetape_end_request (0,HWGROUP (drive));
                }
                else {
#if IDETAPE_DEBUG_LOG
                        printk ("Block Location - %lu\n",idetape_swap_long (result->first_block));
#endif /* IDETAPE_DEBUG_LOG */
                        tape->block_address=idetape_swap_long (result->first_block);
                        tape->block_address_valid=1;
                        idetape_end_request (1,HWGROUP (drive));
                }
        }
        else {
                printk ("Aborting request\n");
                idetape_end_request (0,HWGROUP (drive));
        }
        return;
}
 
/*
 *      Our special ide-tape ioctl's.
 *
 *      Currently there aren't any significant ioctl's.
 *      mtio.h compatible commands should be issued to the character device
 *      interface.
 */
 
int idetape_blkdev_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file,
                        unsigned int cmd, unsigned long arg)
{
        idetape_packet_command_t pc;
 
        pc.buffer=pc.temp_buffer;
        pc.buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc.current_position=pc.temp_buffer;
 
#if IDETAPE_DEBUG_LOG   
        printk ("ide-tape: Reached idetape_blkdev_ioctl\n");
#endif /* IDETAPE_DEBUG_LOG */
        switch (cmd) {
                default:
                        return -EIO;
        }
}
 
static void idetape_abort_pipeline (ide_drive_t *drive)
{
        idetape_tape_t *tape = &drive->tape;
        idetape_pipeline_stage_t *stage = tape->next_stage;
 
        while (stage) {
                stage->rq.cmd = IDETAPE_ABORTED_WRITE_REQUEST;
                stage = stage->next;
        }
}
 
/*
 *      Functions which handle requests.
 */
 
/*
 *      idetape_end_request is used to end a request.
 */
 
void idetape_end_request (byte uptodate, ide_hwgroup_t *hwgroup)
 
{
        ide_drive_t *drive = hwgroup->drive;
        struct request *rq = hwgroup->rq;
        idetape_tape_t *tape = &(drive->tape);
        unsigned int major = HWIF(drive)->major;
        struct blk_dev_struct *bdev = &blk_dev[major];
        int error;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_end_request\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        bdev->current_request=rq;                       /* Since we may have taken it out */
 
        if (!rq->errors)                                /* In case rq->errors is already set, */
                rq->errors=!uptodate;                   /* we won't change it. */
        error=rq->errors;
        if (error)
                tape->failed_pc = NULL;
 
        if (tape->active_data_request == rq) {          /* The request was a pipelined data transfer request */
 
                if (rq->cmd == IDETAPE_READ_REQUEST) {
#if IDETAPE_DEBUG_BUGS
                        if (tape->active_stage == NULL)
                                printk ("ide-tape: bug: active_stage is NULL in idetape_end_request\n");
                        else
#endif /* IDETAPE_DEBUG_BUGS */
                        idetape_copy_buffer_to_stage (tape->active_stage,tape->data_buffer);
                }
 
                tape->active_stage=NULL;
                tape->active_data_request=NULL;
 
                if (rq->cmd == IDETAPE_WRITE_REQUEST) {
                        if (rq->errors) {
                                tape->error_in_pipeline_stage=rq->errors;
                                if (error == IDETAPE_RQ_ERROR_EOD)
                                        idetape_abort_pipeline (drive);
                        }
                        idetape_remove_stage_head (drive);
                }
 
                if (tape->next_stage == NULL) {
                        if (!error)
                                idetape_increase_max_pipeline_stages (drive);
                        ide_end_drive_cmd (drive, 0, 0);
                        return;
                }
 
                idetape_active_next_stage (drive);
 
                /*
                 *      Insert the next request into the request queue.
                 *
                 *      The choice of using ide_next or ide_end is now left
                 *      to the user.
                 */
 
#if IDETAPE_LOW_TAPE_PRIORITY
                (void) ide_do_drive_cmd (drive,tape->active_data_request,ide_end);
#else
                (void) ide_do_drive_cmd (drive,tape->active_data_request,ide_next);
#endif /* IDETAPE_LOW_TAPE_PRIORITY */
        }
        ide_end_drive_cmd (drive, 0, 0);
}
 
/*
 *      idetape_do_request is our request handling function.
 */
 
void idetape_do_request (ide_drive_t *drive, struct request *rq, unsigned long block)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_packet_command_t *pc;
        unsigned int major = HWIF(drive)->major;
        struct blk_dev_struct *bdev = &blk_dev[major];
        idetape_status_reg_t status;
 
#if IDETAPE_DEBUG_LOG
        printk ("Current request:\n");
        printk ("rq_status: %d, rq_dev: %u, cmd: %d, errors: %d\n",rq->rq_status,(unsigned int) rq->rq_dev,rq->cmd,rq->errors);
        printk ("sector: %ld, nr_sectors: %ld, current_nr_sectors: %ld\n",rq->sector,rq->nr_sectors,rq->current_nr_sectors);
#endif /* IDETAPE_DEBUG_LOG */
 
        if (!IDETAPE_REQUEST_CMD (rq->cmd)) {
 
                /*
                 *      We do not support buffer cache originated requests.
                 */
 
                printk ("ide-tape: Unsupported command in request queue\n");
                printk ("ide-tape: The block device interface should not be used for data transfers.\n");
                printk ("ide-tape: Use the character device interfaces\n");
                printk ("ide-tape: /dev/ht0 and /dev/nht0 instead.\n");
                printk ("ide-tape: (Run linux/scripts/MAKEDEV.ide to create them)\n");
                printk ("ide-tape: Aborting request.\n");
 
                ide_end_request (0,HWGROUP (drive));                     /* Let the common code handle it */
                return;
        }
 
        /*
         *      This is an important point. We will try to remove our request
         *      from the block device request queue while we service the
         *      request. Note that the request must be returned to
         *      bdev->current_request before the next call to
         *      ide_end_drive_cmd or ide_do_drive_cmd to conform with the
         *      normal behavior of the IDE driver, which leaves the active
         *      request in bdev->current_request during I/O.
         *
         *      This will eliminate fragmentation of disk/cdrom requests
         *      around a tape request, now that we are using ide_next to
         *      insert pending pipeline requests, since we have only one
         *      ide-tape.c data request in the device request queue, and
         *      thus once removed, ll_rw_blk.c will only see requests from
         *      the other device.
         *
         *      The potential fragmentation inefficiency was pointed to me
         *      by Mark Lord.
         */
 
        if (rq->next != NULL && rq->rq_dev != rq->next->rq_dev)
                bdev->current_request=rq->next;
 
        /* Retry a failed packet command */
 
        if (tape->failed_pc != NULL && tape->pc->c[0] == IDETAPE_REQUEST_SENSE_CMD) {
                idetape_issue_packet_command (drive,tape->failed_pc,&idetape_pc_intr);
                return;
        }
 
        /* Check if we have a postponed request */
 
        if (tape->postponed_rq != NULL) {
#if IDETAPE_DEBUG_BUGS
                if (tape->postponed_rq->rq_status != RQ_ACTIVE || rq != tape->postponed_rq) {
                        printk ("ide-tape: ide-tape.c bug - Two DSC requests were queued\n");
                        idetape_end_request (0,HWGROUP (drive));
                        return;
                }
#endif /* IDETAPE_DEBUG_BUGS */
                if (rq->cmd == IDETAPE_PACKET_COMMAND_REQUEST_TYPE1) {
 
                        /* Media access command */
 
                        tape->postponed_rq = NULL;
                        idetape_media_access_finished (drive);
                        return;
                }
 
                /*
                 * Read / Write command - DSC polling was done before the
                 * actual command - Continue normally so that the command
                 * will be performed below.
                 */
 
                 tape->postponed_rq = NULL;
        }
 
        status.all=IN_BYTE (IDETAPE_STATUS_REG);
 
        /*
         *      After a software reset, the status register is locked. We
         *      will ignore the DSC value for our very first packet command,
         *      which will restore DSC operation.
         */
 
        if (tape->reset_issued) {
                status.b.dsc=1;
                tape->reset_issued=0;
        }
 
        switch (rq->cmd) {
                case IDETAPE_READ_REQUEST:
                        if (!status.b.dsc) {                            /* Tape buffer not ready to accept r/w command */
#if IDETAPE_DEBUG_LOG
                                printk ("ide-tape: DSC != 1 - Postponing read request\n");
#endif /* IDETAPE_DEBUG_LOG */  
                                tape->dsc_polling_frequency=tape->best_dsc_rw_frequency;
                                idetape_postpone_request (drive);       /* Allow ide.c to process requests from */
                                return;
                        }
 
                        pc=idetape_next_pc_storage (drive);
 
                        idetape_create_read_cmd (pc,rq->current_nr_sectors);
 
                        pc->buffer=rq->buffer;
                        pc->buffer_size=rq->current_nr_sectors*tape->tape_block_size;
                        pc->current_position=rq->buffer;
                        pc->request_transfer=rq->current_nr_sectors*tape->tape_block_size;
 
                        idetape_issue_packet_command (drive,pc,&idetape_pc_intr);
                        return;
 
                case IDETAPE_WRITE_REQUEST:
                        if (!status.b.dsc) {                            /* Tape buffer not ready to accept r/w command */
#if IDETAPE_DEBUG_LOG
                                printk ("ide-tape: DSC != 1 - Postponing write request\n");
#endif /* IDETAPE_DEBUG_LOG */  
                                tape->dsc_polling_frequency=tape->best_dsc_rw_frequency;
                                idetape_postpone_request (drive);       /* Allow ide.c to process requests from */
                                return;
                        }
 
                        pc=idetape_next_pc_storage (drive);
 
                        idetape_create_write_cmd (pc,rq->current_nr_sectors);
 
                        pc->buffer=rq->buffer;
                        pc->buffer_size=rq->current_nr_sectors*tape->tape_block_size;
                        pc->current_position=rq->buffer;
                        pc->request_transfer=rq->current_nr_sectors*tape->tape_block_size;
 
                        idetape_issue_packet_command (drive,pc,&idetape_pc_intr);
                        return;
 
                case IDETAPE_ABORTED_WRITE_REQUEST:
                        rq->cmd = IDETAPE_WRITE_REQUEST;
                        rq->errors = IDETAPE_RQ_ERROR_EOD;
                        idetape_end_request (1, HWGROUP(drive));
                        return;
 
                case IDETAPE_PACKET_COMMAND_REQUEST_TYPE1:
                case IDETAPE_PACKET_COMMAND_REQUEST_TYPE2:
/*
 *      This should be unnecessary (postponing of a general packet command),
 *      but I have occasionally missed DSC on a media access command otherwise.
 *      ??? Still have to figure it out ...
 */
                        if (!status.b.dsc) {                            /* Tape buffers are still not ready */
#if IDETAPE_DEBUG_LOG
                                printk ("ide-tape: DSC != 1 - Postponing packet command request\n");
#endif /* IDETAPE_DEBUG_LOG */
                                rq->cmd=IDETAPE_PACKET_COMMAND_REQUEST_TYPE2;   /* Note that we are waiting for DSC *before* we */
                                                                                /* even issued the command */
                                tape->dsc_polling_frequency=IDETAPE_DSC_READ_WRITE_FALLBACK_FREQUENCY;
                                idetape_postpone_request (drive);       /* Allow ide.c to process requests from */
                                return;
                        }
                        rq->cmd=IDETAPE_PACKET_COMMAND_REQUEST_TYPE1;
                        pc=(idetape_packet_command_t *) rq->buffer;
                        idetape_issue_packet_command (drive,pc,&idetape_pc_intr);
                        return;
#if IDETAPE_DEBUG_BUGS
                default:
                        printk ("ide-tape: bug in IDETAPE_REQUEST_CMD macro\n");
                        idetape_end_request (0,HWGROUP (drive));
#endif /* IDETAPE_DEBUG_BUGS */
        }
}
 
/*
 *      idetape_queue_pc_tail is based on the following functions:
 *
 *      ide_do_drive_cmd from ide.c
 *      cdrom_queue_request and cdrom_queue_packet_command from ide-cd.c
 *
 *      We add a special packet command request to the tail of the request queue,
 *      and wait for it to be serviced.
 *
 *      This is not to be called from within the request handling part
 *      of the driver ! We allocate here data in the stack, and it is valid
 *      until the request is finished. This is not the case for the bottom
 *      part of the driver, where we are always leaving the functions to wait
 *      for an interrupt or a timer event.
 *
 *      From the bottom part of the driver, we should allocate safe memory
 *      using idetape_next_pc_storage and idetape_next_rq_storage, and add
 *      the request to the request list without waiting for it to be serviced !
 *      In that case, we usually use idetape_queue_pc_head.
 */
 
int idetape_queue_pc_tail (ide_drive_t *drive,idetape_packet_command_t *pc)
{
        struct request rq;
 
        ide_init_drive_cmd (&rq);
        rq.buffer = (char *) pc;
        rq.cmd = IDETAPE_PACKET_COMMAND_REQUEST_TYPE1;
        return ide_do_drive_cmd (drive, &rq, ide_wait);
}
 
/*
 *      idetape_queue_pc_head generates a new packet command request in front
 *      of the request queue, before the current request, so that it will be
 *      processed immediately, on the next pass through the driver.
 *
 *      idetape_queue_pc_head is called from the request handling part of
 *      the driver (the "bottom" part). Safe storage for the request should
 *      be allocated with idetape_next_pc_storage and idetape_next_rq_storage
 *      before calling idetape_queue_pc_head.
 *
 *      Memory for those requests is pre-allocated at initialization time, and
 *      is limited to IDETAPE_PC_STACK requests. We assume that we have enough
 *      space for the maximum possible number of inter-dependent packet commands.
 *
 *      The higher level of the driver - The ioctl handler and the character
 *      device handling functions should queue request to the lower level part
 *      and wait for their completion using idetape_queue_pc_tail or
 *      idetape_queue_rw_tail.
 */
 
void idetape_queue_pc_head (ide_drive_t *drive,idetape_packet_command_t *pc,struct request *rq)
 
{
        unsigned int major = HWIF(drive)->major;
        struct blk_dev_struct *bdev = &blk_dev[major];
 
        bdev->current_request=HWGROUP (drive)->rq;              /* Since we may have taken it out */
 
        ide_init_drive_cmd (rq);
        rq->buffer = (char *) pc;
        rq->cmd = IDETAPE_PACKET_COMMAND_REQUEST_TYPE1;
        (void) ide_do_drive_cmd (drive, rq, ide_preempt);
}
 
/*
 *      idetape_wait_for_request installs a semaphore in a pending request
 *      and sleeps until it is serviced.
 *
 *      The caller should ensure that the request will not be serviced
 *      before we install the semaphore (usually by disabling interrupts).
 */
 
void idetape_wait_for_request (struct request *rq)
 
{
        struct semaphore sem = MUTEX_LOCKED;
 
#if IDETAPE_DEBUG_BUGS
        if (rq == NULL || !IDETAPE_REQUEST_CMD (rq->cmd)) {
                printk ("ide-tape: bug: Trying to sleep on non-valid request\n");
                return;
        }
#endif /* IDETAPE_DEBUG_BUGS */
 
        rq->sem=&sem;
        down (&sem);
}
 
/*
 *      idetape_queue_rw_tail generates a read/write request for the block
 *      device interface and wait for it to be serviced.
 */
 
int idetape_queue_rw_tail (ide_drive_t *drive,int cmd,int blocks,char *buffer)
 
{
        idetape_tape_t *tape = &(drive->tape);
        struct request rq;
 
#if IDETAPE_DEBUG_LOG
        printk ("idetape_queue_rw_tail: cmd=%d\n",cmd);
#endif /* IDETAPE_DEBUG_LOG */
#if IDETAPE_DEBUG_BUGS
        if (tape->active_data_request != NULL) {
                printk ("ide-tape: bug: the pipeline is active in idetape_queue_rw_tail\n");
                return (0);
        }
#endif /* IDETAPE_DEBUG_BUGS */ 
 
        ide_init_drive_cmd (&rq);
        rq.buffer = buffer;
        rq.cmd = cmd;
        rq.sector = tape->block_address;
        rq.nr_sectors = rq.current_nr_sectors = blocks;
        (void) ide_do_drive_cmd (drive, &rq, ide_wait);
 
        return (tape->tape_block_size*(blocks-rq.current_nr_sectors));
}
 
/*
 *      idetape_add_chrdev_read_request handles character device read requests
 *      when operating in the pipelined operation mode.
 */
 
int idetape_add_chrdev_read_request (ide_drive_t *drive,int blocks,char *buffer)
 
{
        idetape_tape_t *tape = &(drive->tape);
        idetape_pipeline_stage_t *new_stage;
        unsigned long flags;
        struct request rq,*rq_ptr;
        int bytes_read;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_add_chrdev_read_request\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        ide_init_drive_cmd (&rq);
        rq.cmd = IDETAPE_READ_REQUEST;
        rq.sector = tape->block_address;
        rq.nr_sectors = rq.current_nr_sectors = blocks;
 
        if (tape->active_data_request != NULL || tape->current_number_of_stages <= tape->max_number_of_stages / 4) {
                new_stage=idetape_kmalloc_stage (drive);
                while (new_stage != NULL) {
                        new_stage->rq=rq;
                        save_flags (flags);cli ();
                        idetape_add_stage_tail (drive,new_stage);
                        restore_flags (flags);
                        new_stage=idetape_kmalloc_stage (drive);
                }
                if (tape->active_data_request == NULL)
                        idetape_insert_pipeline_into_queue (drive);
        }
 
        if (tape->first_stage == NULL) {
 
                /*
                 *      Linux is short on memory. Revert to non-pipelined
                 *      operation mode for this request.
                 */
 
                return (idetape_queue_rw_tail (drive,IDETAPE_READ_REQUEST,blocks,buffer));
        }
 
        save_flags (flags);cli ();
        if (tape->active_data_request == &(tape->first_stage->rq))
                idetape_wait_for_request (tape->active_data_request);
        restore_flags (flags);
 
        rq_ptr=&(tape->first_stage->rq);
        bytes_read=tape->tape_block_size*(rq_ptr->nr_sectors-rq_ptr->current_nr_sectors);
        rq_ptr->nr_sectors=rq_ptr->current_nr_sectors=0;
        idetape_copy_buffer_from_stage (tape->first_stage,buffer);
        if (rq_ptr->errors != IDETAPE_RQ_ERROR_FILEMARK) {
                tape->filemark = 0;
                idetape_remove_stage_head (drive);
        } else
                tape->filemark = 1;
#if IDETAPE_DEBUG_BUGS
        if (bytes_read > blocks*tape->tape_block_size) {
                printk ("ide-tape: bug: trying to return more bytes than requested\n");
                bytes_read=blocks*tape->tape_block_size;
        }
#endif /* IDETAPE_DEBUG_BUGS */
        return (bytes_read);
}
 
/*
 *      idetape_add_chrdev_write_request tries to add a character device
 *      originated write request to our pipeline. In case we don't succeed,
 *      we revert to non-pipelined operation mode for this request.
 *
 *      1.      Try to allocate a new pipeline stage.
 *      2.      If we can't, wait for more and more requests to be serviced
 *              and try again each time.
 *      3.      If we still can't allocate a stage, fallback to
 *              non-pipelined operation mode for this request.
 */
 
int idetape_add_chrdev_write_request (ide_drive_t *drive,int blocks,char *buffer)
 
{
        idetape_tape_t *tape = &(drive->tape);
        idetape_pipeline_stage_t *new_stage;
        unsigned long flags;
        struct request *rq;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_add_chrdev_write_request\n");
#endif /* IDETAPE_DEBUG_LOG */
 
 
        new_stage=idetape_kmalloc_stage (drive);
 
        /*
         *      If we don't have a new stage, wait for more and more requests
         *      to finish, and try to allocate after each one.
         *
         *      Pay special attention to possible race conditions.
         */
 
        while (new_stage == NULL) {
                save_flags (flags);cli ();
                if (tape->active_data_request != NULL) {
                        idetape_wait_for_request (tape->active_data_request);
                        restore_flags (flags);
                        new_stage=idetape_kmalloc_stage (drive);
                }
                else {
                        /*
                         *      Linux is short on memory. Fallback to
                         *      non-pipelined operation mode for this request.
                         */
 
                        restore_flags (flags);
                        return (idetape_queue_rw_tail (drive,IDETAPE_WRITE_REQUEST,blocks,buffer));
                }
        }
 
        rq=&(new_stage->rq);
 
        ide_init_drive_cmd (rq);
        rq->cmd = IDETAPE_WRITE_REQUEST;
        rq->sector = tape->block_address;       /* Doesn't actually matter - We always assume sequential access */
        rq->nr_sectors = blocks;
        rq->current_nr_sectors = blocks;
 
        idetape_copy_buffer_to_stage (new_stage,buffer);
 
        save_flags (flags);cli ();
        idetape_add_stage_tail (drive,new_stage);
        restore_flags (flags);
 
        /*
         *      Check if we are currently servicing requests in the bottom
         *      part of the driver.
         *
         *      If not, wait for the pipeline to be full enough (75%) before
         *      starting to service requests, so that we will be able to
         *      keep up with the higher speeds of the tape.
         */
 
        if (tape->active_data_request == NULL && tape->current_number_of_stages >= (3 * tape->max_number_of_stages) / 4)
                idetape_insert_pipeline_into_queue (drive);
 
        if (tape->error_in_pipeline_stage) {            /* Return a deferred error */
                tape->error_in_pipeline_stage=0;
                return (-EIO);
        }
 
        return (blocks);
}
 
void idetape_discard_read_pipeline (ide_drive_t *drive)
 
{
        idetape_tape_t *tape = &(drive->tape);
        unsigned long flags;
 
#if IDETAPE_DEBUG_BUGS
        if (tape->chrdev_direction != idetape_direction_read) {
                printk ("ide-tape: bug: Trying to discard read pipeline, but we are not reading.\n");
                return;
        }
#endif /* IDETAPE_DEBUG_BUGS */
 
        tape->merge_buffer_size=tape->merge_buffer_offset=0;
        tape->chrdev_direction=idetape_direction_none;
 
        if (tape->first_stage == NULL)
                return;
 
        save_flags (flags);cli ();
        tape->next_stage=NULL;
        if (tape->active_data_request != NULL)
                idetape_wait_for_request (tape->active_data_request);
        restore_flags (flags);
 
        while (tape->first_stage != NULL)
                idetape_remove_stage_head (drive);
 
#if IDETAPE_PIPELINE
        tape->max_number_of_stages=IDETAPE_MIN_PIPELINE_STAGES;
#else
        tape->max_number_of_stages=0;
#endif /* IDETAPE_PIPELINE */
}
 
/*
 *      idetape_wait_for_pipeline will wait until all pending pipeline
 *      requests are serviced. Typically called on device close.
 */
 
void idetape_wait_for_pipeline (ide_drive_t *drive)
 
{
        idetape_tape_t *tape = &(drive->tape);
        unsigned long flags;
 
        if (tape->active_data_request == NULL)
                idetape_insert_pipeline_into_queue (drive);
 
        save_flags (flags);cli ();
        if (tape->active_data_request == NULL) {
                restore_flags (flags);
                return;
        }
 
        if (tape->last_stage != NULL)
                idetape_wait_for_request (&(tape->last_stage->rq));
 
        else if (tape->active_data_request != NULL)
                idetape_wait_for_request (tape->active_data_request);
        restore_flags (flags);
}
 
void idetape_empty_write_pipeline (ide_drive_t *drive)
 
{
        idetape_tape_t *tape = &(drive->tape);
        int blocks;
 
#if IDETAPE_DEBUG_BUGS
        if (tape->chrdev_direction != idetape_direction_write) {
                printk ("ide-tape: bug: Trying to empty write pipeline, but we are not writing.\n");
                return;
        }
        if (tape->merge_buffer_size > tape->data_buffer_size) {
                printk ("ide-tape: bug: merge_buffer too big\n");
                tape->merge_buffer_size = tape->data_buffer_size;
        }
#endif /* IDETAPE_DEBUG_BUGS */
 
        if (tape->merge_buffer_size) {
                blocks=tape->merge_buffer_size/tape->tape_block_size;
                if (tape->merge_buffer_size % tape->tape_block_size) {
                        blocks++;
                        memset (tape->merge_buffer+tape->merge_buffer_size,0,tape->data_buffer_size-tape->merge_buffer_size);
                }
                (void) idetape_add_chrdev_write_request (drive,blocks,tape->merge_buffer);
                tape->merge_buffer_size=0;
        }
 
        idetape_wait_for_pipeline (drive);
 
        tape->error_in_pipeline_stage=0;
        tape->chrdev_direction=idetape_direction_none;
 
        /*
         *      On the next backup, perform the feedback loop again.
         *      (I don't want to keep sense information between backups,
         *       as some systems are constantly on, and the system load
         *       can be totally different on the next backup).
         */
 
#if IDETAPE_PIPELINE
        tape->max_number_of_stages=IDETAPE_MIN_PIPELINE_STAGES;
#else
        tape->max_number_of_stages=0;
#endif /* IDETAPE_PIPELINE */
#if IDETAPE_DEBUG_BUGS
        if (tape->first_stage != NULL || tape->next_stage != NULL || tape->last_stage != NULL || tape->current_number_of_stages != 0) {
                printk ("ide-tape: ide-tape pipeline bug\n");
        }
#endif /* IDETAPE_DEBUG_BUGS */
}
 
/*
 *      idetape_zero_packet_command just zeros a packet command and
 *      sets the number of retries to 0, as we haven't retried it yet.
 */
 
void idetape_zero_packet_command (idetape_packet_command_t *pc)
 
{
        int i;
 
        for (i=0;i<12;i++)
                pc->c[i]=0;
        pc->retries=0;
        pc->abort=0;
        pc->dma_recommended=0;
        pc->dma_error=0;
}
 
/*
 *      idetape_swap_shorts converts a 16 bit number from little endian
 *      to big endian format.
 */
 
unsigned short idetape_swap_short (unsigned short temp)
 
{
        union convert {
                unsigned all    :16;
                struct {
                        unsigned b1     :8;
                        unsigned b2     :8;
                } b;
        } original,converted;
 
        original.all=temp;
        converted.b.b1=original.b.b2;
        converted.b.b2=original.b.b1;
        return (converted.all);
}
 
/*
 *      idetape_swap_long converts from little endian to big endian format.
 */
 
unsigned long idetape_swap_long (unsigned long temp)
 
{
        union convert {
                unsigned all    :32;
                struct {
                        unsigned b1     :8;
                        unsigned b2     :8;
                        unsigned b3     :8;
                        unsigned b4     :8;
                } b;
        } original,converted;
 
        original.all=temp;
        converted.b.b1=original.b.b4;
        converted.b.b2=original.b.b3;
        converted.b.b3=original.b.b2;
        converted.b.b4=original.b.b1;
        return (converted.all);
}
 
 
/*
 *      idetape_next_pc_storage returns a pointer to a place in which we can
 *      safely store a packet command, even though we intend to leave the
 *      driver. A storage space for a maximum of IDETAPE_PC_STACK packet
 *      commands is allocated at initialization time.
 */
 
idetape_packet_command_t *idetape_next_pc_storage (ide_drive_t *drive)
 
{
        idetape_tape_t *tape;
 
        tape=&(drive->tape);
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: pc_stack_index=%d\n",tape->pc_stack_index);
#endif /* IDETAPE_DEBUG_LOG */
        if (tape->pc_stack_index==IDETAPE_PC_STACK)
                tape->pc_stack_index=0;
        return (&(tape->pc_stack [tape->pc_stack_index++]));
}
 
/*
 *      idetape_next_rq_storage is used along with idetape_next_pc_storage.
 *      Since we queue packet commands in the request queue, we need to
 *      allocate a request, along with the allocation of a packet command.
 */
 
/**************************************************************
 *                                                            *
 *  This should get fixed to use kmalloc(GFP_ATOMIC, ..)      *
 *  followed later on by kfree().   -ml                       *
 *                                                            *
 **************************************************************/
 
struct request *idetape_next_rq_storage (ide_drive_t *drive)
 
{
        idetape_tape_t *tape;
 
        tape=&(drive->tape);
 
#if IDETAPE_DEBUG_LOG
        printk ("ide-tape: rq_stack_index=%d\n",tape->rq_stack_index);
#endif /* IDETAPE_DEBUG_LOG */
        if (tape->rq_stack_index==IDETAPE_PC_STACK)
                tape->rq_stack_index=0;
        return (&(tape->rq_stack [tape->rq_stack_index++]));
}
 
/*
 *      Block device interface functions
 *
 *      The block device interface should not be used for data transfers.
 *      However, we still allow opening it so that we can issue general
 *      ide driver configuration ioctl's, such as the interrupt unmask feature.
 */
 
int idetape_blkdev_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        unsigned long flags;
 
        save_flags (flags);cli ();
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_blkdev_open\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        if (tape->busy) {
                restore_flags (flags);          /* Allowing access only through one */
                return (-EBUSY);                /* one file descriptor */
        }
 
        tape->busy=1;
        restore_flags (flags);
 
        return (0);
}
 
void idetape_blkdev_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        unsigned long flags;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_blkdev_release\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        save_flags (flags);cli ();
        tape->busy=0;
        restore_flags (flags);
 
        return;
}
 
/*
 *      Character device interface functions
 */
 
/*
 *      Our character device read / write functions.
 *
 *      The tape is optimized to maximize throughput when it is transferring
 *      an integral number of the "continuous transfer limit", which is
 *      a parameter of the specific tape (26 KB on my particular tape).
 *
 *      For best results use an integral number of the tape's parameter
 *      (which is displayed in the driver installation stage and is returned
 *       by the MTIOCGET ioctl).
 *
 *      As of version 1.3 of the driver, the character device provides an
 *      abstract continuous view of the media - any mix of block sizes (even 1
 *      byte) on the same backup/restore procedure is supported. The driver
 *      will internally convert the requests to the recommended transfer unit,
 *      so that an unmatch between the user's block size to the recommended
 *      size will only result in a (slightly) increased driver overhead, but
 *      will no longer hit performance.
 */
 
int idetape_chrdev_read (struct inode *inode, struct file *file, char *buf, int count)
 
{
        ide_drive_t *drive=idetape_chrdev.drive;
        idetape_tape_t *tape=&(drive->tape);
        char *buf_ptr=buf;
        int bytes_read,temp,actually_read=0;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_chrdev_read\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        if (tape->chrdev_direction != idetape_direction_read) {         /* Initialize read operation */
                if (tape->chrdev_direction == idetape_direction_write) {
                        idetape_empty_write_pipeline (drive);
                        idetape_flush_tape_buffers (drive);
                }
 
                /*
                 *      Issue a read 0 command to ensure that DSC handshake
                 *      is switched from completion mode to buffer available
                 *      mode.
                 */
 
                bytes_read=idetape_queue_rw_tail (drive,IDETAPE_READ_REQUEST,0,tape->merge_buffer);
                if (bytes_read < 0)
                        return (bytes_read);
 
                tape->chrdev_direction=idetape_direction_read;
        }
 
        if (count==0)
                return (0);
 
        if (tape->merge_buffer_size) {
#if IDETAPE_DEBUG_BUGS
                if (tape->merge_buffer_offset+tape->merge_buffer_size > tape->data_buffer_size) {
                        printk ("ide-tape: bug: merge buffer too big\n");
                        tape->merge_buffer_offset=0;tape->merge_buffer_size=tape->data_buffer_size-1;
                }
#endif /* IDETAPE_DEBUG_BUGS */
                actually_read=IDETAPE_MIN (tape->merge_buffer_size,count);
                memcpy_tofs (buf_ptr,tape->merge_buffer+tape->merge_buffer_offset,actually_read);
                buf_ptr+=actually_read;tape->merge_buffer_size-=actually_read;
                count-=actually_read;tape->merge_buffer_offset+=actually_read;
        }
 
        while (count >= tape->data_buffer_size) {
                bytes_read=idetape_add_chrdev_read_request (drive,tape->capabilities.ctl,tape->merge_buffer);
                if (bytes_read <= 0)
                        goto finish;
                memcpy_tofs (buf_ptr,tape->merge_buffer,bytes_read);
                buf_ptr+=bytes_read;count-=bytes_read;actually_read+=bytes_read;
        }
 
        if (count) {
                bytes_read=idetape_add_chrdev_read_request (drive,tape->capabilities.ctl,tape->merge_buffer);
                if (bytes_read <= 0)
                        goto finish;
                temp=IDETAPE_MIN (count,bytes_read);
                memcpy_tofs (buf_ptr,tape->merge_buffer,temp);
                actually_read+=temp;
                tape->merge_buffer_offset=temp;
                tape->merge_buffer_size=bytes_read-temp;
        }
finish:
        if (!actually_read && tape->filemark)
                idetape_space_over_filemarks (drive, MTFSF, 1);
        return (actually_read);
}
 
int idetape_chrdev_write (struct inode *inode, struct file *file, const char *buf, int count)
 
{
        ide_drive_t *drive=idetape_chrdev.drive;
        idetape_tape_t *tape=&(drive->tape);
        const char *buf_ptr=buf;
        int retval,actually_written=0;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_chrdev_write\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        if (tape->chrdev_direction != idetape_direction_write) {        /* Initialize write operation */
                if (tape->chrdev_direction == idetape_direction_read)
                        idetape_discard_read_pipeline (drive);
 
                /*
                 *      Issue a write 0 command to ensure that DSC handshake
                 *      is switched from completion mode to buffer available
                 *      mode.
                 */
 
                retval=idetape_queue_rw_tail (drive,IDETAPE_WRITE_REQUEST,0,tape->merge_buffer);
                if (retval < 0)
                        return (retval);
 
                tape->chrdev_direction=idetape_direction_write;
        }
 
        if (count==0)
                return (0);
 
        if (tape->merge_buffer_size) {
#if IDETAPE_DEBUG_BUGS
                if (tape->merge_buffer_size >= tape->data_buffer_size) {
                        printk ("ide-tape: bug: merge buffer too big\n");
                        tape->merge_buffer_size=0;
                }
#endif /* IDETAPE_DEBUG_BUGS */
 
                actually_written=IDETAPE_MIN (tape->data_buffer_size-tape->merge_buffer_size,count);
                memcpy_fromfs (tape->merge_buffer+tape->merge_buffer_size,buf_ptr,actually_written);
                buf_ptr+=actually_written;tape->merge_buffer_size+=actually_written;count-=actually_written;
 
                if (tape->merge_buffer_size == tape->data_buffer_size) {
                        tape->merge_buffer_size=0;
                        retval=idetape_add_chrdev_write_request (drive,tape->capabilities.ctl,tape->merge_buffer);
                        if (retval <= 0)
                                return (retval);
                }
        }
 
        while (count >= tape->data_buffer_size) {
                memcpy_fromfs (tape->merge_buffer,buf_ptr,tape->data_buffer_size);
                buf_ptr+=tape->data_buffer_size;count-=tape->data_buffer_size;
                retval=idetape_add_chrdev_write_request (drive,tape->capabilities.ctl,tape->merge_buffer);
                actually_written+=tape->data_buffer_size;
                if (retval <= 0)
                        return (retval);
        }
 
        if (count) {
                actually_written+=count;
                memcpy_fromfs (tape->merge_buffer,buf_ptr,count);
                tape->merge_buffer_size+=count;
        }
        return (actually_written);
}
 
static int idetape_pipeline_size (ide_drive_t *drive)
{
        idetape_tape_t *tape = &drive->tape;
        idetape_pipeline_stage_t *stage;
        struct request *rq;
        int size = 0;
 
        idetape_wait_for_pipeline (drive);
        stage = tape->first_stage;
        while (stage != NULL) {
                rq = &stage->rq;
                size += tape->tape_block_size * (rq->nr_sectors-rq->current_nr_sectors);
                if (rq->errors == IDETAPE_RQ_ERROR_FILEMARK)
                        size += tape->tape_block_size;
                stage = stage->next;
        }
        size += tape->merge_buffer_size;
        return size;
}
 
/*
 *      Our character device ioctls.
 *
 *      General mtio.h magnetic io commands are supported here, and not in
 *      the corresponding block interface.
 *
 *      The following ioctls are supported:
 *
 *      MTIOCTOP -      Refer to idetape_mtioctop for detailed description.
 *
 *      MTIOCGET -      Some of the fields are not supported.
 *
 *      MTIOCPOS -      The current tape "position" is returned.
 *                      (A unique number which can be used with the MTSEEK
 *                       operation to return to this position in some
 *                       future time, provided this place was not overwritten
 *                       meanwhile).
 *
 *      Our own ide-tape ioctls are supported on both interfaces.
 */
 
int idetape_chrdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 
{
        ide_drive_t *drive=idetape_chrdev.drive;
        idetape_tape_t *tape=&(drive->tape);
        idetape_packet_command_t pc;
        struct mtop mtop;
        struct mtget mtget;
        struct mtpos mtpos;
        int retval, block_offset = 0;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_chrdev_ioctl, cmd=%u\n",cmd);
#endif /* IDETAPE_DEBUG_LOG */
 
        if (tape->chrdev_direction == idetape_direction_write) {
                idetape_empty_write_pipeline (drive);
                idetape_flush_tape_buffers (drive);
        }
        pc.buffer=pc.temp_buffer;
        pc.buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc.current_position=pc.temp_buffer;
 
        if (cmd == MTIOCGET || cmd == MTIOCPOS) {
                block_offset = idetape_pipeline_size (drive) / tape->tape_block_size;
                idetape_create_read_position_cmd (&pc);
                retval=idetape_queue_pc_tail (drive,&pc);
                if (retval) return (retval);
        }
        switch (cmd) {
                case MTIOCTOP:
                        retval=verify_area (VERIFY_READ,(char *) arg,sizeof (struct mtop));
                        if (retval) return (retval);
                        memcpy_fromfs ((char *) &mtop, (char *) arg, sizeof (struct mtop));
                        return (idetape_mtioctop (drive,mtop.mt_op,mtop.mt_count));
                case MTIOCGET:
                        memset (&mtget, 0, sizeof (struct mtget));
                        mtget.mt_blkno = tape->block_address - block_offset;
                        mtget.mt_dsreg=(tape->data_buffer_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK;
                        retval=verify_area (VERIFY_WRITE,(char *) arg,sizeof (struct mtget));
                        if (retval) return (retval);
                        memcpy_tofs ((char *) arg,(char *) &mtget, sizeof (struct mtget));
                        return (0);
                case MTIOCPOS:
                        mtpos.mt_blkno = tape->block_address - block_offset;
                        retval=verify_area (VERIFY_WRITE,(char *) arg,sizeof (struct mtpos));
                        if (retval) return (retval);
                        memcpy_tofs ((char *) arg,(char *) &mtpos, sizeof (struct mtpos));
                        return (0);
                default:
                        return (idetape_blkdev_ioctl (drive,inode,file,cmd,arg));
        }
}
 
/*
 *      idetape_mtioctop is called from idetape_chrdev_ioctl when
 *      the general mtio MTIOCTOP ioctl is requested.
 *
 *      We currently support the following mtio.h operations:
 *
 *      MTFSF   -       Space over mt_count filemarks in the positive direction.
 *                      The tape is positioned after the last spaced filemark.
 *
 *      MTFSFM  -       Same as MTFSF, but the tape is positioned before the
 *                      last filemark.
 *
 *      MTBSF   -       Steps background over mt_count filemarks, tape is
 *                      positioned before the last filemark.
 *
 *      MTBSFM  -       Like MTBSF, only tape is positioned after the last filemark.
 *
 *
 *      Note:
 *
 *              MTBSF and MTBSFM are not supported when the tape doesn't
 *              supports spacing over filemarks in the reverse direction.
 *              In this case, MTFSFM is also usually not supported (it is
 *              supported in the rare case in which we crossed the filemark
 *              during our read-ahead pipelined operation mode).
 *
 *      MTWEOF  -       Writes mt_count filemarks. Tape is positioned after
 *                      the last written filemark.
 *
 *      MTREW   -       Rewinds tape.
 *
 *      MTOFFL  -       Puts the tape drive "Offline": Rewinds the tape and
 *                      prevents further access until the media is replaced.
 *
 *      MTNOP   -       Flushes tape buffers.
 *
 *      MTRETEN -       Retension media. This typically consists of one end
 *                      to end pass on the media.
 *
 *      MTEOM   -       Moves to the end of recorded data.
 *
 *      MTERASE -       Erases tape.
 *
 *      MTSEEK  -       Positions the tape in a specific block number, which
 *                      was previously received using the MTIOCPOS ioctl,
 *                      assuming this place was not overwritten meanwhile.
 *
 *      The following commands are currently not supported:
 *
 *      MTFSR, MTBSR, MTFSS, MTBSS, MTWSM, MTSETBLK, MTSETDENSITY,
 *      MTSETDRVBUFFER, MT_ST_BOOLEANS, MT_ST_WRITE_THRESHOLD.
 */
 
int idetape_mtioctop (ide_drive_t *drive,short mt_op,int mt_count)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_packet_command_t pc;
        int i,retval;
 
        pc.buffer=pc.temp_buffer;
        pc.buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc.current_position=pc.temp_buffer;
 
#if IDETAPE_DEBUG_LOG
        printk ("Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n",mt_op,mt_count);
#endif /* IDETAPE_DEBUG_LOG */
 
        /*
         *      Commands which need our pipelined read-ahead stages.
         */
 
        switch (mt_op) {
                case MTFSF:
                case MTFSFM:
                case MTBSF:
                case MTBSFM:
                        if (!mt_count)
                                return (0);
                        return (idetape_space_over_filemarks (drive,mt_op,mt_count));
                default:
                        break;
        }
 
        /*
         *      Empty the pipeline.
         */
 
        if (tape->chrdev_direction == idetape_direction_read)
                idetape_discard_read_pipeline (drive);
 
        switch (mt_op) {
                case MTWEOF:
                        for (i=0;i<mt_count;i++) {
                                idetape_create_write_filemark_cmd (&pc,1);
                                retval=idetape_queue_pc_tail (drive,&pc);
                                if (retval) return (retval);
                        }
                        return (0);
                case MTREW:
                        return (idetape_rewind_tape (drive));
                case MTOFFL:
                        idetape_create_load_unload_cmd (&pc,!IDETAPE_LU_LOAD_MASK);
                        return (idetape_queue_pc_tail (drive,&pc));
                case MTNOP:
                        return (idetape_flush_tape_buffers (drive));
                case MTRETEN:
                        idetape_create_load_unload_cmd (&pc,IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
                        return (idetape_queue_pc_tail (drive,&pc));
                case MTEOM:
                        idetape_create_space_cmd (&pc,0,IDETAPE_SPACE_TO_EOD);
                        return (idetape_queue_pc_tail (drive,&pc));
                case MTERASE:
                        retval=idetape_rewind_tape (drive);
                        if (retval) return (retval);
                        idetape_create_erase_cmd (&pc);
                        return (idetape_queue_pc_tail (drive,&pc));
                case MTSEEK:
                        return (idetape_position_tape (drive,mt_count));
                default:
                        printk ("ide-tape: MTIO operation %d not supported\n",mt_op);
                        return (-EIO);
        }
}
 
/*
 *      idetape_space_over_filemarks is now a bit more complicated than just
 *      passing the command to the tape since we may have crossed some
 *      filemarks during our pipelined read-ahead mode.
 *
 *      As a minor side effect, the pipeline enables us to support MTFSFM when
 *      the filemark is in our internal pipeline even if the tape doesn't
 *      support spacing over filemarks in the reverse direction.
 */
 
int idetape_space_over_filemarks (ide_drive_t *drive,short mt_op,int mt_count)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_packet_command_t pc;
        unsigned long flags;
        int retval,count=0,errors;
 
        if (tape->chrdev_direction == idetape_direction_read) {
 
                /*
                 *      We have a read-ahead buffer. Scan it for crossed
                 *      filemarks.
                 */
 
                tape->merge_buffer_size=tape->merge_buffer_offset=0;
                tape->filemark = 0;
                while (tape->first_stage != NULL) {
 
                        /*
                         *      Wait until the first read-ahead request
                         *      is serviced.
                         */
 
                        save_flags (flags);cli ();
                        if (tape->active_data_request == &(tape->first_stage->rq))
                                idetape_wait_for_request (tape->active_data_request);
                        restore_flags (flags);
 
                        errors=tape->first_stage->rq.errors;
                        if (errors == IDETAPE_RQ_ERROR_FILEMARK)
                                count++;
 
                        if (count == mt_count) {
                                switch (mt_op) {
                                        case MTFSF:
                                                idetape_remove_stage_head (drive);
                                        case MTFSFM:
                                                return (0);
                                }
                        }
                        idetape_remove_stage_head (drive);
                }
                idetape_discard_read_pipeline (drive);
        }
 
        /*
         *      The filemark was not found in our internal pipeline.
         *      Now we can issue the space command.
         */
 
        pc.buffer=pc.temp_buffer;
        pc.buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc.current_position=pc.temp_buffer;
 
        switch (mt_op) {
                case MTFSF:
                        idetape_create_space_cmd (&pc,mt_count-count,IDETAPE_SPACE_OVER_FILEMARK);
                        return (idetape_queue_pc_tail (drive,&pc));
                case MTFSFM:
                        if (!tape->capabilities.sprev)
                                return (-EIO);
                        retval=idetape_mtioctop (drive,MTFSF,mt_count-count);
                        if (retval) return (retval);
                        return (idetape_mtioctop (drive,MTBSF,1));
                case MTBSF:
                        if (!tape->capabilities.sprev)
                                return (-EIO);
                        idetape_create_space_cmd (&pc,-(mt_count+count),IDETAPE_SPACE_OVER_FILEMARK);
                        return (idetape_queue_pc_tail (drive,&pc));
                case MTBSFM:
                        if (!tape->capabilities.sprev)
                                return (-EIO);
                        retval=idetape_mtioctop (drive,MTBSF,mt_count+count);
                        if (retval) return (retval);
                        return (idetape_mtioctop (drive,MTFSF,1));
                default:
                        printk ("ide-tape: MTIO operation %d not supported\n",mt_op);
                        return (-EIO);
        }
}
 
/*
 *      Our character device open function.
 */
 
int idetape_chrdev_open (struct inode *inode, struct file *filp)
 
{
        ide_drive_t *drive=idetape_chrdev.drive;
        idetape_tape_t *tape=&(drive->tape);
        unsigned long flags;
        unsigned int minor=MINOR (inode->i_rdev),allocation_length;
 
        save_flags (flags);cli ();
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_chrdev_open\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        if (minor!=0 && minor!=128) {            /* Currently supporting only one */
                restore_flags (flags);          /* tape drive */
                return (-ENXIO);
        }
 
        if (tape->busy) {
                restore_flags (flags);          /* Allowing access only through one */
                return (-EBUSY);                /* one file descriptor */
        }
 
        tape->busy=1;
        restore_flags (flags);
 
        allocation_length=tape->data_buffer_size;
        if (tape->data_buffer_size % IDETAPE_ALLOCATION_BLOCK)
                allocation_length+=IDETAPE_ALLOCATION_BLOCK;
 
#if IDETAPE_MINIMIZE_IDLE_MEMORY_USAGE
        if (tape->data_buffer == NULL)
                tape->data_buffer=kmalloc (allocation_length,GFP_KERNEL);
        if (tape->data_buffer == NULL)
                goto sorry;
        if (tape->merge_buffer == NULL)
                tape->merge_buffer=kmalloc (allocation_length,GFP_KERNEL);
        if (tape->merge_buffer == NULL) {
                kfree (tape->data_buffer);
        sorry:
                printk ("ide-tape: FATAL - Can not allocate continuous buffer of %d bytes\n",allocation_length);
                tape->busy=0;
                return (-EIO);
        }
#endif /* IDETAPE_MINIMIZE_IDLE_MEMORY_USAGE */
 
        if (!tape->block_address_valid) {
                if (idetape_rewind_tape (drive)) {
                        printk ("ide-tape: Rewinding tape failed\n");
                        tape->busy=0;
                        return (-EIO);
                }
        }
 
        return (0);
}
 
/*
 *      Our character device release function.
 */
 
void idetape_chrdev_release (struct inode *inode, struct file *filp)
 
{
        ide_drive_t *drive=idetape_chrdev.drive;
        idetape_tape_t *tape=&(drive->tape);
        unsigned int minor=MINOR (inode->i_rdev);
        idetape_packet_command_t pc;
        unsigned long flags;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_chrdev_release\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        if (tape->chrdev_direction == idetape_direction_write) {
                idetape_empty_write_pipeline (drive);
                idetape_create_write_filemark_cmd (&pc,1);      /* Write a filemark */
                if (idetape_queue_pc_tail (drive,&pc))
                        printk ("ide-tape: Couldn't write a filemark\n");
        }
 
        if (tape->chrdev_direction == idetape_direction_read) {
                if (minor < 128)
                        idetape_discard_read_pipeline (drive);
                else
                        idetape_wait_for_pipeline (drive);
        }
 
        if (minor < 128)
                if (idetape_rewind_tape (drive))
                        printk ("ide-tape: Rewinding tape failed\n");
 
#if IDETAPE_MINIMIZE_IDLE_MEMORY_USAGE
        kfree (tape->data_buffer);
        tape->data_buffer=NULL;
        if (!tape->merge_buffer_size) {
                kfree (tape->merge_buffer);
                tape->merge_buffer=NULL;
        }
#endif /* IDETAPE_MINIMIZE_IDLE_MEMORY_USAGE */
 
        save_flags (flags);cli ();
        tape->busy=0;
        restore_flags (flags);
 
        return;
}
 
/*
 *      idetape_position_tape positions the tape to the requested block
 *      using the LOCATE packet command. A READ POSITION command is then
 *      issued to check where we are positioned.
 *
 *      Like all higher level operations, we queue the commands at the tail
 *      of the request queue and wait for their completion.
 *
 */
 
int idetape_position_tape (ide_drive_t *drive,unsigned long block)
 
{
        int retval;
        idetape_packet_command_t pc;
 
        idetape_create_locate_cmd (&pc,block,0);
        retval=idetape_queue_pc_tail (drive,&pc);
        if (retval!=0) return (retval);
 
        idetape_create_read_position_cmd (&pc);
        pc.buffer=pc.temp_buffer;
        pc.buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc.current_position=pc.temp_buffer;
        return (idetape_queue_pc_tail (drive,&pc));
}
 
/*
 *      Rewinds the tape to the Beginning Of the current Partition (BOP).
 *
 *      We currently support only one partition.
 */
 
int idetape_rewind_tape (ide_drive_t *drive)
 
{
        int retval;
        idetape_packet_command_t pc;
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_rewind_tape\n");
#endif /* IDETAPE_DEBUG_LOG */  
 
        idetape_create_rewind_cmd (&pc);
        retval=idetape_queue_pc_tail (drive,&pc);
        if (retval) return (retval);
 
        idetape_create_read_position_cmd (&pc);
        pc.buffer=pc.temp_buffer;
        pc.buffer_size=IDETAPE_TEMP_BUFFER_SIZE;
        pc.current_position=pc.temp_buffer;
        return (idetape_queue_pc_tail (drive,&pc));
}
 
int idetape_flush_tape_buffers (ide_drive_t *drive)
 
{
        idetape_packet_command_t pc;
 
        idetape_create_write_filemark_cmd (&pc,0);
        return (idetape_queue_pc_tail (drive,&pc));
}
 
/*
 *      Pipeline related functions
 */
 
/*
 *      idetape_kmalloc_stage uses kmalloc to allocate a pipeline stage,
 *      along with all the necessary small buffers which together make
 *      a buffer of size tape->data_buffer_size or a bit more, in case
 *      it is not a multiply of IDETAPE_ALLOCATION_BLOCK (it isn't ...).
 *
 *      Returns a pointer to the new allocated stage, or NULL if we
 *      can't (or don't want to, in case we already have too many stages)
 *      allocate a stage.
 *
 *      Pipeline stages are optional and are used to increase performance.
 *      If we can't allocate them, we'll manage without them.
 */
 
idetape_pipeline_stage_t *idetape_kmalloc_stage (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_pipeline_stage_t *new_stage;
        idetape_buffer_head_t *prev_bh,*bh;
        int buffers_num,i;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_kmalloc_stage\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        if (tape->current_number_of_stages>=tape->max_number_of_stages) {
                return (NULL);
        }
 
        new_stage=(idetape_pipeline_stage_t *) kmalloc (sizeof (idetape_pipeline_stage_t),GFP_KERNEL);
        if (new_stage==NULL)
                return (NULL);
 
        new_stage->next=new_stage->prev=NULL;
 
        buffers_num=tape->data_buffer_size / IDETAPE_ALLOCATION_BLOCK;
        if (tape->data_buffer_size % IDETAPE_ALLOCATION_BLOCK)
                buffers_num++;
 
        prev_bh=new_stage->bh=(idetape_buffer_head_t *) kmalloc (sizeof (idetape_buffer_head_t),GFP_KERNEL);
        if (new_stage->bh==NULL) {
                idetape_kfree_stage (new_stage);
                return (NULL);
        }
        new_stage->bh->next=NULL;
 
        new_stage->bh->data=kmalloc (IDETAPE_ALLOCATION_BLOCK,GFP_KERNEL);
        if (new_stage->bh->data==NULL) {
                idetape_kfree_stage (new_stage);
                return (NULL);
        }
 
        for (i=1;i<buffers_num;i++) {
                bh=(idetape_buffer_head_t *) kmalloc (sizeof (idetape_buffer_head_t),GFP_KERNEL);
                if (bh==NULL) {
                        idetape_kfree_stage (new_stage);
                        return (NULL);
                }
                bh->next=NULL;
                prev_bh->next=bh;
                bh->data=kmalloc (IDETAPE_ALLOCATION_BLOCK,GFP_KERNEL);
                if (bh->data == NULL) {
                        idetape_kfree_stage (new_stage);
                        return (NULL);
                }
                prev_bh=bh;
        }
        return (new_stage);
}
 
/*
 *      idetape_kfree_stage calls kfree to completely free a stage, along with
 *      its related buffers.
 */
 
void idetape_kfree_stage (idetape_pipeline_stage_t *stage)
 
{
        idetape_buffer_head_t *prev_bh,*bh;
 
        if (stage == NULL)
                return;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_kfree_stage\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        bh=stage->bh;
 
        while (bh != NULL) {
                prev_bh=bh;
                if (bh->data != NULL)
                        kfree (bh->data);
                bh=bh->next;
                kfree (prev_bh);
        }
 
        kfree (stage);
        return;
}
 
/*
 *      idetape_copy_buffer_from_stage and idetape_copy_buffer_to_stage
 *      copy data from/to the small buffers into/from a continuous buffer.
 */
 
void idetape_copy_buffer_from_stage (idetape_pipeline_stage_t *stage,char *buffer)
 
{
        idetape_buffer_head_t *bh;
        char *ptr;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_copy_buffer_from_stage\n");
#endif /* IDETAPE_DEBUG_LOG */
#if IDETAPE_DEBUG_BUGS
        if (buffer == NULL) {
                printk ("ide-tape: bug: buffer is null in copy_buffer_from_stage\n");
                return;
        }
#endif /* IDETAPE_DEBUG_BUGS */
 
        ptr=buffer;
        bh=stage->bh;
 
        while (bh != NULL) {
#if IDETAPE_DEBUG_BUGS
                if (bh->data == NULL) {
                        printk ("ide-tape: bug: bh->data is null\n");
                        return;
                }
#endif /* IDETAPE_DEBUG_BUGS */
                memcpy (ptr,bh->data,IDETAPE_ALLOCATION_BLOCK);
                bh=bh->next;
                ptr=ptr+IDETAPE_ALLOCATION_BLOCK;
        }
        return;
}
 
/*
 *      Here we copy a continuous data buffer to the various small buffers
 *      in the pipeline stage.
 */
 
void idetape_copy_buffer_to_stage (idetape_pipeline_stage_t *stage,char *buffer)
 
{
        idetape_buffer_head_t *bh;
        char *ptr;
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_copy_buffer_to_stage\n");
#endif /* IDETAPE_DEBUG_LOG */
#if IDETAPE_DEBUG_BUGS
        if (buffer == NULL) {
                printk ("ide-tape: bug: buffer is null in copy_buffer_to_stage\n");
                return;
        }
#endif /* IDETAPE_DEBUG_BUGS */
 
        ptr=buffer;
        bh=stage->bh;
 
        while (bh != NULL) {
#if IDETAPE_DEBUG_BUGS
                if (bh->data == NULL) {
                        printk ("ide-tape: bug: bh->data is null\n");
                        return;
                }
#endif /* IDETAPE_DEBUG_BUGS */
                memcpy (bh->data,ptr,IDETAPE_ALLOCATION_BLOCK);
                bh=bh->next;
                ptr=ptr+IDETAPE_ALLOCATION_BLOCK;
        }
        return;
}
 
/*
 *      idetape_increase_max_pipeline_stages is a part of the feedback
 *      loop which tries to find the optimum number of stages. In the
 *      feedback loop, we are starting from a minimum maximum number of
 *      stages, and if we sense that the pipeline is empty, we try to
 *      increase it, until we reach the user compile time memory limit.
 */
 
void idetape_increase_max_pipeline_stages (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_increase_max_pipeline_stages\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        tape->max_number_of_stages+=IDETAPE_INCREASE_STAGES_RATE;
 
        if (tape->max_number_of_stages >= IDETAPE_MAX_PIPELINE_STAGES)
                tape->max_number_of_stages = IDETAPE_MAX_PIPELINE_STAGES;
 
#if IDETAPE_DEBUG_LOG
        printk ("Maximum number of stages: %d\n",tape->max_number_of_stages);
#endif /* IDETAPE_DEBUG_LOG */
 
        return;
}
 
/*
 *      idetape_add_stage_tail adds a new stage at the end of the pipeline.
 *
 *      Caller should disable interrupts, if necessary.
 */
 
void idetape_add_stage_tail (ide_drive_t *drive,idetape_pipeline_stage_t *stage)
 
{
        idetape_tape_t *tape=&(drive->tape);
 
#if IDETAPE_DEBUG_LOG
                printk ("Reached idetape_add_stage_tail\n");
#endif /* IDETAPE_DEBUG_LOG */
 
        stage->next=NULL;
        stage->prev=tape->last_stage;
        if (tape->last_stage != NULL)
                tape->last_stage->next=stage;
        else
                tape->first_stage=tape->next_stage=stage;
        tape->last_stage=stage;
        if (tape->next_stage == NULL)
                tape->next_stage=tape->last_stage;
        tape->current_number_of_stages++;
}
 
/*
 *      idetape_remove_stage_head removes tape->first_stage from the pipeline.
 *
 *      Again, caller should avoid race conditions.
 */
 
void idetape_remove_stage_head (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_pipeline_stage_t *stage;
 
#if IDETAPE_DEBUG_LOG
                printk ("Reached idetape_remove_stage_head\n");
#endif /* IDETAPE_DEBUG_LOG */
#if IDETAPE_DEBUG_BUGS
        if (tape->first_stage == NULL) {
                printk ("ide-tape: bug: tape->first_stage is NULL\n");
                return;
        }
        if (tape->active_stage == tape->first_stage) {
                printk ("ide-tape: bug: Trying to free our active pipeline stage\n");
                return;
        }
#endif /* IDETAPE_DEBUG_BUGS */
        stage=tape->first_stage;
        tape->first_stage=stage->next;
        idetape_kfree_stage (stage);
        tape->current_number_of_stages--;
        if (tape->first_stage == NULL) {
                tape->last_stage=NULL;
#if IDETAPE_DEBUG_BUGS
                if (tape->next_stage != NULL)
                        printk ("ide-tape: bug: tape->next_stage != NULL\n");
                if (tape->current_number_of_stages)
                        printk ("ide-tape: bug: current_number_of_stages should be 0 now\n");
#endif /* IDETAPE_DEBUG_BUGS */
        }
}
 
/*
 *      idetape_insert_pipeline_into_queue is used to start servicing the
 *      pipeline stages, starting from tape->next_stage.
 */
 
void idetape_insert_pipeline_into_queue (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
 
        if (tape->next_stage == NULL)
                return;
 
        if (tape->active_data_request == NULL) {
                idetape_active_next_stage (drive);
                (void) (ide_do_drive_cmd (drive,tape->active_data_request,ide_end));
                return;
        }
}
 
/*
 *      idetape_active_next_stage will declare the next stage as "active".
 */
 
void idetape_active_next_stage (ide_drive_t *drive)
 
{
        idetape_tape_t *tape=&(drive->tape);
        idetape_pipeline_stage_t *stage=tape->next_stage;
        struct request *rq=&(stage->rq);
 
#if IDETAPE_DEBUG_LOG
        printk ("Reached idetape_active_next_stage\n");
#endif /* IDETAPE_DEBUG_LOG */
#if IDETAPE_DEBUG_BUGS
        if (stage == NULL) {
                printk ("ide-tape: bug: Trying to activate a non existing stage\n");
                return;
        }
#endif /* IDETAPE_DEBUG_BUGS */ 
        if (rq->cmd == IDETAPE_WRITE_REQUEST)
                idetape_copy_buffer_from_stage (stage,tape->data_buffer);
 
        rq->buffer=tape->data_buffer;
        tape->active_data_request=rq;
        tape->active_stage=stage;
        tape->next_stage=stage->next;
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [block/] [ide-tape.c] - Blame information for rev 1772

Line No.	Rev	Author	Line
1	1626	jcastillo	`/*`
2			`* linux/drivers/block/ide-tape.c Version 1.91 May 21, 1998`
3			`*`
4			`* Copyright (C) 1995, 1996 Gadi Oxman <gadio@netvision.net.il>`
5			`*`
6			`* This driver was constructed as a student project in the software laboratory`
7			`* of the faculty of electrical engineering in the Technion - Israel's`
8			`* Institute Of Technology, with the guide of Avner Lottem and Dr. Ilana David.`
9			`*`
10			`* It is hereby placed under the terms of the GNU general public license.`
11			`* (See linux/COPYING).`
12			`*/`
13
14			`/*`
15			`* IDE ATAPI streaming tape driver.`
16			`*`
17			`* This driver is a part of the Linux ide driver and works in co-operation`
18			`* with linux/drivers/block/ide.c.`
19			`*`
20			`* The driver, in co-operation with ide.c, basically traverses the`
21			`* request-list for the block device interface. The character device`
22			`* interface, on the other hand, creates new requests, adds them`
23			`* to the request-list of the block device, and waits for their completion.`
24			`*`
25			`* Pipelined operation mode is now supported on both reads and writes.`
26			`*`
27			`* The block device major and minor numbers are determined from the`
28			`* tape's relative position in the ide interfaces, as explained in ide.c.`
29			`*`
30			`* The character device interface consists of two devices:`
31			`*`
32			`* ht0 major=37,minor=0 first IDE tape, rewind on close.`
33			`* nht0 major=37,minor=128 first IDE tape, no rewind on close.`
34			`*`
35			`* Run /usr/src/linux/scripts/MAKEDEV.ide to create the above entries.`
36			`* We currently support only one ide tape drive.`
37			`*`
38			`* The general magnetic tape commands compatible interface, as defined by`
39			`* include/linux/mtio.h, is accessible through the character device.`
40			`*`