lkml.org 
[lkml]   [2001]   [Jan]   [11]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH] improved IDE OnStream support for linux 2.4

    Its cool with me...

    On Thu, 11 Jan 2001, Marcel J.E. Mol wrote:

    > Hi guys,
    >
    > Below is a patch to fix some problems in the OnStream tape drive support
    > in ide-tape.c.
    >
    > - It implements Early Warning (e.g. retuns ENOSPC) for reaching end-of-tape.
    > This fixes a real nasty problem when writing beyond end-of-tape, rendering
    > the 'backup' more ore less useless.
    > - Includes a workaround for a read error around block 3000.
    > - The module use counts were gone allowing to remove the module while it was
    > still busy.
    > - Support for other IDE OnStream tape drives (e.g. DI-50).
    > - A few cosmetic fixes to improve readability.
    >
    > Patch is against linux 2.4.0-prerelease.
    >
    > Andre: a patch for 2.2.18 is almost ready to be included in the ide patchset.
    >
    > -Marcel
    > --
    > ======-------- Marcel J.E. Mol MESA Consulting B.V.
    > =======--------- ph. +31-(0)6-54724868 P.O. Box 112
    > =======--------- marcel@mesa.nl 2630 AC Nootdorp
    > __==== www.mesa.nl ---____U_n_i_x______I_n_t_e_r_n_e_t____ The Netherlands ____
    > They couldn't think of a number, so they gave me a name!
    > -- Rupert Hine http://www.ruperthine.com/
    >
    > --- linux/drivers/ide/ide-tape.c.org Wed Jan 3 00:13:40 2001
    > +++ linux/drivers/ide/ide-tape.c Thu Jan 11 22:41:36 2001
    > @@ -1,5 +1,5 @@
    > /*
    > - * linux/drivers/ide/ide-tape.c Version 1.16f Dec 15, 1999
    > + * linux/drivers/ide/ide-tape.c Version 1.17 Jan, 2001
    > *
    > * Copyright (C) 1995 - 1999 Gadi Oxman <gadio@netvision.net.il>
    > *
    > @@ -274,6 +274,18 @@
    > * this section correctly, a hypothetical and unwanted situation
    > * is being described)
    > * Ver 1.16f Dec 15 99 Change place of the secondary OnStream header frames.
    > + * Ver 1.17 Nov 2000 / Jan 2001 Marcel Mol, marcel@mesa.nl
    > + * - Add idetape_onstream_mode_sense_tape_parameter_page
    > + * function to get tape capacity in frames: tape->capacity.
    > + * - Add support for DI-50 drives( or any DI- drive).
    > + * - 'workaround' for read error/blank block arround block 3000.
    > + * - Implement Early warning for end of media for Onstream.
    > + * - Cosmetic code changes for readability.
    > + * - Idetape_position_tape should not use SKIP bit during
    > + * Onstream read recovery.
    > + * - Add capacity, logical_blk_num and first/last_frame_position
    > + * to /proc/ide/hd?/settings.
    > + * - Module use count was gone in the Linux 2.4 driver.
    > *
    > *
    > * Here are some words from the first releases of hd.c, which are quoted
    > @@ -384,7 +396,7 @@
    > * sharing a (fast) ATA-2 disk with any (slow) new ATAPI device.
    > */
    >
    > -#define IDETAPE_VERSION "1.16f"
    > +#define IDETAPE_VERSION "1.17"
    >
    > #include <linux/config.h>
    > #include <linux/module.h>
    > @@ -421,7 +433,11 @@
    > #define OS_CONFIG_PARTITION (0xff)
    > #define OS_DATA_PARTITION (0)
    > #define OS_PARTITION_VERSION (1)
    > +#define OS_EW 300
    > +#define OS_ADR_MINREV 2
    >
    > +#define OS_DATA_STARTFRAME1 20
    > +#define OS_DATA_ENDFRAME1 2980
    > /*
    > * partition
    > */
    > @@ -512,12 +528,33 @@
    > } os_header_t;
    >
    > /*
    > + * OnStream Tape Parameters Page
    > + */
    > +typedef struct {
    > + unsigned page_code :6; /* Page code - Should be 0x2b */
    > + unsigned reserved1_6 :1;
    > + unsigned ps :1;
    > + __u8 reserved2;
    > + __u8 density; /* kbpi */
    > + __u8 reserved3,reserved4;
    > + __u16 segtrk; /* segment of per track */
    > + __u16 trks; /* tracks per tape */
    > + __u8 reserved5,reserved6,reserved7,reserved8,reserved9,reserved10;
    > +} onstream_tape_paramtr_page_t;
    > +
    > +/*
    > * OnStream ADRL frame
    > */
    > #define OS_FRAME_SIZE (32 * 1024 + 512)
    > #define OS_DATA_SIZE (32 * 1024)
    > #define OS_AUX_SIZE (512)
    >
    > +/*
    > + * internal error codes for onstream
    > + */
    > +#define OS_PART_ERROR 2
    > +#define OS_WRITE_ERROR 1
    > +
    > #include <linux/mtio.h>
    >
    > /**************************** Tunable parameters *****************************/
    > @@ -949,6 +986,7 @@
    > int eod_frame_addr;
    > unsigned long cmd_start_time;
    > unsigned long max_cmd_time;
    > + unsigned capacity;
    >
    > /*
    > * Optimize the number of "buffer filling"
    > @@ -1157,7 +1195,7 @@
    > typedef union {
    > unsigned all :8;
    > struct {
    > - unsigned dma :1; /* Using DMA of PIO */
    > + unsigned dma :1; /* Using DMA or PIO */
    > unsigned reserved321 :3; /* Reserved */
    > unsigned reserved654 :3; /* Reserved (Tag Type) */
    > unsigned reserved7 :1; /* Reserved */
    > @@ -1287,7 +1325,9 @@
    > * by ide-tape.
    > */
    > #define IDETAPE_CAPABILITIES_PAGE 0x2a
    > +#define IDETAPE_PARAMTR_PAGE 0x2b /* onstream only */
    > #define IDETAPE_BLOCK_SIZE_PAGE 0x30
    > +#define IDETAPE_BUFFER_FILLING_PAGE 0x33
    >
    > /*
    > * Mode Parameter Header for the MODE SENSE packet command
    > @@ -1428,6 +1468,14 @@
    > #endif /* IDETAPE_DEBUG_LOG_VERBOSE */
    >
    > /*
    > + * Function declarations
    > + *
    > + */
    > +static void idetape_onstream_mode_sense_tape_parameter_page(ide_drive_t *drive, int debug);
    > +static int idetape_chrdev_release (struct inode *inode, struct file *filp);
    > +static void idetape_write_release (struct inode *inode);
    > +
    > +/*
    > * Too bad. The drive wants to send us data which we are not ready to accept.
    > * Just throw it away.
    > */
    > @@ -1452,7 +1500,8 @@
    > #endif /* IDETAPE_DEBUG_BUGS */
    > count = IDE_MIN (bh->b_size - atomic_read(&bh->b_count), bcount);
    > atapi_input_bytes (drive, bh->b_data + atomic_read(&bh->b_count), count);
    > - bcount -= count; atomic_add(count, &bh->b_count);
    > + bcount -= count;
    > + atomic_add(count, &bh->b_count);
    > if (atomic_read(&bh->b_count) == bh->b_size) {
    > bh = bh->b_reqnext;
    > if (bh)
    > @@ -1476,7 +1525,9 @@
    > #endif /* IDETAPE_DEBUG_BUGS */
    > count = IDE_MIN (pc->b_count, bcount);
    > atapi_output_bytes (drive, pc->b_data, count);
    > - bcount -= count; pc->b_data += count; pc->b_count -= count;
    > + bcount -= count;
    > + pc->b_data += count;
    > + pc->b_count -= count;
    > if (!pc->b_count) {
    > pc->bh = bh = bh->b_reqnext;
    > if (bh) {
    > @@ -1577,20 +1628,23 @@
    > * to analyze the request sense. We currently do not utilize this
    > * information.
    > */
    > -static void idetape_analyze_error (ide_drive_t *drive,idetape_request_sense_result_t *result)
    > +static void idetape_analyze_error (ide_drive_t *drive, idetape_request_sense_result_t *result)
    > {
    > idetape_tape_t *tape = drive->driver_data;
    > idetape_pc_t *pc = tape->failed_pc;
    >
    > - tape->sense = *result;
    > - tape->sense_key = result->sense_key; tape->asc = result->asc; tape->ascq = result->ascq;
    > + tape->sense = *result;
    > + 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.
    > */
    > if (tape->debug_level >= 1)
    > - printk (KERN_INFO "ide-tape: pc = %x, sense key = %x, asc = %x, ascq = %x\n",pc->c[0],result->sense_key,result->asc,result->ascq);
    > + printk (KERN_INFO "ide-tape: pc = %x, sense key = %x, asc = %x, ascq = %x\n",
    > + pc->c[0], result->sense_key, result->asc, result->ascq);
    > #if IDETAPE_DEBUG_LOG_VERBOSE
    > if (tape->debug_level >= 1)
    > printk (KERN_INFO "ide-tape: pc = %s, sense key = %x, asc = %x, ascq = %x\n",
    > @@ -1660,7 +1714,7 @@
    > static void idetape_active_next_stage (ide_drive_t *drive)
    > {
    > idetape_tape_t *tape = drive->driver_data;
    > - idetape_stage_t *stage=tape->next_stage;
    > + idetape_stage_t *stage = tape->next_stage;
    > struct request *rq = &stage->rq;
    >
    > #if IDETAPE_DEBUG_LOG
    > @@ -1676,9 +1730,9 @@
    >
    > rq->buffer = NULL;
    > rq->bh = stage->bh;
    > - tape->active_data_request=rq;
    > - tape->active_stage=stage;
    > - tape->next_stage=stage->next;
    > + tape->active_data_request = rq;
    > + tape->active_stage = stage;
    > + tape->next_stage = stage->next;
    > }
    >
    > /*
    > @@ -1756,12 +1810,12 @@
    > return;
    > }
    > #endif /* IDETAPE_DEBUG_BUGS */
    > - stage=tape->first_stage;
    > - tape->first_stage=stage->next;
    > + stage = tape->first_stage;
    > + tape->first_stage = stage->next;
    > idetape_kfree_stage (tape, stage);
    > tape->nr_stages--;
    > if (tape->first_stage == NULL) {
    > - tape->last_stage=NULL;
    > + tape->last_stage = NULL;
    > #if IDETAPE_DEBUG_BUGS
    > if (tape->next_stage != NULL)
    > printk (KERN_ERR "ide-tape: bug: tape->next_stage != NULL\n");
    > @@ -1821,12 +1875,12 @@
    > }
    > #endif
    > if (tape->onstream && !tape->raw) {
    > - if (tape->first_frame_position == 0xba4) {
    > + if (tape->first_frame_position == OS_DATA_ENDFRAME1) {
    > #if ONSTREAM_DEBUG
    > - if (tape->debug_level >= 2)
    > - printk("ide-tape: %s: skipping over config parition..\n", tape->name);
    > + if (tape->debug_level >= 2)
    > + printk("ide-tape: %s: skipping over config parition..\n", tape->name);
    > #endif
    > - tape->onstream_write_error = 2;
    > + tape->onstream_write_error = OS_PART_ERROR;
    > if (tape->sem)
    > up(tape->sem);
    > }
    > @@ -1839,7 +1893,7 @@
    > if (tape->onstream && !tape->raw && error == IDETAPE_ERROR_GENERAL && tape->sense.sense_key == 3) {
    > clear_bit (IDETAPE_PIPELINE_ERROR, &tape->flags);
    > printk(KERN_ERR "ide-tape: %s: write error, enabling error recovery\n", tape->name);
    > - tape->onstream_write_error = 1;
    > + tape->onstream_write_error = OS_WRITE_ERROR;
    > remove_stage = 0;
    > tape->nr_pending_stages++;
    > tape->next_stage = tape->first_stage;
    > @@ -1883,11 +1937,11 @@
    > printk (KERN_INFO "ide-tape: Reached idetape_request_sense_callback\n");
    > #endif /* IDETAPE_DEBUG_LOG */
    > if (!tape->pc->error) {
    > - idetape_analyze_error (drive,(idetape_request_sense_result_t *) tape->pc->buffer);
    > - idetape_end_request (1,HWGROUP (drive));
    > + idetape_analyze_error (drive, (idetape_request_sense_result_t *) tape->pc->buffer);
    > + idetape_end_request (1, HWGROUP (drive));
    > } else {
    > printk (KERN_ERR "ide-tape: Error in REQUEST SENSE itself - Aborting request!\n");
    > - idetape_end_request (0,HWGROUP (drive));
    > + idetape_end_request (0, HWGROUP (drive));
    > }
    > return ide_stopped;
    > }
    > @@ -1980,7 +2034,7 @@
    > idetape_status_reg_t status;
    > idetape_bcount_reg_t bcount;
    > idetape_ireason_reg_t ireason;
    > - idetape_pc_t *pc=tape->pc;
    > + idetape_pc_t *pc = tape->pc;
    >
    > unsigned int temp;
    > unsigned long cmd_time;
    > @@ -2011,7 +2065,7 @@
    > */
    > set_bit (PC_DMA_ERROR, &pc->flags);
    > } else if (!status.b.check) {
    > - pc->actually_transferred=pc->request_transfer;
    > + pc->actually_transferred = pc->request_transfer;
    > idetape_update_buffers (pc);
    > }
    > #if IDETAPE_DEBUG_LOG
    > @@ -2064,7 +2118,7 @@
    > return ide_stopped;
    > }
    > if (tape->failed_pc == pc)
    > - tape->failed_pc=NULL;
    > + tape->failed_pc = NULL;
    > return pc->callback(drive); /* Command finished - Call the callback function */
    > }
    > #ifdef CONFIG_BLK_DEV_IDEDMA
    > @@ -2075,9 +2129,9 @@
    > return ide_do_reset (drive);
    > }
    > #endif /* CONFIG_BLK_DEV_IDEDMA */
    > - bcount.b.high=IN_BYTE (IDE_BCOUNTH_REG); /* Get the number of bytes to transfer */
    > - bcount.b.low=IN_BYTE (IDE_BCOUNTL_REG); /* on this interrupt */
    > - ireason.all=IN_BYTE (IDE_IREASON_REG);
    > + bcount.b.high = IN_BYTE (IDE_BCOUNTH_REG); /* Get the number of bytes to transfer */
    > + bcount.b.low = IN_BYTE (IDE_BCOUNTL_REG); /* on this interrupt */
    > + ireason.all = IN_BYTE (IDE_IREASON_REG);
    >
    > if (ireason.b.cod) {
    > printk (KERN_ERR "ide-tape: CoD != 0 in idetape_pc_intr\n");
    > @@ -2093,8 +2147,8 @@
    > if ( temp > pc->request_transfer) {
    > if (temp > pc->buffer_size) {
    > printk (KERN_ERR "ide-tape: The tape wants to send us more data than expected - discarding data\n");
    > - idetape_discard_data (drive,bcount.all);
    > - ide_set_handler (drive,&idetape_pc_intr,IDETAPE_WAIT_CMD,NULL);
    > + idetape_discard_data (drive, bcount.all);
    > + ide_set_handler (drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);
    > return ide_started;
    > }
    > #if IDETAPE_DEBUG_LOG
    > @@ -2114,13 +2168,13 @@
    > else
    > atapi_input_bytes (drive,pc->current_position,bcount.all); /* Read the current buffer */
    > }
    > - pc->actually_transferred+=bcount.all; /* Update the current position */
    > + pc->actually_transferred += bcount.all; /* Update the current position */
    > pc->current_position+=bcount.all;
    > #if IDETAPE_DEBUG_LOG
    > if (tape->debug_level >= 2)
    > printk(KERN_INFO "ide-tape: [cmd %x] transferred %d bytes on that interrupt\n", pc->c[0], bcount.all);
    > #endif
    > - ide_set_handler (drive,&idetape_pc_intr,IDETAPE_WAIT_CMD,NULL); /* And set the interrupt handler again */
    > + ide_set_handler (drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL); /* And set the interrupt handler again */
    > return ide_started;
    > }
    >
    > @@ -2178,7 +2232,7 @@
    > printk (KERN_ERR "ide-tape: Strange, packet command initiated yet DRQ isn't asserted\n");
    > return startstop;
    > }
    > - ireason.all=IN_BYTE (IDE_IREASON_REG);
    > + ireason.all = IN_BYTE (IDE_IREASON_REG);
    > while (retries-- && (!ireason.b.cod || ireason.b.io)) {
    > printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while issuing a packet command, retrying\n");
    > udelay(100);
    > @@ -2203,7 +2257,7 @@
    > {
    > idetape_tape_t *tape = drive->driver_data;
    > idetape_bcount_reg_t bcount;
    > - int dma_ok=0;
    > + int dma_ok = 0;
    >
    > #if IDETAPE_DEBUG_BUGS
    > if (tape->pc->c[0] == IDETAPE_REQUEST_SENSE_CMD && pc->c[0] == IDETAPE_REQUEST_SENSE_CMD) {
    > @@ -2212,8 +2266,8 @@
    > #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 */
    > + tape->failed_pc = pc;
    > + tape->pc = pc; /* Set the current packet command */
    >
    > if (pc->retries > IDETAPE_MAX_PC_RETRIES || test_bit (PC_ABORT, &pc->flags)) {
    > /*
    > @@ -2223,24 +2277,25 @@
    > * example).
    > */
    > if (!test_bit (PC_ABORT, &pc->flags)) {
    > - if (!(pc->c[0] == 0 && tape->sense_key == 2 && tape->asc == 4 && (tape->ascq == 1 || tape->ascq == 8))) {
    > + if (!(pc->c[0] == IDETAPE_TEST_UNIT_READY_CMD && tape->sense_key == 2 &&
    > + tape->asc == 4 && (tape->ascq == 1 || tape->ascq == 8))) {
    > printk (KERN_ERR "ide-tape: %s: I/O error, pc = %2x, key = %2x, asc = %2x, ascq = %2x\n",
    > tape->name, pc->c[0], tape->sense_key, tape->asc, tape->ascq);
    > - if (tape->onstream && pc->c[0] == 8 && tape->sense_key == 3 && tape->asc == 0x11) /* AJN-1: 11 should be 0x11 */
    > + if (tape->onstream && pc->c[0] == IDETAPE_READ_CMD && tape->sense_key == 3 && tape->asc == 0x11) /* AJN-1: 11 should be 0x11 */
    > printk(KERN_ERR "ide-tape: %s: enabling read error recovery\n", tape->name);
    > }
    > pc->error = IDETAPE_ERROR_GENERAL; /* Giving up */
    > }
    > - tape->failed_pc=NULL;
    > + tape->failed_pc = NULL;
    > return pc->callback(drive);
    > }
    > #if IDETAPE_DEBUG_LOG
    > if (tape->debug_level >= 2)
    > - printk (KERN_INFO "ide-tape: Retry number - %d\n",pc->retries);
    > + printk (KERN_INFO "ide-tape: Retry number - %d\n", pc->retries);
    > #endif /* IDETAPE_DEBUG_LOG */
    >
    > pc->retries++;
    > - pc->actually_transferred=0; /* We haven't transferred any data yet */
    > + 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 */
    >
    > @@ -2250,15 +2305,15 @@
    > (void) HWIF(drive)->dmaproc(ide_dma_off, drive);
    > }
    > if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
    > - dma_ok=!HWIF(drive)->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
    > + dma_ok = !HWIF(drive)->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
    > #endif /* CONFIG_BLK_DEV_IDEDMA */
    >
    > if (IDE_CONTROL_REG)
    > - OUT_BYTE (drive->ctl,IDE_CONTROL_REG);
    > - OUT_BYTE (dma_ok ? 1:0,IDE_FEATURE_REG); /* Use PIO/DMA */
    > - OUT_BYTE (bcount.b.high,IDE_BCOUNTH_REG);
    > - OUT_BYTE (bcount.b.low,IDE_BCOUNTL_REG);
    > - OUT_BYTE (drive->select.all,IDE_SELECT_REG);
    > + OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
    > + OUT_BYTE (dma_ok ? 1 : 0, IDE_FEATURE_REG); /* Use PIO/DMA */
    > + OUT_BYTE (bcount.b.high, IDE_BCOUNTH_REG);
    > + OUT_BYTE (bcount.b.low, IDE_BCOUNTL_REG);
    > + OUT_BYTE (drive->select.all, IDE_SELECT_REG);
    > #ifdef CONFIG_BLK_DEV_IDEDMA
    > if (dma_ok) { /* Begin DMA, if necessary */
    > set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
    > @@ -2287,7 +2342,7 @@
    > printk (KERN_INFO "ide-tape: Reached idetape_pc_callback\n");
    > #endif /* IDETAPE_DEBUG_LOG */
    >
    > - idetape_end_request (tape->pc->error ? 0:1, HWGROUP(drive));
    > + idetape_end_request (tape->pc->error ? 0 : 1, HWGROUP(drive));
    > return ide_stopped;
    > }
    >
    > @@ -2333,7 +2388,7 @@
    > if (tape->debug_level >= 1)
    > printk(KERN_INFO "ide-tape: buffer fill callback, %d/%d\n", tape->cur_frames, tape->max_frames);
    > #endif
    > - idetape_end_request (tape->pc->error ? 0:1, HWGROUP(drive));
    > + idetape_end_request (tape->pc->error ? 0 : 1, HWGROUP(drive));
    > return ide_stopped;
    > }
    >
    > @@ -2344,7 +2399,7 @@
    >
    > pc = idetape_next_pc_storage (drive);
    > rq = idetape_next_rq_storage (drive);
    > - idetape_create_mode_sense_cmd (pc, 0x33);
    > + idetape_create_mode_sense_cmd (pc, IDETAPE_BUFFER_FILLING_PAGE);
    > pc->callback = idetape_onstream_buffer_fill_callback;
    > idetape_queue_pc_head (drive, pc, rq);
    > }
    > @@ -2564,7 +2619,7 @@
    > * We do not support buffer cache originated requests.
    > */
    > printk (KERN_NOTICE "ide-tape: %s: Unsupported command in request queue (%d)\n", drive->name, rq->cmd);
    > - ide_end_request (0,HWGROUP (drive)); /* Let the common code handle it */
    > + ide_end_request (0, HWGROUP (drive)); /* Let the common code handle it */
    > return ide_stopped;
    > }
    >
    > @@ -2578,7 +2633,7 @@
    > if (postponed_rq != NULL)
    > if (rq != postponed_rq) {
    > printk (KERN_ERR "ide-tape: ide-tape.c bug - Two DSC requests were queued\n");
    > - idetape_end_request (0,HWGROUP (drive));
    > + idetape_end_request (0, HWGROUP (drive));
    > return ide_stopped;
    > }
    > #endif /* IDETAPE_DEBUG_BUGS */
    > @@ -2624,8 +2679,15 @@
    > tape->insert_speed = tape->insert_size / 1024 * HZ / (jiffies - tape->insert_time);
    > calculate_speeds(drive);
    > if (tape->onstream && tape->max_frames &&
    > - ((rq->cmd == IDETAPE_WRITE_RQ && (tape->cur_frames == tape->max_frames || (tape->speed_control && tape->cur_frames > 5 && (tape->insert_speed > tape->max_insert_speed || (0 /* tape->cur_frames > 30 && tape->tape_still_time > 200 */))))) ||
    > - (rq->cmd == IDETAPE_READ_RQ && (tape->cur_frames == 0 || (tape->speed_control && (tape->cur_frames < tape->max_frames - 5) && tape->insert_speed > tape->max_insert_speed)) && rq->nr_sectors))) {
    > + ((rq->cmd == IDETAPE_WRITE_RQ &&
    > + ( tape->cur_frames == tape->max_frames ||
    > + ( tape->speed_control && tape->cur_frames > 5 &&
    > + (tape->insert_speed > tape->max_insert_speed ||
    > + (0 /* tape->cur_frames > 30 && tape->tape_still_time > 200 */) ) ) ) ) ||
    > + (rq->cmd == IDETAPE_READ_RQ &&
    > + ( tape->cur_frames == 0 ||
    > + ( tape->speed_control && (tape->cur_frames < tape->max_frames - 5) &&
    > + tape->insert_speed > tape->max_insert_speed ) ) && rq->nr_sectors) ) ) {
    > #if IDETAPE_DEBUG_LOG
    > if (tape->debug_level >= 4)
    > printk(KERN_INFO "ide-tape: postponing request, cmd %d, cur %d, max %d\n",
    > @@ -2672,7 +2734,7 @@
    > if (jiffies > tape->last_buffer_fill + 5 * HZ / 100)
    > tape->req_buffer_fill = 1;
    > }
    > - pc=idetape_next_pc_storage (drive);
    > + pc = idetape_next_pc_storage (drive);
    > idetape_create_read_cmd (tape, pc, rq->current_nr_sectors, rq->bh);
    > break;
    > case IDETAPE_WRITE_RQ:
    > @@ -2689,12 +2751,12 @@
    > tape->req_buffer_fill = 1;
    > calculate_speeds(drive);
    > }
    > - pc=idetape_next_pc_storage (drive);
    > + pc = idetape_next_pc_storage (drive);
    > idetape_create_write_cmd (tape, pc, rq->current_nr_sectors, rq->bh);
    > break;
    > case IDETAPE_READ_BUFFER_RQ:
    > tape->postpone_cnt = 0;
    > - pc=idetape_next_pc_storage (drive);
    > + pc = idetape_next_pc_storage (drive);
    > idetape_create_read_buffer_cmd (tape, pc, rq->current_nr_sectors, rq->bh);
    > break;
    > case IDETAPE_ABORTED_WRITE_RQ:
    > @@ -2710,7 +2772,7 @@
    > idetape_end_request (IDETAPE_ERROR_EOD, HWGROUP(drive));
    > return ide_stopped;
    > case IDETAPE_PC_RQ1:
    > - pc=(idetape_pc_t *) rq->buffer;
    > + pc = (idetape_pc_t *) rq->buffer;
    > rq->cmd = IDETAPE_PC_RQ2;
    > break;
    > case IDETAPE_PC_RQ2:
    > @@ -2718,7 +2780,7 @@
    > return ide_stopped;
    > default:
    > printk (KERN_ERR "ide-tape: bug in IDETAPE_RQ_CMD macro\n");
    > - idetape_end_request (0,HWGROUP (drive));
    > + idetape_end_request (0, HWGROUP (drive));
    > return ide_stopped;
    > }
    > return idetape_issue_packet_command (drive, pc);
    > @@ -2844,7 +2906,9 @@
    > #endif /* IDETAPE_DEBUG_BUGS */
    > count = IDE_MIN (bh->b_size - atomic_read(&bh->b_count), n);
    > copy_from_user (bh->b_data + atomic_read(&bh->b_count), buf, count);
    > - n -= count; atomic_add(count, &bh->b_count); buf += count;
    > + n -= count;
    > + atomic_add(count, &bh->b_count);
    > + buf += count;
    > if (atomic_read(&bh->b_count) == bh->b_size) {
    > bh = bh->b_reqnext;
    > if (bh)
    > @@ -2868,7 +2932,10 @@
    > #endif /* IDETAPE_DEBUG_BUGS */
    > count = IDE_MIN (tape->b_count, n);
    > copy_to_user (buf, tape->b_data, count);
    > - n -= count; tape->b_data += count; tape->b_count -= count; buf += count;
    > + n -= count;
    > + tape->b_data += count;
    > + tape->b_count -= count;
    > + buf += count;
    > if (!tape->b_count) {
    > tape->bh = bh = bh->b_reqnext;
    > if (bh) {
    > @@ -2920,10 +2987,10 @@
    > if (tape->last_stage != NULL)
    > tape->last_stage->next=stage;
    > else
    > - tape->first_stage=tape->next_stage=stage;
    > - tape->last_stage=stage;
    > + tape->first_stage = tape->next_stage=stage;
    > + tape->last_stage = stage;
    > if (tape->next_stage == NULL)
    > - tape->next_stage=tape->last_stage;
    > + tape->next_stage = tape->last_stage;
    > tape->nr_stages++;
    > tape->nr_pending_stages++;
    > spin_unlock_irqrestore(&tape->spinlock, flags);
    > @@ -2953,26 +3020,21 @@
    > par->par_desc_ver = OS_PARTITION_VERSION;
    > par->wrt_pass_cntr = htons(0xffff);
    > par->first_frame_addr = htonl(0);
    > - par->last_frame_addr = htonl(0xbb7);
    > + par->last_frame_addr = htonl(0xbb7); /* 2999 */
    > + aux->frame_seq_num = htonl(0);
    > + aux->logical_blk_num_high = htonl(0);
    > + aux->logical_blk_num = htonl(0);
    > + aux->next_mark_addr = htonl(tape->first_mark_addr);
    > } else {
    > aux->update_frame_cntr = htonl(0);
    > par->partition_num = OS_DATA_PARTITION;
    > par->par_desc_ver = OS_PARTITION_VERSION;
    > par->wrt_pass_cntr = htons(tape->wrt_pass_cntr);
    > - par->first_frame_addr = htonl(0x14);
    > - par->last_frame_addr = htonl(19239 * 24);
    > - }
    > - if (frame_type != OS_FRAME_TYPE_HEADER) {
    > + par->first_frame_addr = htonl(OS_DATA_STARTFRAME1);
    > + par->last_frame_addr = htonl(tape->capacity);
    > aux->frame_seq_num = htonl(logical_blk_num);
    > aux->logical_blk_num_high = htonl(0);
    > aux->logical_blk_num = htonl(logical_blk_num);
    > - } else {
    > - aux->frame_seq_num = htonl(0);
    > - aux->logical_blk_num_high = htonl(0);
    > - aux->logical_blk_num = htonl(0);
    > - }
    > -
    > - if (frame_type != OS_FRAME_TYPE_HEADER) {
    > dat->dat_sz = 8;
    > dat->reserved1 = 0;
    > dat->entry_cnt = 1;
    > @@ -2987,11 +3049,10 @@
    > else
    > dat->dat_list[0].flags = OS_DAT_FLAGS_DATA;
    > dat->dat_list[0].reserved = 0;
    > - } else
    > - aux->next_mark_addr = htonl(tape->first_mark_addr);
    > - aux->filemark_cnt = ntohl(tape->filemark_cnt);
    > - aux->phys_fm = ntohl(0xffffffff);
    > - aux->last_mark_addr = ntohl(tape->last_mark_addr);
    > + }
    > + aux->filemark_cnt = ntohl(tape->filemark_cnt); /* shouldn't this be htonl ?? */
    > + aux->phys_fm = ntohl(0xffffffff); /* shouldn't this be htonl ?? */
    > + aux->last_mark_addr = ntohl(tape->last_mark_addr); /* shouldn't this be htonl ?? */
    > }
    >
    > /*
    > @@ -3042,7 +3103,7 @@
    > if (result->bpu) {
    > printk (KERN_INFO "ide-tape: Block location is unknown to the tape\n");
    > clear_bit (IDETAPE_ADDRESS_VALID, &tape->flags);
    > - idetape_end_request (0,HWGROUP (drive));
    > + idetape_end_request (0, HWGROUP (drive));
    > } else {
    > #if IDETAPE_DEBUG_LOG
    > if (tape->debug_level >= 2)
    > @@ -3053,10 +3114,10 @@
    > tape->last_frame_position = ntohl (result->last_block);
    > tape->blocks_in_buffer = result->blocks_in_buffer[2];
    > set_bit (IDETAPE_ADDRESS_VALID, &tape->flags);
    > - idetape_end_request (1,HWGROUP (drive));
    > + idetape_end_request (1, HWGROUP (drive));
    > }
    > } else {
    > - idetape_end_request (0,HWGROUP (drive));
    > + idetape_end_request (0, HWGROUP (drive));
    > }
    > return ide_stopped;
    > }
    > @@ -3076,8 +3137,8 @@
    > idetape_init_pc (pc);
    > pc->c[0] = IDETAPE_WRITE_FILEMARK_CMD;
    > if (tape->onstream)
    > - pc->c[1] = 1;
    > - pc->c[4] = write_filemark;
    > + pc->c[1] = 1; /* Immed bit */
    > + pc->c[4] = write_filemark; /* not used for OnStream ?? */
    > set_bit (PC_WAIT_FOR_DSC, &pc->flags);
    > pc->callback = &idetape_pc_callback;
    > }
    > @@ -3109,7 +3170,7 @@
    > * the request to the request list without waiting for it to be serviced !
    > * In that case, we usually use idetape_queue_pc_head.
    > */
    > -static int __idetape_queue_pc_tail (ide_drive_t *drive,idetape_pc_t *pc)
    > +static int __idetape_queue_pc_tail (ide_drive_t *drive, idetape_pc_t *pc)
    > {
    > struct request rq;
    >
    > @@ -3150,7 +3211,7 @@
    > return 0;
    > if (tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2) {
    > idetape_create_load_unload_cmd (drive, &pc, IDETAPE_LU_LOAD_MASK);
    > - __idetape_queue_pc_tail(drive,&pc);
    > + __idetape_queue_pc_tail(drive, &pc);
    > idetape_create_test_unit_ready_cmd(&pc);
    > if (!__idetape_queue_pc_tail(drive, &pc))
    > return 0;
    > @@ -3169,7 +3230,8 @@
    > int rc;
    >
    > rc = __idetape_queue_pc_tail(drive, pc);
    > - if (rc) return rc;
    > + if (rc)
    > + return rc;
    > if (tape->onstream && test_bit(PC_WAIT_FOR_DSC, &pc->flags))
    > rc = idetape_wait_ready(drive, 60 * 10 * HZ); /* AJN-4: Changed from 5 to 10 minutes;
    > because retension takes approx. 8:20 with Onstream 30GB tape */
    > @@ -3182,7 +3244,7 @@
    > int rc;
    >
    > idetape_create_write_filemark_cmd(drive, &pc, 0);
    > - if ((rc = idetape_queue_pc_tail (drive,&pc)))
    > + if ((rc = idetape_queue_pc_tail (drive, &pc)))
    > return rc;
    > idetape_wait_ready(drive, 60 * 5 * HZ);
    > return 0;
    > @@ -3206,7 +3268,7 @@
    > idetape_flush_tape_buffers(drive);
    > #endif
    > idetape_create_read_position_cmd(&pc);
    > - if (idetape_queue_pc_tail (drive,&pc))
    > + if (idetape_queue_pc_tail (drive, &pc))
    > return -1;
    > position = tape->first_frame_position;
    > #ifdef NO_LONGER_REQUIRED
    > @@ -3231,12 +3293,17 @@
    > idetape_init_pc (pc);
    > pc->c[0] = IDETAPE_LOCATE_CMD;
    > if (tape->onstream)
    > - pc->c[1] = 1;
    > + pc->c[1] = 1; /* Immediate bit */
    > else
    > pc->c[1] = 2;
    > put_unaligned (htonl (block), (unsigned int *) &pc->c[3]);
    > pc->c[8] = partition;
    > if (tape->onstream)
    > + /*
    > + * Set SKIP bit.
    > + * In case of write error this will write buffered
    > + * data in the drive to this new position!
    > + */
    > pc->c[9] = skip << 7;
    > set_bit (PC_WAIT_FOR_DSC, &pc->flags);
    > pc->callback = &idetape_pc_callback;
    > @@ -3307,11 +3374,12 @@
    > __idetape_discard_read_pipeline(drive);
    > idetape_wait_ready(drive, 60 * 5 * HZ);
    > idetape_create_locate_cmd (drive, &pc, block, partition, skip);
    > - retval=idetape_queue_pc_tail (drive,&pc);
    > - if (retval) return (retval);
    > + retval = idetape_queue_pc_tail (drive, &pc);
    > + if (retval)
    > + return (retval);
    >
    > idetape_create_read_position_cmd (&pc);
    > - return (idetape_queue_pc_tail (drive,&pc));
    > + return (idetape_queue_pc_tail (drive, &pc));
    > }
    >
    > static void idetape_discard_read_pipeline (ide_drive_t *drive, int restore_position)
    > @@ -3339,7 +3407,7 @@
    > {
    > idetape_pc_t pc;
    >
    > - idetape_create_mode_sense_cmd (&pc, 0x33);
    > + idetape_create_mode_sense_cmd (&pc, IDETAPE_BUFFER_FILLING_PAGE);
    > pc.callback = idetape_onstream_buffer_fill_callback;
    > (void) idetape_queue_pc_tail(drive, &pc);
    > }
    > @@ -3447,33 +3515,41 @@
    > idetape_tape_t *tape = drive->driver_data;
    > unsigned int block;
    >
    > - if (tape->onstream_write_error == 1) {
    > - printk(KERN_ERR "ide-tape: %s: detected physical bad block at %u\n", tape->name, ntohl(tape->sense.information));
    > - block = ntohl(tape->sense.information) + 80;
    > + if (tape->onstream_write_error == OS_WRITE_ERROR) {
    > + printk(KERN_ERR "ide-tape: %s: onstream_write_error_recovery: detected physical bad block at %u, logical %u first frame %u last_frame %u bufblocks %u stages %u skipping %u frames\n",
    > + tape->name, ntohl(tape->sense.information), tape->logical_blk_num,
    > + tape->first_frame_position, tape->last_frame_position,
    > + tape->blocks_in_buffer, tape->nr_stages,
    > + (ntohl(tape->sense.command_specific) >> 16) & 0xff );
    > + block = ntohl(tape->sense.information) + ((ntohl(tape->sense.command_specific) >> 16) & 0xff);
    > idetape_update_stats(drive);
    > printk(KERN_ERR "ide-tape: %s: relocating %d buffered logical blocks to physical block %u\n", tape->name, tape->cur_frames, block);
    > +#if 0 /* isn't once enough ??? MM */
    > idetape_update_stats(drive);
    > +#endif
    > if (tape->firmware_revision_num >= 106)
    > idetape_position_tape(drive, block, 0, 1);
    > else {
    > idetape_onstream_read_back_buffer(drive);
    > idetape_position_tape(drive, block, 0, 0);
    > }
    > +#if 0 /* already done in idetape_position_tape MM */
    > idetape_read_position(drive);
    > +#endif
    > #if ONSTREAM_DEBUG
    > if (tape->debug_level >= 1)
    > printk(KERN_ERR "ide-tape: %s: positioning complete, cur_frames %d, pos %d, tape pos %d\n", tape->name, tape->cur_frames, tape->first_frame_position, tape->last_frame_position);
    > #endif
    > - } else if (tape->onstream_write_error == 2) {
    > + } else if (tape->onstream_write_error == OS_PART_ERROR) {
    > #if ONSTREAM_DEBUG
    > if (tape->debug_level >= 1)
    > printk(KERN_INFO "ide-tape: %s: skipping over config partition\n", tape->name);
    > #endif
    > idetape_flush_tape_buffers(drive);
    > block = idetape_read_position(drive);
    > - if (block != 0xba4)
    > - printk(KERN_ERR "ide-tape: warning, current position %d, expected %d\n", block, 0xba4);
    > - idetape_position_tape(drive, 0xbb8, 0, 0);
    > + if (block != OS_DATA_ENDFRAME1)
    > + printk(KERN_ERR "ide-tape: warning, current position %d, expected %d\n", block, OS_DATA_ENDFRAME1);
    > + idetape_position_tape(drive, 0xbb8, 0, 0); /* 3000 */
    > }
    > tape->onstream_write_error = 0;
    > }
    > @@ -3572,48 +3648,48 @@
    > return 1;
    > }
    > if (rq->errors == IDETAPE_ERROR_GENERAL) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, read error\n", tape->name);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, read error\n", tape->name, tape->first_frame_position);
    > return 0;
    > }
    > if (rq->errors == IDETAPE_ERROR_EOD) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, eod\n", tape->name);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, eod\n", tape->name, tape->first_frame_position);
    > return 0;
    > }
    > if (ntohl(aux->format_id) != 0) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, format_id %u\n", tape->name, ntohl(aux->format_id));
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, format_id %u\n", tape->name, tape->first_frame_position, ntohl(aux->format_id));
    > return 0;
    > }
    > if (memcmp(aux->application_sig, tape->application_sig, 4) != 0) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, incorrect application signature\n", tape->name);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, incorrect application signature\n", tape->name, tape->first_frame_position);
    > return 0;
    > }
    > if (aux->frame_type != OS_FRAME_TYPE_DATA &&
    > aux->frame_type != OS_FRAME_TYPE_EOD &&
    > aux->frame_type != OS_FRAME_TYPE_MARKER) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, frame type %x\n", tape->name, aux->frame_type);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, frame type %x\n", tape->name, tape->first_frame_position, aux->frame_type);
    > return 0;
    > }
    > if (par->partition_num != OS_DATA_PARTITION) {
    > if (!tape->linux_media || tape->linux_media_version != 2) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, partition num %d\n", tape->name, par->partition_num);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, partition num %d\n", tape->name, tape->first_frame_position, par->partition_num);
    > return 0;
    > }
    > }
    > if (par->par_desc_ver != OS_PARTITION_VERSION) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, partition version %d\n", tape->name, par->par_desc_ver);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, partition version %d\n", tape->name, tape->first_frame_position, par->par_desc_ver);
    > return 0;
    > }
    > if (ntohs(par->wrt_pass_cntr) != tape->wrt_pass_cntr) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, wrt_pass_cntr %d (expected %d)(logical_blk_num %u)\n", tape->name, ntohs(par->wrt_pass_cntr), tape->wrt_pass_cntr, ntohl(aux->logical_blk_num));
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, wrt_pass_cntr %d (expected %d)(logical_blk_num %u)\n", tape->name, tape->first_frame_position, ntohs(par->wrt_pass_cntr), tape->wrt_pass_cntr, ntohl(aux->logical_blk_num));
    > return 0;
    > }
    > if (aux->frame_seq_num != aux->logical_blk_num) {
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, seq != logical\n", tape->name);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, seq != logical\n", tape->name, tape->first_frame_position);
    > return 0;
    > }
    > if (logical_blk_num != -1 && ntohl(aux->logical_blk_num) != logical_blk_num) {
    > if (!quiet)
    > - printk(KERN_INFO "ide-tape: %s: skipping frame, logical_blk_num %u (expected %d)\n", tape->name, ntohl(aux->logical_blk_num), logical_blk_num);
    > + printk(KERN_INFO "ide-tape: %s: skipping frame %d, logical_blk_num %u (expected %d)\n", tape->name, tape->first_frame_position, ntohl(aux->logical_blk_num), logical_blk_num);
    > return 0;
    > }
    > if (aux->frame_type == OS_FRAME_TYPE_MARKER) {
    > @@ -3689,7 +3765,7 @@
    > idetape_switch_buffers (tape, new_stage);
    > idetape_init_stage(drive, new_stage, OS_FRAME_TYPE_DATA, tape->logical_blk_num);
    > tape->logical_blk_num++;
    > - idetape_add_stage_tail (drive,new_stage);
    > + idetape_add_stage_tail (drive, new_stage);
    > tape->pipeline_head++;
    > #if USE_IOTRACE
    > IO_trace(IO_IDETAPE_FIFO, tape->pipeline_head, tape->buffer_head, tape->tape_head, tape->minor);
    > @@ -3766,7 +3842,7 @@
    > }
    > #endif /* IDETAPE_DEBUG_BUGS */
    > if (tape->merge_stage_size) {
    > - blocks=tape->merge_stage_size/tape->tape_block_size;
    > + blocks = tape->merge_stage_size / tape->tape_block_size;
    > if (tape->merge_stage_size % tape->tape_block_size) {
    > blocks++;
    > i = tape->tape_block_size - tape->merge_stage_size % tape->tape_block_size;
    > @@ -3797,7 +3873,7 @@
    > tape->merge_stage = NULL;
    > }
    > clear_bit (IDETAPE_PIPELINE_ERROR, &tape->flags);
    > - tape->chrdev_direction=idetape_direction_none;
    > + tape->chrdev_direction = idetape_direction_none;
    >
    > /*
    > * On the next backup, perform the feedback loop again.
    > @@ -3874,13 +3950,13 @@
    > rq.sector = tape->first_frame_position;
    > rq.nr_sectors = rq.current_nr_sectors = blocks;
    > if (!test_bit(IDETAPE_PIPELINE_ERROR, &tape->flags) && tape->nr_stages <= max_stages) {
    > - new_stage=idetape_kmalloc_stage (tape);
    > + new_stage = idetape_kmalloc_stage (tape);
    > while (new_stage != NULL) {
    > - new_stage->rq=rq;
    > - idetape_add_stage_tail (drive,new_stage);
    > + new_stage->rq = rq;
    > + idetape_add_stage_tail (drive, new_stage);
    > if (tape->nr_stages >= max_stages)
    > break;
    > - new_stage=idetape_kmalloc_stage (tape);
    > + new_stage = idetape_kmalloc_stage (tape);
    > }
    > }
    > if (!idetape_pipeline_active(tape)) {
    > @@ -3922,16 +3998,23 @@
    > #endif
    > clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);
    > position = idetape_read_position(drive);
    > + printk(KERN_INFO "ide-tape: %s: blank block detected at %d\n", tape->name, position);
    > if (position >= 3000 && position < 3080)
    > - position += 32;
    > - if (position >= 2980 && position < 3000)
    > + position += 32; /* Why is this check and number ??? MM */
    > + if (position >= OS_DATA_ENDFRAME1 && position < 3000)
    > position = 3000;
    > else
    > + /*
    > + * compensate for write errors that generally skip 80 frames,
    > + * expect around 20 read errors in a row...
    > + */
    > position += 60;
    > - if (position >= 2980 && position < 3000)
    > + if (position >= OS_DATA_ENDFRAME1 && position < 3000)
    > position = 3000;
    > - printk(KERN_INFO "ide-tape: %s: blank block detected, positioning tape to block %d\n", tape->name, position);
    > - idetape_position_tape(drive, position, 0, 1);
    > + printk(KERN_INFO "ide-tape: %s: positioning tape to block %d\n", tape->name, position);
    > + if (position == 3000) /* seems to be needed to correctly position at block 3000 MM */
    > + idetape_position_tape(drive, 0, 0, 0);
    > + idetape_position_tape(drive, position, 0, 0);
    > cnt += 40;
    > continue;
    > } else
    > @@ -4089,12 +4172,14 @@
    > #endif /* IDETAPE_DEBUG_LOG */
    >
    > idetape_create_rewind_cmd (drive, &pc);
    > - retval=idetape_queue_pc_tail (drive,&pc);
    > - if (retval) return retval;
    > + retval = idetape_queue_pc_tail (drive, &pc);
    > + if (retval)
    > + return retval;
    >
    > idetape_create_read_position_cmd (&pc);
    > - retval = idetape_queue_pc_tail (drive,&pc);
    > - if (retval) return retval;
    > + retval = idetape_queue_pc_tail (drive, &pc);
    > + if (retval)
    > + return retval;
    > tape->logical_blk_num = 0;
    > return 0;
    > }
    > @@ -4412,7 +4497,7 @@
    > switch (mt_op) {
    > case MTFSF:
    > idetape_create_space_cmd (&pc,mt_count-count,IDETAPE_SPACE_OVER_FILEMARK);
    > - return (idetape_queue_pc_tail (drive,&pc));
    > + return (idetape_queue_pc_tail (drive, &pc));
    > case MTFSFM:
    > if (!tape->capabilities.sprev)
    > return (-EIO);
    > @@ -4423,7 +4508,7 @@
    > 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));
    > + return (idetape_queue_pc_tail (drive, &pc));
    > case MTBSFM:
    > if (!tape->capabilities.sprev)
    > return (-EIO);
    > @@ -4460,7 +4545,7 @@
    > struct inode *inode = file->f_dentry->d_inode;
    > ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
    > idetape_tape_t *tape = drive->driver_data;
    > - ssize_t bytes_read,temp,actually_read=0, rc;
    > + ssize_t bytes_read,temp, actually_read = 0, rc;
    >
    > if (ppos != &file->f_pos) {
    > /* "A request was outside the capabilities of the device." */
    > @@ -4482,28 +4567,32 @@
    > }
    > if ((rc = idetape_initiate_read(drive, tape->max_stages)) < 0)
    > return rc;
    > - if (count==0)
    > + if (count == 0)
    > return (0);
    > if (tape->merge_stage_size) {
    > - actually_read=IDE_MIN (tape->merge_stage_size,count);
    > + actually_read = IDE_MIN (tape->merge_stage_size, count);
    > idetape_copy_stage_to_user (tape, buf, tape->merge_stage, actually_read);
    > - buf += actually_read; tape->merge_stage_size -= actually_read; count-=actually_read;
    > + buf += actually_read;
    > + tape->merge_stage_size -= actually_read;
    > + count -= actually_read;
    > }
    > while (count >= tape->stage_size) {
    > - bytes_read=idetape_add_chrdev_read_request (drive, tape->capabilities.ctl);
    > + bytes_read = idetape_add_chrdev_read_request (drive, tape->capabilities.ctl);
    > if (bytes_read <= 0)
    > goto finish;
    > idetape_copy_stage_to_user (tape, buf, tape->merge_stage, bytes_read);
    > - buf += bytes_read; count -= bytes_read; actually_read += bytes_read;
    > + buf += bytes_read;
    > + count -= bytes_read;
    > + actually_read += bytes_read;
    > }
    > if (count) {
    > bytes_read=idetape_add_chrdev_read_request (drive, tape->capabilities.ctl);
    > if (bytes_read <= 0)
    > goto finish;
    > - temp=IDE_MIN (count,bytes_read);
    > + temp = IDE_MIN (count, bytes_read);
    > idetape_copy_stage_to_user (tape, buf, tape->merge_stage, temp);
    > - actually_read+=temp;
    > - tape->merge_stage_size=bytes_read-temp;
    > + actually_read += temp;
    > + tape->merge_stage_size = bytes_read-temp;
    > }
    > finish:
    > if (!actually_read && test_bit (IDETAPE_FILEMARK, &tape->flags)) {
    > @@ -4515,7 +4604,8 @@
    > return 0;
    > }
    > if (tape->onstream && !actually_read && test_and_clear_bit(IDETAPE_READ_ERROR, &tape->flags)) {
    > - printk(KERN_ERR "ide-tape: %s: unrecovered read error on logical block number %d, skipping\n", tape->name, tape->logical_blk_num);
    > + printk(KERN_ERR "ide-tape: %s: unrecovered read error on logical block number %d, skipping\n",
    > + tape->name, tape->logical_blk_num);
    > tape->logical_blk_num++;
    > return -EIO;
    > }
    > @@ -4576,6 +4666,37 @@
    > return;
    > }
    >
    > +static void idetape_write_filler (ide_drive_t *drive, int block, int cnt)
    > +{
    > + idetape_tape_t *tape = drive->driver_data;
    > + idetape_stage_t *stage;
    > + int rc;
    > +
    > + if (!tape->onstream || tape->raw)
    > + return;
    > + stage = __idetape_kmalloc_stage(tape, 1, 1);
    > + if (stage == NULL)
    > + return;
    > + idetape_init_stage(drive, stage, OS_FRAME_TYPE_FILL, 0);
    > + idetape_wait_ready(drive, 60 * 5 * HZ);
    > + rc = idetape_position_tape(drive, block, 0, 0);
    > +#if ONSTREAM_DEBUG
    > + printk(KERN_INFO "write_filler: positioning failed it returned %d\n", rc);
    > +#endif
    > + if (rc != 0)
    > + return; /* don't write fillers if we cannot position the tape. */
    > +
    > + strcpy(stage->bh->b_data, "Filler");
    > + while (cnt--) {
    > + if (!idetape_queue_rw_tail (drive, IDETAPE_WRITE_RQ, 1, stage->bh)) {
    > + printk(KERN_INFO "ide-tape: %s: write_filler: couldn't write header frame\n", tape->name);
    > + __idetape_kfree_stage (stage);
    > + return;
    > + }
    > + }
    > + __idetape_kfree_stage (stage);
    > +}
    > +
    > static void __idetape_write_header (ide_drive_t *drive, int block, int cnt)
    > {
    > idetape_tape_t *tape = drive->driver_data;
    > @@ -4591,12 +4712,12 @@
    > memset(&header, 0, sizeof(header));
    > strcpy(header.ident_str, "ADR_SEQ");
    > header.major_rev = 1;
    > - header.minor_rev = 2;
    > + header.minor_rev = OS_ADR_MINREV;
    > header.par_num = 1;
    > header.partition.partition_num = OS_DATA_PARTITION;
    > header.partition.par_desc_ver = OS_PARTITION_VERSION;
    > - header.partition.first_frame_addr = htonl(0x14);
    > - header.partition.last_frame_addr = htonl(19239 * 24);
    > + header.partition.first_frame_addr = htonl(OS_DATA_STARTFRAME1);
    > + header.partition.last_frame_addr = htonl(tape->capacity);
    > header.partition.wrt_pass_cntr = htons(tape->wrt_pass_cntr);
    > header.partition.eod_frame_addr = htonl(tape->eod_frame_addr);
    > memcpy(stage->bh->b_data, &header, sizeof(header));
    > @@ -4623,7 +4744,7 @@
    > return;
    > tape->update_frame_cntr++;
    > __idetape_write_header(drive, 5, 5);
    > - __idetape_write_header(drive, 0xbae, 5);
    > + __idetape_write_header(drive, 0xbae, 5); /* 2990 */
    > if (locate_eod) {
    > #if ONSTREAM_DEBUG
    > if (tape->debug_level >= 2)
    > @@ -4639,22 +4760,39 @@
    > struct inode *inode = file->f_dentry->d_inode;
    > ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
    > idetape_tape_t *tape = drive->driver_data;
    > - ssize_t retval,actually_written=0;
    > + ssize_t retval, actually_written = 0;
    > int position;
    >
    > if (ppos != &file->f_pos) {
    > /* "A request was outside the capabilities of the device." */
    > return -ENXIO;
    > }
    > - if (tape->onstream && (count != tape->tape_block_size)) {
    > - printk(KERN_ERR "ide-tape: %s: use %d bytes as block size (%Zd used)\n", tape->name, tape->tape_block_size, count);
    > - return -EINVAL;
    > - }
    > +
    > #if IDETAPE_DEBUG_LOG
    > if (tape->debug_level >= 3)
    > printk (KERN_INFO "ide-tape: Reached idetape_chrdev_write, count %Zd\n", count);
    > #endif /* IDETAPE_DEBUG_LOG */
    >
    > + if (tape->onstream) {
    > + if (count != tape->tape_block_size) {
    > + printk(KERN_ERR "ide-tape: %s: chrdev_write: use %d bytes as block size (%d used)\n",
    > + tape->name, tape->tape_block_size, count);
    > + return -EINVAL;
    > + }
    > + /*
    > + * Check if we reach the end of the tape. Just assume the whole pipeline
    > + * is filled with write requests!
    > + */
    > + if (tape->first_frame_position + tape->nr_stages >= tape->capacity - OS_EW) {
    > +#if ONSTREAM_DEBUG
    > + printk(KERN_INFO, "chrdev_write: Write truncated at EOM early warning");
    > +#endif
    > + if (tape->chrdev_direction == idetape_direction_write)
    > + idetape_write_release(inode);
    > + return -ENOSPC;
    > + }
    > + }
    > +
    > if (tape->chrdev_direction != idetape_direction_write) { /* Initialize write operation */
    > if (tape->chrdev_direction == idetape_direction_read)
    > idetape_discard_read_pipeline (drive, 1);
    > @@ -4671,17 +4809,17 @@
    >
    > if (tape->onstream) {
    > position = idetape_read_position(drive);
    > - if (position <= 20) {
    > + if (position <= OS_DATA_STARTFRAME1) {
    > tape->logical_blk_num = 0;
    > tape->wrt_pass_cntr++;
    > #if ONSTREAM_DEBUG
    > if (tape->debug_level >= 2)
    > - printk(KERN_INFO "ide-tape: %s: logical block num 0, setting eod to 20\n", tape->name);
    > + printk(KERN_INFO "ide-tape: %s: logical block num 0, setting eod to %d\n", tape->name, OS_DATA_STARTFRAME1);
    > if (tape->debug_level >= 2)
    > printk(KERN_INFO "ide-tape: %s: allocating new write pass counter %d\n", tape->name, tape->wrt_pass_cntr);
    > #endif
    > tape->filemark_cnt = 0;
    > - tape->eod_frame_addr = 20;
    > + tape->eod_frame_addr = OS_DATA_STARTFRAME1;
    > tape->first_mark_addr = tape->last_mark_addr = -1;
    > idetape_write_header(drive, 1);
    > }
    > @@ -4715,7 +4853,7 @@
    > printk("ide-tape: first_frame_position %d\n", tape->first_frame_position);
    > #endif
    > }
    > - if (count==0)
    > + if (count == 0)
    > return (0);
    > if (tape->restart_speed_control_req)
    > idetape_restart_speed_control(drive);
    > @@ -4723,32 +4861,35 @@
    > #if IDETAPE_DEBUG_BUGS
    > if (tape->merge_stage_size >= tape->stage_size) {
    > printk (KERN_ERR "ide-tape: bug: merge buffer too big\n");
    > - tape->merge_stage_size=0;
    > + tape->merge_stage_size = 0;
    > }
    > #endif /* IDETAPE_DEBUG_BUGS */
    > - actually_written=IDE_MIN (tape->stage_size-tape->merge_stage_size,count);
    > + actually_written = IDE_MIN (tape->stage_size - tape->merge_stage_size, count);
    > idetape_copy_stage_from_user (tape, tape->merge_stage, buf, actually_written);
    > - buf+=actually_written;tape->merge_stage_size+=actually_written;count-=actually_written;
    > + buf += actually_written;
    > + tape->merge_stage_size += actually_written;
    > + count -= actually_written;
    >
    > if (tape->merge_stage_size == tape->stage_size) {
    > tape->merge_stage_size = 0;
    > - retval=idetape_add_chrdev_write_request (drive, tape->capabilities.ctl);
    > + retval = idetape_add_chrdev_write_request (drive, tape->capabilities.ctl);
    > if (retval <= 0)
    > return (retval);
    > }
    > }
    > while (count >= tape->stage_size) {
    > idetape_copy_stage_from_user (tape, tape->merge_stage, buf, tape->stage_size);
    > - buf+=tape->stage_size;count-=tape->stage_size;
    > - retval=idetape_add_chrdev_write_request (drive, tape->capabilities.ctl);
    > - actually_written+=tape->stage_size;
    > + buf += tape->stage_size;
    > + count -= tape->stage_size;
    > + retval = idetape_add_chrdev_write_request (drive, tape->capabilities.ctl);
    > + actually_written += tape->stage_size;
    > if (retval <= 0)
    > return (retval);
    > }
    > if (count) {
    > actually_written+=count;
    > idetape_copy_stage_from_user (tape, tape->merge_stage, buf, count);
    > - tape->merge_stage_size+=count;
    > + tape->merge_stage_size += count;
    > }
    > return (actually_written);
    > }
    > @@ -4760,8 +4901,8 @@
    > idetape_pc_t pc;
    >
    > if (!tape->onstream) {
    > - idetape_create_write_filemark_cmd(drive, &pc,1); /* Write a filemark */
    > - if (idetape_queue_pc_tail (drive,&pc)) {
    > + idetape_create_write_filemark_cmd(drive, &pc, 1); /* Write a filemark */
    > + if (idetape_queue_pc_tail (drive, &pc)) {
    > printk (KERN_ERR "ide-tape: Couldn't write a filemark\n");
    > return -EIO;
    > }
    > @@ -4937,24 +5078,24 @@
    > if (idetape_rewind_tape(drive))
    > return -EIO;
    > if (tape->onstream && !tape->raw)
    > - return idetape_position_tape(drive, 20, 0, 0);
    > + return idetape_position_tape(drive, OS_DATA_STARTFRAME1, 0, 0);
    > return 0;
    > case MTLOAD:
    > idetape_discard_read_pipeline (drive, 0);
    > idetape_create_load_unload_cmd (drive, &pc, IDETAPE_LU_LOAD_MASK);
    > - return (idetape_queue_pc_tail (drive,&pc));
    > + return (idetape_queue_pc_tail (drive, &pc));
    > case MTUNLOAD:
    > case MTOFFL:
    > idetape_discard_read_pipeline (drive, 0);
    > idetape_create_load_unload_cmd (drive, &pc,!IDETAPE_LU_LOAD_MASK);
    > - return (idetape_queue_pc_tail (drive,&pc));
    > + return (idetape_queue_pc_tail (drive, &pc));
    > case MTNOP:
    > idetape_discard_read_pipeline (drive, 0);
    > return (idetape_flush_tape_buffers (drive));
    > case MTRETEN:
    > idetape_discard_read_pipeline (drive, 0);
    > idetape_create_load_unload_cmd (drive, &pc,IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
    > - return (idetape_queue_pc_tail (drive,&pc));
    > + return (idetape_queue_pc_tail (drive, &pc));
    > case MTEOM:
    > if (tape->onstream) {
    > #if ONSTREAM_DEBUG
    > @@ -4968,24 +5109,30 @@
    > return -EIO;
    > return 0;
    > }
    > - idetape_create_space_cmd (&pc,0,IDETAPE_SPACE_TO_EOD);
    > - return (idetape_queue_pc_tail (drive,&pc));
    > + idetape_create_space_cmd (&pc, 0, IDETAPE_SPACE_TO_EOD);
    > + return (idetape_queue_pc_tail (drive, &pc));
    > case MTERASE:
    > if (tape->onstream) {
    > - tape->eod_frame_addr = 20;
    > + tape->eod_frame_addr = OS_DATA_STARTFRAME1;
    > tape->logical_blk_num = 0;
    > tape->first_mark_addr = tape->last_mark_addr = -1;
    > idetape_position_tape(drive, tape->eod_frame_addr, 0, 0);
    > idetape_write_eod(drive);
    > idetape_flush_tape_buffers (drive);
    > idetape_write_header(drive, 0);
    > + /*
    > + * write filler frames to the unused frames...
    > + * REMOVE WHEN going to LIN4 application type...
    > + */
    > + idetape_write_filler(drive, OS_DATA_STARTFRAME1 - 10, 10);
    > + idetape_write_filler(drive, OS_DATA_ENDFRAME1, 10);
    > idetape_flush_tape_buffers (drive);
    > (void) idetape_rewind_tape (drive);
    > return 0;
    > }
    > (void) idetape_rewind_tape (drive);
    > idetape_create_erase_cmd (&pc);
    > - return (idetape_queue_pc_tail (drive,&pc));
    > + return (idetape_queue_pc_tail (drive, &pc));
    > case MTSETBLK:
    > if (tape->onstream) {
    > if (mt_count != tape->tape_block_size) {
    > @@ -5028,14 +5175,14 @@
    > case MTLOCK:
    > if (!idetape_create_prevent_cmd(drive, &pc, 1))
    > return 0;
    > - retval = idetape_queue_pc_tail (drive,&pc);
    > + retval = idetape_queue_pc_tail (drive, &pc);
    > if (retval) return retval;
    > tape->door_locked = DOOR_EXPLICITLY_LOCKED;
    > return 0;
    > case MTUNLOCK:
    > if (!idetape_create_prevent_cmd(drive, &pc, 0))
    > return 0;
    > - retval = idetape_queue_pc_tail (drive,&pc);
    > + retval = idetape_queue_pc_tail (drive, &pc);
    > if (retval) return retval;
    > tape->door_locked = DOOR_UNLOCKED;
    > return 0;
    > @@ -5113,7 +5260,7 @@
    > mtget.mt_gstat |= GMT_ONLINE(0xffffffff);
    > if (tape->first_stage && tape->first_stage->aux->frame_type == OS_FRAME_TYPE_EOD)
    > mtget.mt_gstat |= GMT_EOD(0xffffffff);
    > - if (position <= 20)
    > + if (position <= OS_DATA_STARTFRAME1)
    > mtget.mt_gstat |= GMT_BOT(0xffffffff);
    > }
    > if (copy_to_user ((char *) arg,(char *) &mtget, sizeof (struct mtget)))
    > @@ -5150,7 +5297,7 @@
    > tape->header_ok = tape->linux_media = 0;
    > tape->update_frame_cntr = 0;
    > tape->wrt_pass_cntr = 0;
    > - tape->eod_frame_addr = 20;
    > + tape->eod_frame_addr = OS_DATA_STARTFRAME1;
    > tape->first_mark_addr = tape->last_mark_addr = -1;
    > stage = __idetape_kmalloc_stage (tape, 0, 0);
    > if (stage == NULL)
    > @@ -5172,8 +5319,8 @@
    > __idetape_kfree_stage (stage);
    > return 0;
    > }
    > - if (header->major_rev != 1 || (header->minor_rev != 1 && header->minor_rev != 2))
    > - printk(KERN_INFO "ide-tape: warning: revision %d.%d detected (1.1/1.2 supported)\n", header->major_rev, header->minor_rev);
    > + if (header->major_rev != 1 || (header->minor_rev > OS_ADR_MINREV))
    > + printk(KERN_INFO "ide-tape: warning: revision %d.%d detected (up to 1.%d supported)\n", header->major_rev, header->minor_rev, OS_ADR_MINREV);
    > if (header->par_num != 1)
    > printk(KERN_INFO "ide-tape: warning: %d partitions defined, only one supported\n", header->par_num);
    > tape->wrt_pass_cntr = ntohs(header->partition.wrt_pass_cntr);
    > @@ -5182,12 +5329,14 @@
    > tape->first_mark_addr = ntohl(aux->next_mark_addr);
    > tape->last_mark_addr = ntohl(aux->last_mark_addr);
    > tape->update_frame_cntr = ntohl(aux->update_frame_cntr);
    > - memcpy(tape->application_sig, aux->application_sig, 4); tape->application_sig[4] = 0;
    > + memcpy(tape->application_sig, aux->application_sig, 4);
    > + tape->application_sig[4] = 0;
    > if (memcmp(tape->application_sig, "LIN", 3) == 0) {
    > tape->linux_media = 1;
    > tape->linux_media_version = tape->application_sig[3] - '0';
    > if (tape->linux_media_version != 3)
    > - printk(KERN_INFO "ide-tape: %s: Linux media version %d detected (current 3)\n", tape->name, tape->linux_media_version);
    > + printk(KERN_INFO "ide-tape: %s: Linux media version %d detected (current 3)\n",
    > + tape->name, tape->linux_media_version);
    > } else {
    > printk(KERN_INFO "ide-tape: %s: non Linux media detected (%s)\n", tape->name, tape->application_sig);
    > tape->linux_media = 0;
    > @@ -5214,18 +5363,14 @@
    > for (block = 5; block < 10; block++)
    > if (__idetape_analyze_headers(drive, block))
    > goto ok;
    > -#if 0
    > - for (block = 0xbae; block < 0xbb8; block++)
    > -#else
    > - for (block = 0xbae; block < 0xbb3; block++)
    > -#endif
    > + for (block = 0xbae; block < 0xbb3; block++) /* 2990 - 2994 */
    > if (__idetape_analyze_headers(drive, block))
    > goto ok;
    > printk(KERN_ERR "ide-tape: %s: failed to find valid ADRL header\n", tape->name);
    > return 0;
    > ok:
    > - if (position < 20)
    > - position = 20;
    > + if (position < OS_DATA_STARTFRAME1)
    > + position = OS_DATA_STARTFRAME1;
    > idetape_position_tape(drive, position, 0, 0);
    > tape->header_ok = 1;
    > return 1;
    > @@ -5251,6 +5396,7 @@
    >
    > if (test_and_set_bit (IDETAPE_BUSY, &tape->flags))
    > return -EBUSY;
    > + MOD_INC_USE_COUNT;
    > if (!tape->onstream) {
    > idetape_read_position(drive);
    > if (!test_bit (IDETAPE_ADDRESS_VALID, &tape->flags))
    > @@ -5263,18 +5409,22 @@
    > tape->tape_block_size = tape->stage_size = 32768;
    > tape->raw = 0;
    > }
    > + idetape_onstream_mode_sense_tape_parameter_page(drive, tape->debug_level);
    > }
    > if (idetape_wait_ready(drive, 60 * HZ)) {
    > clear_bit(IDETAPE_BUSY, &tape->flags);
    > printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);
    > + MOD_DEC_USE_COUNT;
    > return -EBUSY;
    > }
    > idetape_read_position(drive);
    > + MOD_DEC_USE_COUNT;
    > clear_bit (IDETAPE_PIPELINE_ERROR, &tape->flags);
    >
    > if (tape->chrdev_direction == idetape_direction_none) {
    > + MOD_INC_USE_COUNT;
    > if (idetape_create_prevent_cmd(drive, &pc, 1)) {
    > - if (!idetape_queue_pc_tail (drive,&pc)) {
    > + if (!idetape_queue_pc_tail (drive, &pc)) {
    > if (tape->door_locked != DOOR_EXPLICITLY_LOCKED)
    > tape->door_locked = DOOR_LOCKED;
    > }
    > @@ -5287,6 +5437,28 @@
    > return 0;
    > }
    >
    > +static void idetape_write_release (struct inode *inode)
    > +{
    > + ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
    > + idetape_tape_t *tape = drive->driver_data;
    > + unsigned int minor=MINOR (inode->i_rdev);
    > +
    > + idetape_empty_write_pipeline (drive);
    > + tape->merge_stage = __idetape_kmalloc_stage (tape, 1, 0);
    > + if (tape->merge_stage != NULL) {
    > + idetape_pad_zeros (drive, tape->tape_block_size * (tape->user_bs_factor - 1));
    > + __idetape_kfree_stage (tape->merge_stage);
    > + tape->merge_stage = NULL;
    > + }
    > + idetape_write_filemark(drive);
    > + idetape_write_eod(drive);
    > + idetape_flush_tape_buffers (drive);
    > + idetape_write_header(drive, minor >= 128);
    > + idetape_flush_tape_buffers (drive);
    > +
    > + return;
    > +}
    > +
    > /*
    > * Our character device release function.
    > */
    > @@ -5305,18 +5477,7 @@
    > #endif /* IDETAPE_DEBUG_LOG */
    >
    > if (tape->chrdev_direction == idetape_direction_write) {
    > - idetape_empty_write_pipeline (drive);
    > - tape->merge_stage = __idetape_kmalloc_stage (tape, 1, 0);
    > - if (tape->merge_stage != NULL) {
    > - idetape_pad_zeros (drive, tape->tape_block_size * (tape->user_bs_factor - 1));
    > - __idetape_kfree_stage (tape->merge_stage);
    > - tape->merge_stage = NULL;
    > - }
    > - idetape_write_filemark(drive);
    > - idetape_write_eod(drive);
    > - idetape_flush_tape_buffers (drive);
    > - idetape_write_header(drive, minor >= 128);
    > - idetape_flush_tape_buffers (drive);
    > + idetape_write_release(inode);
    > }
    > if (tape->chrdev_direction == idetape_direction_read) {
    > if (minor < 128)
    > @@ -5333,9 +5494,10 @@
    > if (tape->chrdev_direction == idetape_direction_none) {
    > if (tape->door_locked != DOOR_EXPLICITLY_LOCKED) {
    > if (idetape_create_prevent_cmd(drive, &pc, 0))
    > - if (!idetape_queue_pc_tail (drive,&pc))
    > + if (!idetape_queue_pc_tail (drive, &pc))
    > tape->door_locked = DOOR_UNLOCKED;
    > }
    > + MOD_DEC_USE_COUNT;
    > }
    > clear_bit (IDETAPE_BUSY, &tape->flags);
    > unlock_kernel();
    > @@ -5491,7 +5653,7 @@
    > pc.buffer[4 + 5] = vendor[3];
    > pc.buffer[4 + 6] = 0;
    > pc.buffer[4 + 7] = 0;
    > - if (idetape_queue_pc_tail (drive,&pc))
    > + if (idetape_queue_pc_tail (drive, &pc))
    > printk (KERN_ERR "ide-tape: Couldn't set vendor name to %s\n", vendor);
    >
    > }
    > @@ -5513,7 +5675,7 @@
    > pc.buffer[4 + 1] = 2;
    > pc.buffer[4 + 2] = 4;
    > pc.buffer[4 + 3] = retries;
    > - if (idetape_queue_pc_tail (drive,&pc))
    > + if (idetape_queue_pc_tail (drive, &pc))
    > printk (KERN_ERR "ide-tape: Couldn't set retries to %d\n", retries);
    > }
    > #endif
    > @@ -5530,8 +5692,8 @@
    > /*
    > * Get the current block size from the block size mode page
    > */
    > - idetape_create_mode_sense_cmd (&pc,IDETAPE_BLOCK_SIZE_PAGE);
    > - if (idetape_queue_pc_tail (drive,&pc))
    > + idetape_create_mode_sense_cmd (&pc, IDETAPE_BLOCK_SIZE_PAGE);
    > + if (idetape_queue_pc_tail (drive, &pc))
    > printk (KERN_ERR "ide-tape: can't get tape block size mode page\n");
    > header = (idetape_mode_parameter_header_t *) pc.buffer;
    > bs = (idetape_block_size_page_t *) (pc.buffer + sizeof(idetape_mode_parameter_header_t) + header->bdl);
    > @@ -5552,7 +5714,7 @@
    > bs->record32 = 0;
    > bs->record32_5 = 1;
    > idetape_create_mode_select_cmd(&pc, sizeof(*header) + sizeof(*bs));
    > - if (idetape_queue_pc_tail (drive,&pc))
    > + if (idetape_queue_pc_tail (drive, &pc))
    > printk (KERN_ERR "ide-tape: Couldn't set tape block size mode page\n");
    >
    > #if ONSTREAM_DEBUG
    > @@ -5575,7 +5737,7 @@
    > idetape_inquiry_result_t *inquiry;
    >
    > idetape_create_inquiry_cmd(&pc);
    > - if (idetape_queue_pc_tail (drive,&pc)) {
    > + if (idetape_queue_pc_tail (drive, &pc)) {
    > printk (KERN_ERR "ide-tape: %s: can't get INQUIRY results\n", tape->name);
    > return;
    > }
    > @@ -5618,6 +5780,34 @@
    > }
    >
    > /*
    > + * idetape_get_mode_sense_parameters asks the tape about its various
    > + * parameters. This may work for other drives to???
    > + */
    > +static void idetape_onstream_mode_sense_tape_parameter_page(ide_drive_t *drive, int debug)
    > +{
    > + idetape_tape_t *tape = drive->driver_data;
    > + idetape_pc_t pc;
    > + idetape_mode_parameter_header_t *header;
    > + onstream_tape_paramtr_page_t *prm;
    > +
    > + idetape_create_mode_sense_cmd (&pc, IDETAPE_PARAMTR_PAGE);
    > + if (idetape_queue_pc_tail (drive, &pc)) {
    > + printk (KERN_ERR "ide-tape: Can't get tape parameters page - probably no tape inserted in onstream drive\n");
    > + return;
    > + }
    > + header = (idetape_mode_parameter_header_t *) pc.buffer;
    > + prm = (onstream_tape_paramtr_page_t *) (pc.buffer + sizeof(idetape_mode_parameter_header_t) + header->bdl);
    > +
    > + tape->capacity = ntohs(prm->segtrk) * ntohs(prm->trks);
    > + if (debug) {
    > + printk (KERN_INFO "ide-tape: %s <-> %s: Tape length %dMB (%d frames/track, %d tracks = %d blocks, density: %dKbpi)\n",
    > + drive->name, tape->name, tape->capacity/32, ntohs(prm->segtrk), ntohs(prm->trks), tape->capacity, prm->density);
    > + }
    > +
    > + 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.
    > @@ -5629,8 +5819,8 @@
    > idetape_mode_parameter_header_t *header;
    > idetape_capabilities_page_t *capabilities;
    >
    > - idetape_create_mode_sense_cmd (&pc,IDETAPE_CAPABILITIES_PAGE);
    > - if (idetape_queue_pc_tail (drive,&pc)) {
    > + idetape_create_mode_sense_cmd (&pc, IDETAPE_CAPABILITIES_PAGE);
    > + if (idetape_queue_pc_tail (drive, &pc)) {
    > printk (KERN_ERR "ide-tape: Can't get tape parameters - assuming some default values\n");
    > tape->tape_block_size = 512; tape->capabilities.ctl = 52;
    > tape->capabilities.speed = 450; tape->capabilities.buffer_size = 6 * 52;
    > @@ -5721,6 +5911,9 @@
    > ide_add_setting(drive, "tape_still_time",SETTING_READ, -1, -1, TYPE_INT, 0, 0xffff, 1, 1, &tape->tape_still_time, NULL);
    > ide_add_setting(drive, "max_insert_speed",SETTING_RW, -1, -1, TYPE_INT, 0, 0xffff, 1, 1, &tape->max_insert_speed, NULL);
    > ide_add_setting(drive, "insert_size", SETTING_READ, -1, -1, TYPE_INT, 0, 0xffff, 1, 1, &tape->insert_size, NULL);
    > + ide_add_setting(drive, "capacity", SETTING_READ, -1, -1, TYPE_INT, 0, 0xffff, 1, 1, &tape->capacity, NULL);
    > + ide_add_setting(drive, "first_frame", SETTING_READ, -1, -1, TYPE_INT, 0, 0xffff, 1, 1, &tape->first_frame_position, NULL);
    > + ide_add_setting(drive, "logical_blk", SETTING_READ, -1, -1, TYPE_INT, 0, 0xffff, 1, 1, &tape->logical_blk_num, NULL);
    > }
    > }
    >
    > @@ -5747,7 +5940,7 @@
    > spin_lock_init(&tape->spinlock);
    > drive->driver_data = tape;
    > drive->ready_stat = 0; /* An ATAPI device ignores DRDY */
    > - if (strstr(drive->id->model, "OnStream DI-30"))
    > + if (strstr(drive->id->model, "OnStream DI-"))
    > tape->onstream = 1;
    > drive->dsc_overlap = 1;
    > #ifdef CONFIG_BLK_DEV_IDEPCI
    > @@ -5778,8 +5971,10 @@
    >
    > idetape_get_inquiry_results(drive);
    > idetape_get_mode_sense_results(drive);
    > - if (tape->onstream)
    > - idetape_configure_onstream(drive);
    > + if (tape->onstream) {
    > + idetape_onstream_mode_sense_tape_parameter_page(drive, 1);
    > + idetape_configure_onstream(drive);
    > + }
    >
    > tape->user_bs_factor = 1;
    > tape->stage_size = tape->capabilities.ctl * tape->tape_block_size;
    > @@ -5867,8 +6062,8 @@
    > char *out = page;
    > int len;
    >
    > - len = sprintf(out,"%s\n", tape->name);
    > - PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
    > + len = sprintf(out, "%s\n", tape->name);
    > + PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
    > }
    >
    > static ide_proc_entry_t idetape_proc[] = {
    > @@ -5962,7 +6157,7 @@
    > continue;
    > }
    > if (drive->scsi) {
    > - if (strstr(drive->id->model, "OnStream DI-30")) {
    > + if (strstr(drive->id->model, "OnStream DI-")) {
    > printk("ide-tape: ide-scsi emulation is not supported for %s.\n", drive->id->model);
    > } else {
    > printk("ide-tape: passing drive %s to ide-scsi emulation.\n", drive->name);
    >

    Andre Hedrick
    Linux ATA Development

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-03-22 13:28    [W:0.165 / U:0.628 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site