Messages in this thread | | | Date | Thu, 11 Jan 2001 14:04:11 -0800 (PST) | From | Andre Hedrick <> | Subject | Re: [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/
| |