ide: generic packet command representation
cover ide: generic packet command representation
Hi Bart,
here's the ide_atapi_pc unification series. It all went pretty smoothly along the search & replace line. Using driver-specific members in ide_atapi_pc like idefloppy_callback and idetape_callback is kinda dumb but this approach seemed the fastest versus unnecessary callback function signature change that will touch stuff all over the place. Besides, ide-tape might be gone soon so that would alleviate the problem.
On a different note, i noticed ide-scsi might also need a cleanup similar to the other drivers. It is next on my TODO list in case you don't have anything with a higher prio.
drivers/ide/ide-floppy.c | 205 +++++++++++++++++-------------------- drivers/ide/ide-tape.c | 251 +++++++++++++++++++++------------------------- drivers/scsi/ide-scsi.c | 133 +++++++++++------------- include/linux/ide.h | 47 +++++++++ 4 files changed, 316 insertions(+), 320 deletions(-)
Signature · 2 lines
Thanks, Boris.
PATCH 1/4 ide: add generic packet command representation ide_atapi_pc
This new struct unifies ide{-floppy,-tape,-scsi}'s view of a packet command. For now, it represents the common denominator between the three drivers while adding driver- specific members at the end of the struct which will be merged/simplified into the generic ATAPI handling code in later steps, or removed completely.
--- include/linux/ide.h | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 47 insertions(+), 0 deletions(-)
include/linux/ide.h +47 -0
@@ -629,6 +629,53 @@ typedef struct ide_settings_s {int ide_add_setting (ide_drive_t *,const char *,int ,int ,int ,int ,int ,int ,void *,ide_procset_t *set); +struct ide_atapi_pc { +/* actual packet bytes */ +u8 c[12 ]; +/* incremented on each retry */ +int retries; +int error; + +/* bytes to transfer */ +int req_xfer; +/* bytes actually transferred */ +int xferred; + +/* data buffer */ +u8 *buf; +/* current buffer position */ +u8 *cur_pos; +int buf_size; +/* missing/available data on the current buffer */ +int b_count; + +/* the corresponding request */ +struct request *rq; + +unsigned long flags; + +/* +* those are more or less driver-specific and some of them are subject +* to change/removal later. +*/ +u8 pc_buf[256 ]; +void (*idefloppy_callback) (ide_drive_t *); +ide_startstop_t (*idetape_callback) (ide_drive_t *); + +/* idetape only */ +struct idetape_bh *bh; +char *b_data; + +/* idescsi only for now */ +struct scatterlist *sg; +unsigned int sg_cnt; + +struct scsi_cmnd *scsi_cmd; +void (*done) (struct scsi_cmnd *); + +unsigned long timeout; +}; +/* * /proc/ide interface */
Signature · 1 line
1.5.3.7
PATCH 2/4 ide-floppy: convert driver to using generic ide_atapi_pc
In reply to Borislav Petkov--- drivers/ide/ide-floppy.c | 205 +++++++++++++++++++++------------------------- 1 files changed, 93 insertions(+), 112 deletions(-)
drivers/ide/ide-floppy.c +93 -112
@@ -78,26 +78,6 @@*/ #define IDEFLOPPY_PC_STACK (10 + IDEFLOPPY_MAX_PC_RETRIES) -typedef struct idefloppy_packet_command_s { -u8 c[12 ];/* Actual packet bytes */ -int retries;/* On each retry, we increment -retries */ -int error;/* Error code */ -int request_transfer;/* Bytes to transfer */ -int actually_transferred;/* Bytes actually transferred */ -int buffer_size;/* Size of our data buffer */ -int b_count;/* Missing/Available data on -the current buffer */ -struct request *rq;/* The corresponding request */ -u8 *buffer;/* Data buffer */ -u8 *current_position;/* Pointer into above buffer */ -void (*callback) (ide_drive_t *);/* Called when this packet -command is completed */ -u8 pc_buffer[IDEFLOPPY_PC_BUFFER_SIZE ];/* Temporary buffer */ -unsigned long flags;/* Status/Action bit flags: long -for set_bit */ -}idefloppy_pc_t ; -/* Packet command flag bits. */ enum {/* 1 when we prefer to use DMA if possible */
@@ -131,11 +111,11 @@ typedef struct ide_floppy_obj {unsigned int openers;/* protected by BKL for now */ /* Current packet command */ -idefloppy_pc_t *pc; +struct ide_atapi_pc *pc;/* Last failed packet command */ -idefloppy_pc_t *failed_pc; +struct ide_atapi_pc *failed_pc;/* Packet command stack */ -idefloppy_pc_t pc_stack[IDEFLOPPY_PC_STACK ]; +struct ide_atapi_pc pc_stack[IDEFLOPPY_PC_STACK ];/* Next free packet command storage space */ int pc_stack_index;struct request rq_stack[IDEFLOPPY_PC_STACK ];
@@ -262,7 +242,7 @@ static int idefloppy_do_end_request(ide_drive_t *drive, int uptodate, int nsecs)return 0 ; } -static void ide_floppy_io_buffers (ide_drive_t *drive,idefloppy_pc_t *pc, +static void ide_floppy_io_buffers (ide_drive_t *drive,struct ide_atapi_pc *pc,unsigned int bcount,int direction) {struct request *rq = pc->rq;
@@ -302,7 +282,8 @@ static void ide_floppy_io_buffers(ide_drive_t *drive, idefloppy_pc_t *pc, } } -static void idefloppy_update_buffers (ide_drive_t *drive,idefloppy_pc_t *pc) +static void idefloppy_update_buffers (ide_drive_t *drive, +struct ide_atapi_pc *pc) {struct request *rq = pc->rq;struct bio *bio = rq->bio;
@@ -316,7 +297,7 @@ static void idefloppy_update_buffers(ide_drive_t *drive, idefloppy_pc_t *pc)* the current request so that it will be processed immediately, on the next * pass through the driver. */ -static void idefloppy_queue_pc_head (ide_drive_t *drive,idefloppy_pc_t *pc, +static void idefloppy_queue_pc_head (ide_drive_t *drive,struct ide_atapi_pc *pc,struct request *rq) {struct ide_floppy_obj *floppy = drive->driver_data;
@@ -328,7 +309,7 @@ static void idefloppy_queue_pc_head(ide_drive_t *drive, idefloppy_pc_t *pc, (void )ide_do_drive_cmd (drive, rq, ide_preempt); } -static idefloppy_pc_t *idefloppy_next_pc_storage (ide_drive_t *drive) +static struct ide_atapi_pc *idefloppy_next_pc_storage (ide_drive_t *drive) {idefloppy_floppy_t *floppy = drive->driver_data;
@@ -349,7 +330,7 @@ static struct request *idefloppy_next_rq_storage(ide_drive_t *drive)static void idefloppy_request_sense_callback (ide_drive_t *drive) {idefloppy_floppy_t *floppy = drive->driver_data; -u8 *buf = floppy->pc->buffer; +u8 *buf = floppy->pc->buf;debug_log ("Reached %s\n" , __func__);
@@ -392,24 +373,24 @@ static void idefloppy_pc_callback(ide_drive_t *drive)idefloppy_do_end_request (drive, floppy->pc->error ?0 :1 ,0 ); } -static void idefloppy_init_pc (idefloppy_pc_t *pc) +static void idefloppy_init_pc (struct ide_atapi_pc *pc) {memset (pc->c,0 ,12 ); pc->retries =0 ; pc->flags =0 ; - pc->request_transfer =0 ; - pc->buffer = pc->pc_buffer; - pc->buffer_size =IDEFLOPPY_PC_BUFFER_SIZE ; - pc->callback = &idefloppy_pc_callback; + pc->req_xfer =0 ; + pc->buf = pc->pc_buf; + pc->buf_size =IDEFLOPPY_PC_BUFFER_SIZE ; + pc->idefloppy_callback = &idefloppy_pc_callback; } -static void idefloppy_create_request_sense_cmd (idefloppy_pc_t *pc) +static void idefloppy_create_request_sense_cmd (struct ide_atapi_pc *pc) {idefloppy_init_pc (pc); pc->c[0 ] =GPCMD_REQUEST_SENSE ; pc->c[4 ] =255 ; - pc->request_transfer =18 ; - pc->callback = &idefloppy_request_sense_callback; + pc->req_xfer =18 ; + pc->idefloppy_callback = &idefloppy_request_sense_callback; }/*
@@ -418,7 +399,7 @@ static void idefloppy_create_request_sense_cmd(idefloppy_pc_t *pc)*/ static void idefloppy_retry_pc (ide_drive_t *drive) { -idefloppy_pc_t *pc; +struct ide_atapi_pc *pc;struct request *rq; (void )ide_read_error (drive);
@@ -433,7 +414,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive) {idefloppy_floppy_t *floppy = drive->driver_data;ide_hwif_t *hwif = drive->hwif; -idefloppy_pc_t *pc = floppy->pc; +struct ide_atapi_pc *pc = floppy->pc;struct request *rq = pc->rq;xfer_func_t *xferfunc;unsigned int temp;
@@ -450,7 +431,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive) rq_data_dir(rq) ? "write" : "read"); pc->flags |=PC_FLAG_DMA_ERROR ; }else { - pc->actually_transferred = pc->request_transfer; + pc->xferred = pc->req_xfer;idefloppy_update_buffers (drive, pc); }debug_log ("DMA finished\n" );
@@ -462,7 +443,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)/* No more interrupts */ if ((stat &DRQ_STAT ) ==0 ) {debug_log ("Packet command completed, %d bytes transferred\n" , - pc->actually_transferred); + pc->xferred); pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS ;local_irq_enable_in_hardirq ();
@@ -485,7 +466,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)if (floppy->failed_pc == pc) floppy->failed_pc =NULL ;/* Command finished - Call the callback function */ - pc->callback (drive); + pc->idefloppy_callback (drive);return ide_stopped; }
@@ -517,9 +498,9 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive) }if (!(pc->flags &PC_FLAG_WRITING )) {/* Reading - Check that we have enough space */ - temp = pc->actually_transferred + bcount; -if (temp > pc->request_transfer) { -if (temp > pc->buffer_size) { + temp = pc->xferred + bcount; +if (temp > pc->req_xfer) { +if (temp > pc->buf_size) {printk (KERN_ERR "ide-floppy: The floppy wants " "to send us more data than expected " "- discarding data\n" );
@@ -540,15 +521,15 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)else xferfunc = hwif->atapi_input_bytes; -if (pc->buffer) -xferfunc (drive, pc->current_position, bcount); +if (pc->buf) +xferfunc (drive, pc->cur_pos, bcount);else ide_floppy_io_buffers (drive, pc, bcount, !!(pc->flags &PC_FLAG_WRITING ));/* Update the current position */ - pc->actually_transferred += bcount; - pc->current_position += bcount; + pc->xferred += bcount; + pc->cur_pos += bcount;/* And set the interrupt handler again */ ide_set_handler (drive, &idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD ,NULL );
@@ -640,7 +621,7 @@ static ide_startstop_t idefloppy_transfer_pc1(ide_drive_t *drive) }static void ide_floppy_report_error (idefloppy_floppy_t *floppy, -idefloppy_pc_t *pc) +struct ide_atapi_pc *pc) {/* supress error messages resulting from Medium not present */ if (floppy->sense_key == 0x02 &&
@@ -656,7 +637,7 @@ static void ide_floppy_report_error(idefloppy_floppy_t *floppy, }static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, -idefloppy_pc_t *pc) +struct ide_atapi_pc *pc) {idefloppy_floppy_t *floppy = drive->driver_data;ide_hwif_t *hwif = drive->hwif;
@@ -677,7 +658,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive, pc->error =IDEFLOPPY_ERROR_GENERAL ; floppy->failed_pc =NULL ; - pc->callback (drive); + pc->idefloppy_callback (drive);return ide_stopped; }
@@ -685,9 +666,9 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive, pc->retries++;/* We haven't transferred any data yet */ - pc->actually_transferred =0 ; - pc->current_position = pc->buffer; - bcount =min (pc->request_transfer,63 *1024 ); + pc->xferred =0 ; + pc->cur_pos = pc->buf; + bcount =min (pc->req_xfer,63 *1024 );if (pc->flags &PC_FLAG_DMA_ERROR ) { pc->flags &= ~PC_FLAG_DMA_ERROR ;
@@ -715,7 +696,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,/* immediate */ pkt_xfer_routine = &idefloppy_transfer_pc; } - +if (floppy->flags &IDEFLOPPY_FLAG_DRQ_INTERRUPT ) {/* Issue the packet command */ ide_execute_command(drive, WIN_PACKETCMD,
@@ -738,7 +719,7 @@ static void idefloppy_rw_callback(ide_drive_t *drive)return ; } -static void idefloppy_create_prevent_cmd (idefloppy_pc_t *pc,int prevent) +static void idefloppy_create_prevent_cmd (struct ide_atapi_pc *pc,int prevent) {debug_log ("creating prevent removal command, prevent = %d\n" , prevent);
@@ -747,39 +728,39 @@ static void idefloppy_create_prevent_cmd(idefloppy_pc_t *pc, int prevent) pc->c[4 ] = prevent; } -static void idefloppy_create_read_capacity_cmd (idefloppy_pc_t *pc) +static void idefloppy_create_read_capacity_cmd (struct ide_atapi_pc *pc) {idefloppy_init_pc (pc); pc->c[0 ] =GPCMD_READ_FORMAT_CAPACITIES ; pc->c[7 ] =255 ; pc->c[8 ] =255 ; - pc->request_transfer =255 ; + pc->req_xfer =255 ; } -static void idefloppy_create_format_unit_cmd (idefloppy_pc_t *pc,int b,int l, -int flags) +static void idefloppy_create_format_unit_cmd (struct ide_atapi_pc *pc,int b, +int l,int flags) {idefloppy_init_pc (pc); pc->c[0 ] =GPCMD_FORMAT_UNIT ; pc->c[1 ] =0x17 ; -memset (pc->buffer,0 ,12 ); - pc->buffer[1 ] =0xA2 ; +memset (pc->buf,0 ,12 ); + pc->buf[1 ] =0xA2 ;/* Default format list header, u8 1: FOV/DCRT/IMM bits set */ if (flags &1 )/* Verify bit on... */ - pc->buffer[1 ] ^=0x20 ;/* ... turn off DCRT bit */ - pc->buffer[3 ] =8 ; + pc->buf[1 ] ^=0x20 ;/* ... turn off DCRT bit */ + pc->buf[3 ] =8 ; -put_unaligned (cpu_to_be32 (b), (unsigned int *)(&pc->buffer[4 ])); -put_unaligned (cpu_to_be32 (l), (unsigned int *)(&pc->buffer[8 ])); - pc->buffer_size =12 ; +put_unaligned (cpu_to_be32 (b), (unsigned int *)(&pc->buf[4 ])); +put_unaligned (cpu_to_be32 (l), (unsigned int *)(&pc->buf[8 ])); + pc->buf_size =12 ; pc->flags |=PC_FLAG_WRITING ; }/* A mode sense command is used to "sense" floppy parameters. */ -static void idefloppy_create_mode_sense_cmd (idefloppy_pc_t *pc,u8 page_code, -u8 type) +static void idefloppy_create_mode_sense_cmd (struct ide_atapi_pc *pc, +u8 page_code,u8 type) {u16 length =8 ;/* sizeof(Mode Parameter Header) = 8 Bytes */
@@ -800,24 +781,24 @@ static void idefloppy_create_mode_sense_cmd(idefloppy_pc_t *pc, u8 page_code, "in create_mode_sense_cmd\n"); }put_unaligned (cpu_to_be16 (length), (u16 *) &pc->c[7 ]); - pc->request_transfer = length; + pc->req_xfer = length; } -static void idefloppy_create_start_stop_cmd (idefloppy_pc_t *pc,int start) +static void idefloppy_create_start_stop_cmd (struct ide_atapi_pc *pc,int start) {idefloppy_init_pc (pc); pc->c[0 ] =GPCMD_START_STOP_UNIT ; pc->c[4 ] = start; } -static void idefloppy_create_test_unit_ready_cmd (idefloppy_pc_t *pc) +static void idefloppy_create_test_unit_ready_cmd (struct ide_atapi_pc *pc) {idefloppy_init_pc (pc); pc->c[0 ] =GPCMD_TEST_UNIT_READY ; }static void idefloppy_create_rw_cmd (idefloppy_floppy_t *floppy, -idefloppy_pc_t *pc,struct request *rq, +struct ide_atapi_pc *pc,struct request *rq,unsigned long sector) {int block = sector / floppy->bs_factor;
@@ -832,41 +813,41 @@ static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy,put_unaligned (cpu_to_be16 (blocks), (unsigned short *)&pc->c[7 ]);put_unaligned (cpu_to_be32 (block), (unsigned int *) &pc->c[2 ]); - pc->callback = &idefloppy_rw_callback; + pc->idefloppy_callback = &idefloppy_rw_callback; pc->rq = rq; pc->b_count = cmd ==READ ?0 : rq->bio->bi_size;if (rq->cmd_flags &REQ_RW ) pc->flags |=PC_FLAG_WRITING ; - pc->buffer =NULL ; - pc->request_transfer = pc->buffer_size = blocks * floppy->block_size; + pc->buf =NULL ; + pc->req_xfer = pc->buf_size = blocks * floppy->block_size; pc->flags |=PC_FLAG_DMA_RECOMMENDED ; }static void idefloppy_blockpc_cmd (idefloppy_floppy_t *floppy, -idefloppy_pc_t *pc,struct request *rq) +struct ide_atapi_pc *pc,struct request *rq) {idefloppy_init_pc (pc); - pc->callback = &idefloppy_rw_callback; + pc->idefloppy_callback = &idefloppy_rw_callback;memcpy (pc->c, rq->cmd,sizeof (pc->c)); pc->rq = rq; pc->b_count = rq->data_len;if (rq->data_len &&rq_data_dir (rq) ==WRITE ) pc->flags |=PC_FLAG_WRITING ; - pc->buffer = rq->data; + pc->buf = rq->data;if (rq->bio) pc->flags |=PC_FLAG_DMA_RECOMMENDED ;/* * possibly problematic, doesn't look like ide-floppy correctly * handled scattered requests if dma fails... */ - pc->request_transfer = pc->buffer_size = rq->data_len; + pc->req_xfer = pc->buf_size = rq->data_len; }static ide_startstop_t idefloppy_do_request (ide_drive_t *drive,struct request *rq,sector_t block_s) {idefloppy_floppy_t *floppy = drive->driver_data; -idefloppy_pc_t *pc; +struct ide_atapi_pc *pc;unsigned long block = (unsigned long )block_s; debug_log("dev: %s, cmd_type: %x, errors: %d\n",
@@ -896,7 +877,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive, pc =idefloppy_next_pc_storage (drive);idefloppy_create_rw_cmd (floppy, pc, rq, block); }else if (blk_special_request (rq)) { - pc = (idefloppy_pc_t *) rq->buffer; + pc = (struct ide_atapi_pc *) rq->buffer; }else if (blk_pc_request (rq)) { pc =idefloppy_next_pc_storage (drive);idefloppy_blockpc_cmd (floppy, pc, rq);
@@ -915,7 +896,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,* Add a special packet command request to the tail of the request queue, * and wait for it to be serviced. */ -static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc) +static int idefloppy_queue_pc_tail (ide_drive_t *drive,struct ide_atapi_pc *pc) {struct ide_floppy_obj *floppy = drive->driver_data;struct request rq;
@@ -935,7 +916,7 @@ static int idefloppy_queue_pc_tail(ide_drive_t *drive, idefloppy_pc_t *pc)static int ide_floppy_get_flexible_disk_page (ide_drive_t *drive) {idefloppy_floppy_t *floppy = drive->driver_data; -idefloppy_pc_t pc; +struct ide_atapi_pc pc;u8 *page;int capacity, lba_capacity;u16 transfer_rate, sector_size, cyls, rpm;
@@ -949,16 +930,16 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive) " parameters\n");return 1 ; } - floppy->wp = !!(pc.buffer[3 ] &0x80 ); + floppy->wp = !!(pc.buf[3 ] &0x80 );set_disk_ro (floppy->disk, floppy->wp); - page = &pc.buffer[8 ]; + page = &pc.buf[8 ]; - transfer_rate =be16_to_cpu (*(u16 *)&pc.buffer[8 +2 ]); - sector_size =be16_to_cpu (*(u16 *)&pc.buffer[8 +6 ]); - cyls =be16_to_cpu (*(u16 *)&pc.buffer[8 +8 ]); - rpm =be16_to_cpu (*(u16 *)&pc.buffer[8 +28 ]); - heads = pc.buffer[8 +4 ]; - sectors = pc.buffer[8 +5 ]; + transfer_rate =be16_to_cpu (*(u16 *)&pc.buf[8 +2 ]); + sector_size =be16_to_cpu (*(u16 *)&pc.buf[8 +6 ]); + cyls =be16_to_cpu (*(u16 *)&pc.buf[8 +8 ]); + rpm =be16_to_cpu (*(u16 *)&pc.buf[8 +28 ]); + heads = pc.buf[8 +4 ]; + sectors = pc.buf[8 +5 ]; capacity = cyls * heads * sectors * sector_size;
@@ -987,7 +968,7 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)static int idefloppy_get_sfrp_bit (ide_drive_t *drive) {idefloppy_floppy_t *floppy = drive->driver_data; -idefloppy_pc_t pc; +struct ide_atapi_pc pc; floppy->srfp =0 ; idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE,
@@ -997,7 +978,7 @@ static int idefloppy_get_sfrp_bit(ide_drive_t *drive)if (idefloppy_queue_pc_tail (drive, &pc))return 1 ; - floppy->srfp = pc.buffer[8 +2 ] &0x40 ; + floppy->srfp = pc.buf[8 +2 ] &0x40 ;return (0 ); }
@@ -1008,7 +989,7 @@ static int idefloppy_get_sfrp_bit(ide_drive_t *drive)static int ide_floppy_get_capacity (ide_drive_t *drive) {idefloppy_floppy_t *floppy = drive->driver_data; -idefloppy_pc_t pc; +struct ide_atapi_pc pc;u8 *cap_desc;u8 header_len, desc_cnt;int i, rc =1 , blocks, length;
@@ -1024,15 +1005,15 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)printk (KERN_ERR "ide-floppy: Can't get floppy parameters\n" );return 1 ; } - header_len = pc.buffer[3 ]; - cap_desc = &pc.buffer[4 ]; + header_len = pc.buf[3 ]; + cap_desc = &pc.buf[4 ]; desc_cnt = header_len /8 ;/* capacity descriptor of 8 bytes */ for (i =0 ; i < desc_cnt; i++) {unsigned int desc_start =4 + i*8 ; - blocks =be32_to_cpu (*(u32 *)&pc.buffer[desc_start]); - length =be16_to_cpu (*(u16 *)&pc.buffer[desc_start +6 ]); + blocks =be32_to_cpu (*(u32 *)&pc.buf[desc_start]); + length =be16_to_cpu (*(u16 *)&pc.buf[desc_start +6 ]);debug_log ("Descriptor %d: %dkB, %d blocks, %d sector size\n" , i, blocks * length /1024 , blocks, length);
@@ -1043,7 +1024,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)* the code below is valid only for the 1st descriptor, ie i=0 */ -switch (pc.buffer[desc_start +4 ] &0x03 ) { +switch (pc.buf[desc_start +4 ] &0x03 ) {/* Clik! drive returns this instead of CAPACITY_CURRENT */ case CAPACITY_UNFORMATTED :if (!(floppy->flags &IDEFLOPPY_FLAG_CLIK_DRIVE ))
@@ -1088,7 +1069,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)break ; }debug_log ("Descriptor 0 Code: %d\n" , - pc.buffer[desc_start +4 ] &0x03 ); + pc.buf[desc_start +4 ] &0x03 ); }/* Clik! disk does not support get_flexible_disk_page */
@@ -1120,7 +1101,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)static int ide_floppy_get_format_capacities (ide_drive_t *drive,int __user *arg) { -idefloppy_pc_t pc; +struct ide_atapi_pc pc;u8 header_len, desc_cnt;int i, blocks, length, u_array_size, u_index;int __user *argp;
@@ -1136,7 +1117,7 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)printk (KERN_ERR "ide-floppy: Can't get floppy parameters\n" );return (-EIO ); } - header_len = pc.buffer[3 ]; + header_len = pc.buf[3 ]; desc_cnt = header_len /8 ;/* capacity descriptor of 8 bytes */ u_index =0 ;
@@ -1153,8 +1134,8 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)if (u_index >= u_array_size)break ;/* User-supplied buffer too small */ - blocks =be32_to_cpu (*(u32 *)&pc.buffer[desc_start]); - length =be16_to_cpu (*(u16 *)&pc.buffer[desc_start +6 ]); + blocks =be32_to_cpu (*(u32 *)&pc.buf[desc_start]); + length =be16_to_cpu (*(u16 *)&pc.buf[desc_start +6 ]);if (put_user (blocks, argp))return (-EFAULT );
@@ -1185,7 +1166,7 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)static int idefloppy_get_format_progress (ide_drive_t *drive,int __user *arg) {idefloppy_floppy_t *floppy = drive->driver_data; -idefloppy_pc_t pc; +struct ide_atapi_pc pc;int progress_indication =0x10000 ;if (floppy->srfp) {
@@ -1391,7 +1372,7 @@ static int idefloppy_open(struct inode *inode, struct file *filp)struct gendisk *disk = inode->i_bdev->bd_disk;struct ide_floppy_obj *floppy;ide_drive_t *drive; -idefloppy_pc_t pc; +struct ide_atapi_pc pc;int ret =0 ;debug_log ("Reached %s\n" , __func__);
@@ -1454,7 +1435,7 @@ static int idefloppy_release(struct inode *inode, struct file *filp)struct gendisk *disk = inode->i_bdev->bd_disk;struct ide_floppy_obj *floppy =ide_floppy_g (disk);ide_drive_t *drive = floppy->drive; -idefloppy_pc_t pc; +struct ide_atapi_pc pc;debug_log ("Reached %s\n" , __func__);
@@ -1486,8 +1467,8 @@ static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)return 0 ; } -static int ide_floppy_lockdoor (idefloppy_floppy_t *floppy,idefloppy_pc_t *pc, -unsigned long arg,unsigned int cmd) +static int ide_floppy_lockdoor (idefloppy_floppy_t *floppy, +struct ide_atapi_pc *pc,unsigned long arg,unsigned int cmd) {if (floppy->openers >1 )return -EBUSY ;
@@ -1516,7 +1497,7 @@ static int ide_floppy_format_unit(idefloppy_floppy_t *floppy, int __user *arg) {int blocks, length, flags, err =0 ; -idefloppy_pc_t pc; +struct ide_atapi_pc pc;if (floppy->openers >1 ) {/* Don't format if someone is using the disk */
@@ -1567,7 +1548,7 @@ static int idefloppy_ioctl(struct inode *inode, struct file *file,struct block_device *bdev = inode->i_bdev;struct ide_floppy_obj *floppy =ide_floppy_g (bdev->bd_disk);ide_drive_t *drive = floppy->drive; -idefloppy_pc_t pc; +struct ide_atapi_pc pc;void __user *argp = (void __user *)arg;int err;
Signature · 1 line
1.5.3.7
PATCH 4/4 ide-scsi: convert driver to using generic ide_atapi_pc
In reply to Borislav Petkov--- drivers/scsi/ide-scsi.c | 133 ++++++++++++++++++++++------------------------- 1 files changed, 62 insertions(+), 71 deletions(-)
drivers/scsi/ide-scsi.c +62 -71
@@ -60,23 +60,6 @@#define IDESCSI_DEBUG_LOG 0 -typedef struct idescsi_pc_s { -u8 c[12 ];/* Actual packet bytes */ -int request_transfer;/* Bytes to transfer */ -int actually_transferred;/* Bytes actually transferred */ -int buffer_size;/* Size of our data buffer */ -struct request *rq;/* The corresponding request */ -u8 *buffer;/* Data buffer */ -u8 *current_position;/* Pointer into the above buffer */ -struct scatterlist *sg;/* Scatter gather table */ -unsigned int sg_cnt;/* Number of entries in sg */ -int b_count;/* Bytes transferred from current entry */ -struct scsi_cmnd *scsi_cmd;/* SCSI command */ -void (*done)(struct scsi_cmnd *);/* Scsi completion routine */ -unsigned long flags;/* Status/Action flags */ -unsigned long timeout;/* Command timeout */ -}idescsi_pc_t ; -/* * Packet command status bits. */
@@ -101,14 +84,15 @@ typedef struct ide_scsi_obj {struct gendisk *disk;struct Scsi_Host *host; -idescsi_pc_t *pc;/* Current packet command */ +struct ide_atapi_pc *pc;/* Current packet command */ unsigned long flags;/* Status/Action flags */ unsigned long transform;/* SCSI cmd translation layer */ unsigned long log;/* log flags */ } idescsi_scsi_t;static DEFINE_MUTEX (idescsi_ref_mutex); -static int idescsi_nocd;/* Set by module param to skip cd */ +/* Set by module param to skip cd */ +static int idescsi_nocd;#define ide_scsi_g (disk) \ container_of((disk)->private_data, struct ide_scsi_obj, driver)
@@ -155,7 +139,8 @@ static inline idescsi_scsi_t *drive_to_idescsi(ide_drive_t *ide_drive)/* * PIO data transfer routines using the scatter gather table. */ -static void idescsi_input_buffers (ide_drive_t *drive,idescsi_pc_t *pc,unsigned int bcount) +static void idescsi_input_buffers (ide_drive_t *drive,struct ide_atapi_pc *pc, +unsigned int bcount) {int count;char *buf;
@@ -192,7 +177,8 @@ static void idescsi_input_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigne } } -static void idescsi_output_buffers (ide_drive_t *drive,idescsi_pc_t *pc,unsigned int bcount) +static void idescsi_output_buffers (ide_drive_t *drive,struct ide_atapi_pc *pc, +unsigned int bcount) {int count;char *buf;
@@ -234,15 +220,16 @@ static void ide_scsi_hex_dump(u8 *data, int len)print_hex_dump (KERN_CONT ,"" ,DUMP_PREFIX_NONE ,16 ,1 , data, len,0 ); } -static int idescsi_check_condition (ide_drive_t *drive,struct request *failed_command) +static int idescsi_check_condition (ide_drive_t *drive, +struct request *failed_cmd) {idescsi_scsi_t *scsi =drive_to_idescsi (drive); -idescsi_pc_t *pc; +struct ide_atapi_pc *pc;struct request *rq;u8 *buf;/* stuff a sense request in front of our current request */ - pc =kzalloc (sizeof (idescsi_pc_t),GFP_ATOMIC ); + pc =kzalloc (sizeof (struct ide_atapi_pc ),GFP_ATOMIC ); rq =kmalloc (sizeof (struct request ),GFP_ATOMIC ); buf =kzalloc (SCSI_SENSE_BUFFERSIZE ,GFP_ATOMIC );if (!pc || !rq || !buf) {
@@ -254,14 +241,14 @@ static int idescsi_check_condition(ide_drive_t *drive, struct request *failed_coide_init_drive_cmd (rq); rq->special = (char *) pc; pc->rq = rq; - pc->buffer = buf; + pc->buf = buf; pc->c[0 ] =REQUEST_SENSE ; - pc->c[4 ] = pc->request_transfer = pc->buffer_size =SCSI_SENSE_BUFFERSIZE ; + pc->c[4 ] = pc->req_xfer = pc->buf_size =SCSI_SENSE_BUFFERSIZE ; rq->cmd_type =REQ_TYPE_SENSE ; pc->timeout = jiffies +WAIT_READY ;/* NOTE! Save the failed packet command in "rq->buffer" */ - rq->buffer = (void *) failed_command->special; - pc->scsi_cmd = ((idescsi_pc_t *) failed_command->special)->scsi_cmd; + rq->buffer = (void *) failed_cmd->special; + pc->scsi_cmd = ((struct ide_atapi_pc *) failed_cmd->special)->scsi_cmd;if (test_bit (IDESCSI_LOG_CMD , &scsi->log)) {printk ("ide-scsi: %s: queue cmd = " , drive->name);ide_scsi_hex_dump (pc->c,6 );
@@ -294,7 +281,7 @@ idescsi_atapi_abort(ide_drive_t *drive, struct request *rq) {#if IDESCSI_DEBUG_LOG printk (KERN_WARNING "idescsi_atapi_abort called for %lu\n" , - ((idescsi_pc_t *) rq->special)->scsi_cmd->serial_number); + ((struct ide_atapi_pc *) rq->special)->scsi_cmd->serial_number);#endif rq->errors |=ERROR_MAX ;
@@ -307,7 +294,7 @@ static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs) {idescsi_scsi_t *scsi =drive_to_idescsi (drive);struct request *rq =HWGROUP (drive)->rq; -idescsi_pc_t *pc = (idescsi_pc_t *) rq->special; +struct ide_atapi_pc *pc = (struct ide_atapi_pc *) rq->special;int log =test_bit (IDESCSI_LOG_CMD , &scsi->log);struct Scsi_Host *host;int errors = rq->errors;
@@ -319,13 +306,14 @@ static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs) }ide_end_drive_cmd (drive,0 ,0 );if (blk_sense_request (rq)) { -idescsi_pc_t *opc = (idescsi_pc_t *) rq->buffer; +struct ide_atapi_pc *opc = (struct ide_atapi_pc *) rq->buffer;if (log) {printk ("ide-scsi: %s: wrap up check %lu, rst = " , drive->name, opc->scsi_cmd->serial_number); -ide_scsi_hex_dump (pc->buffer,16 ); +ide_scsi_hex_dump (pc->buf,16 ); } -memcpy ((void *) opc->scsi_cmd->sense_buffer, pc->buffer,SCSI_SENSE_BUFFERSIZE ); -kfree (pc->buffer); +memcpy ((void *) opc->scsi_cmd->sense_buffer, pc->buf, +SCSI_SENSE_BUFFERSIZE ); +kfree (pc->buf);kfree (pc);kfree (rq); pc = opc;
@@ -361,7 +349,7 @@ static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs)return 0 ; } -static inline unsigned long get_timeout (idescsi_pc_t *pc) +static inline unsigned long get_timeout (struct ide_atapi_pc *pc) { return max_t(unsigned long, WAIT_CMD, pc->timeout - jiffies); }
@@ -369,7 +357,7 @@ static inline unsigned long get_timeout(idescsi_pc_t *pc)static int idescsi_expiry (ide_drive_t *drive) {idescsi_scsi_t *scsi =drive_to_idescsi (drive); -idescsi_pc_t *pc = scsi->pc; +struct ide_atapi_pc *pc = scsi->pc;#if IDESCSI_DEBUG_LOG printk (KERN_WARNING "idescsi_expiry called for %lu at %lu\n" , pc->scsi_cmd->serial_number, jiffies);
@@ -386,7 +374,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive) {idescsi_scsi_t *scsi =drive_to_idescsi (drive);ide_hwif_t *hwif = drive->hwif; -idescsi_pc_t *pc = scsi->pc; +struct ide_atapi_pc *pc = scsi->pc;struct request *rq = pc->rq;unsigned int temp;u16 bcount;
@@ -409,7 +397,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)#if IDESCSI_DEBUG_LOG printk ("ide-scsi: %s: DMA complete\n" , drive->name);#endif /* IDESCSI_DEBUG_LOG */ - pc->actually_transferred=pc->request_transfer; + pc->xferred = pc->req_xfer; (void )HWIF (drive)->ide_dma_end (drive); }
@@ -419,7 +407,8 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)if ((stat &DRQ_STAT ) ==0 ) {/* No more interrupts */ if (test_bit (IDESCSI_LOG_CMD , &scsi->log)) -printk (KERN_INFO "Packet command completed, %d bytes transferred\n" , pc->actually_transferred); +printk (KERN_INFO "Packet command completed, %d bytes" +" transferred\n" , pc->xferred);local_irq_enable_in_hardirq ();if (stat &ERR_STAT ) rq->errors++;
@@ -435,25 +424,26 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)return ide_do_reset (drive); }if (ireason &IO ) { - temp = pc->actually_transferred + bcount; -if (temp > pc->request_transfer) { -if (temp > pc->buffer_size) { + temp = pc->xferred + bcount; +if (temp > pc->req_xfer) { +if (temp > pc->buf_size) {printk (KERN_ERR "ide-scsi: The scsi wants to " "send us more data than expected " "- discarding data\n" ); - temp = pc->buffer_size - pc->actually_transferred; + temp = pc->buf_size - pc->xferred;if (temp) {clear_bit (PC_WRITING , &pc->flags);if (pc->sg) -idescsi_input_buffers (drive, pc, temp); +idescsi_input_buffers (drive, pc, + temp);else - drive->hwif->atapi_input_bytes (drive, pc->current_position, temp); + drive->hwif->atapi_input_bytes (drive, pc->cur_pos, temp);printk (KERN_ERR "ide-scsi: transferred" " %d of %d bytes\n" , temp, bcount); } - pc->actually_transferred += temp; - pc->current_position += temp; + pc->xferred += temp; + pc->cur_pos += temp;ide_atapi_discard_data (drive, bcount - temp);ide_set_handler (drive, &idescsi_pc_intr,get_timeout (pc), idescsi_expiry);return ide_started;
@@ -468,19 +458,19 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)if (pc->sg)idescsi_input_buffers (drive, pc, bcount);else - hwif->atapi_input_bytes (drive, pc->current_position, + hwif->atapi_input_bytes (drive, pc->cur_pos, bcount); }else {set_bit (PC_WRITING , &pc->flags);if (pc->sg)idescsi_output_buffers (drive, pc, bcount);else - hwif->atapi_output_bytes (drive, pc->current_position, + hwif->atapi_output_bytes (drive, pc->cur_pos, bcount); }/* Update the current position */ - pc->actually_transferred += bcount; - pc->current_position += bcount; + pc->xferred += bcount; + pc->cur_pos += bcount;/* And set the interrupt handler again */ ide_set_handler (drive, &idescsi_pc_intr,get_timeout (pc), idescsi_expiry);
@@ -491,7 +481,7 @@ static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive) {ide_hwif_t *hwif = drive->hwif;idescsi_scsi_t *scsi =drive_to_idescsi (drive); -idescsi_pc_t *pc = scsi->pc; +struct ide_atapi_pc *pc = scsi->pc;ide_startstop_t startstop;u8 ireason;
@@ -518,7 +508,7 @@ static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive)return ide_started; } -static inline int idescsi_set_direction (idescsi_pc_t *pc) +static inline int idescsi_set_direction (struct ide_atapi_pc *pc) {switch (pc->c[0 ]) {case READ_6 :case READ_10 :case READ_12 :
@@ -532,13 +522,13 @@ static inline int idescsi_set_direction(idescsi_pc_t *pc) } } -static int idescsi_map_sg (ide_drive_t *drive,idescsi_pc_t *pc) +static int idescsi_map_sg (ide_drive_t *drive,struct ide_atapi_pc *pc) {ide_hwif_t *hwif = drive->hwif;struct scatterlist *sg, *scsi_sg;int segments; -if (!pc->request_transfer || pc->request_transfer %1024 ) +if (!pc->req_xfer || pc->req_xfer %1024 )return 1 ;if (idescsi_set_direction (pc))
@@ -557,21 +547,21 @@ static int idescsi_map_sg(ide_drive_t *drive, idescsi_pc_t *pc)return 0 ; } -/* -* Issue a packet command -*/ -static ide_startstop_t idescsi_issue_pc (ide_drive_t *drive,idescsi_pc_t *pc) +static ide_startstop_t idescsi_issue_pc (ide_drive_t *drive, +struct ide_atapi_pc *pc) {idescsi_scsi_t *scsi =drive_to_idescsi (drive);ide_hwif_t *hwif = drive->hwif;u16 bcount;u8 dma =0 ; - scsi->pc=pc;/* Set the current packet command */ - pc->actually_transferred=0 ;/* We haven't transferred any data yet */ - pc->current_position=pc->buffer; +/* Set the current packet command */ + scsi->pc = pc; +/* We haven't transferred any data yet */ + pc->xferred =0 ; + pc->cur_pos = pc->buf;/* Request to transfer the entire buffer at once */ - bcount =min (pc->request_transfer,63 *1024 ); + bcount =min (pc->req_xfer,63 *1024 );if (drive->using_dma && !idescsi_map_sg (drive, pc)) { hwif->sg_mapped =1 ;
@@ -606,7 +596,8 @@ static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *r#endif /* IDESCSI_DEBUG_LOG */ if (blk_sense_request (rq) ||blk_special_request (rq)) { -return idescsi_issue_pc (drive, (idescsi_pc_t *) rq->special); +return idescsi_issue_pc (drive, + (struct ide_atapi_pc *) rq->special); }blk_dump_rq_flags (rq,"ide-scsi: unsup command" );idescsi_end_request (drive,0 ,0 );
@@ -764,15 +755,15 @@ static int idescsi_queue (struct scsi_cmnd *cmd,idescsi_scsi_t *scsi =scsihost_to_idescsi (host);ide_drive_t *drive = scsi->drive;struct request *rq =NULL ; -idescsi_pc_t *pc =NULL ; +struct ide_atapi_pc *pc =NULL ;if (!drive) {scmd_printk (KERN_ERR , cmd,"drive not present\n" ); goto abort; } scsi =drive_to_idescsi (drive); - pc =kmalloc (sizeof (idescsi_pc_t),GFP_ATOMIC ); - rq =kmalloc (sizeof (struct request ),GFP_ATOMIC ); + pc =kmalloc (sizeof (struct ide_atapi_pc ),GFP_ATOMIC ); + rq =kmalloc (sizeof (struct request ),GFP_ATOMIC );if (rq ==NULL || pc ==NULL ) {printk (KERN_ERR "ide-scsi: %s: out of memory\n" , drive->name); goto abort;
@@ -782,11 +773,11 @@ static int idescsi_queue (struct scsi_cmnd *cmd, pc->flags =0 ; pc->rq = rq;memcpy (pc->c, cmd->cmnd, cmd->cmd_len); - pc->buffer =NULL ; + pc->buf =NULL ; pc->sg =scsi_sglist (cmd); pc->sg_cnt =scsi_sg_count (cmd); pc->b_count =0 ; - pc->request_transfer = pc->buffer_size =scsi_bufflen (cmd); + pc->req_xfer = pc->buf_size =scsi_bufflen (cmd); pc->scsi_cmd = cmd; pc->done = done; pc->timeout = jiffies + cmd->timeout_per_command;
@@ -857,7 +848,7 @@ static int idescsi_eh_abort (struct scsi_cmnd *cmd)printk (KERN_ERR "ide-scsi: cmd aborted!\n" );if (blk_sense_request (scsi->pc->rq)) -kfree (scsi->pc->buffer); +kfree (scsi->pc->buf);kfree (scsi->pc->rq);kfree (scsi->pc); scsi->pc =NULL ;
@@ -907,7 +898,7 @@ static int idescsi_eh_reset (struct scsi_cmnd *cmd)if (__blk_end_request (req, -EIO ,0 ))BUG ();if (blk_sense_request (req)) -kfree (scsi->pc->buffer); +kfree (scsi->pc->buf);kfree (scsi->pc); scsi->pc =NULL ;kfree (req);
Signature · 1 line
1.5.3.7
PATCH 3/4 ide-tape: convert driver to using generic ide_atapi_pc
In reply to Borislav Petkov--- drivers/ide/ide-tape.c | 251 ++++++++++++++++++++++-------------------------- 1 files changed, 114 insertions(+), 137 deletions(-)
drivers/ide/ide-tape.c +114 -137
@@ -181,34 +181,6 @@ struct idetape_bh {char *b_data; }; -typedef struct idetape_packet_command_s { -/* Actual packet bytes */ -u8 c[12 ]; -/* On each retry, we increment retries */ -int retries; -/* Error code */ -int error; -/* Bytes to transfer */ -int request_transfer; -/* Bytes actually transferred */ -int actually_transferred; -/* Size of our data buffer */ -int buffer_size; -struct idetape_bh *bh; -char *b_data; -int b_count; -/* Data buffer */ -u8 *buffer; -/* Pointer into the above buffer */ -u8 *current_position; -/* Called when this packet command is completed */ -ide_startstop_t (*callback) (ide_drive_t *); -/* Temporary buffer */ -u8 pc_buffer[IDETAPE_PC_BUFFER_SIZE ]; -/* Status/Action bit flags: long for set_bit */ -unsigned long flags; -}idetape_pc_t ; -/* Packet command flag bits. */ enum {/* Set when an error is considered normal - We won't retry */
@@ -316,11 +288,11 @@ typedef struct ide_tape_obj {* retry, to get detailed information on what went wrong. */ /* Current packet command */ -idetape_pc_t *pc; +struct ide_atapi_pc *pc;/* Last failed packet command */ -idetape_pc_t *failed_pc; +struct ide_atapi_pc *failed_pc;/* Packet command stack */ -idetape_pc_t pc_stack[IDETAPE_PC_STACK ]; +struct ide_atapi_pc pc_stack[IDETAPE_PC_STACK ];/* Next free packet command storage space */ int pc_stack_index;struct request rq_stack[IDETAPE_PC_STACK ];
@@ -524,7 +496,7 @@ static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i)return tape; } -static void idetape_input_buffers (ide_drive_t *drive,idetape_pc_t *pc, +static void idetape_input_buffers (ide_drive_t *drive,struct ide_atapi_pc *pc,unsigned int bcount) {struct idetape_bh *bh = pc->bh;
@@ -553,7 +525,7 @@ static void idetape_input_buffers(ide_drive_t *drive, idetape_pc_t *pc, pc->bh = bh; } -static void idetape_output_buffers (ide_drive_t *drive,idetape_pc_t *pc, +static void idetape_output_buffers (ide_drive_t *drive,struct ide_atapi_pc *pc,unsigned int bcount) {struct idetape_bh *bh = pc->bh;
@@ -581,11 +553,11 @@ static void idetape_output_buffers(ide_drive_t *drive, idetape_pc_t *pc, } } -static void idetape_update_buffers (idetape_pc_t *pc) +static void idetape_update_buffers (struct ide_atapi_pc *pc) {struct idetape_bh *bh = pc->bh;int count; -unsigned int bcount = pc->actually_transferred; +unsigned int bcount = pc->xferred;if (pc->flags &PC_FLAG_WRITING )return ;
@@ -610,7 +582,7 @@ static void idetape_update_buffers(idetape_pc_t *pc)* driver. A storage space for a maximum of IDETAPE_PC_STACK packet * commands is allocated at initialization time. */ -static idetape_pc_t *idetape_next_pc_storage (ide_drive_t *drive) +static struct ide_atapi_pc *idetape_next_pc_storage (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data;
@@ -645,14 +617,14 @@ static struct request *idetape_next_rq_storage(ide_drive_t *drive)return (&tape->rq_stack[tape->rq_stack_index++]); } -static void idetape_init_pc (idetape_pc_t *pc) +static void idetape_init_pc (struct ide_atapi_pc *pc) {memset (pc->c,0 ,12 ); pc->retries =0 ; pc->flags =0 ; - pc->request_transfer =0 ; - pc->buffer = pc->pc_buffer; - pc->buffer_size =IDETAPE_PC_BUFFER_SIZE ; + pc->req_xfer =0 ; + pc->buf = pc->pc_buf; + pc->buf_size =IDETAPE_PC_BUFFER_SIZE ; pc->bh =NULL ; pc->b_data =NULL ; }
@@ -664,7 +636,7 @@ static void idetape_init_pc(idetape_pc_t *pc)static void idetape_analyze_error (ide_drive_t *drive,u8 *sense) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t *pc = tape->failed_pc; +struct ide_atapi_pc *pc = tape->failed_pc; tape->sense_key = sense[2 ] &0xF ; tape->asc = sense[12 ];
@@ -673,9 +645,9 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense)debug_log (DBG_ERR ,"pc = %x, sense key = %x, asc = %x, ascq = %x\n" , pc->c[0 ], tape->sense_key, tape->asc, tape->ascq); -/* Correct pc->actually_transferred by asking the tape. */ +/* Correct pc->xferred by asking the tape. */ if (pc->flags &PC_FLAG_DMA_ERROR ) { - pc->actually_transferred = pc->request_transfer - + pc->xferred = pc->req_xfer - tape->blk_size *be32_to_cpu (get_unaligned ((u32 *)&sense[3 ]));idetape_update_buffers (pc);
@@ -713,7 +685,7 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) pc->flags |=PC_FLAG_ABORT ; }if (!(pc->flags &PC_FLAG_ABORT ) && - pc->actually_transferred) + pc->xferred) pc->retries =IDETAPE_MAX_PC_RETRIES +1 ; } }
@@ -922,7 +894,7 @@ static ide_startstop_t idetape_request_sense_callback(ide_drive_t *drive)debug_log (DBG_PROCS ,"Enter %s\n" , __func__);if (!tape->pc->error) { -idetape_analyze_error (drive, tape->pc->buffer); +idetape_analyze_error (drive, tape->pc->buf);idetape_end_request (drive,1 ,0 ); }else { printk(KERN_ERR "ide-tape: Error in REQUEST SENSE itself - "
@@ -932,13 +904,13 @@ static ide_startstop_t idetape_request_sense_callback(ide_drive_t *drive)return ide_stopped; } -static void idetape_create_request_sense_cmd (idetape_pc_t *pc) +static void idetape_create_request_sense_cmd (struct ide_atapi_pc *pc) {idetape_init_pc (pc); pc->c[0 ] =REQUEST_SENSE ; pc->c[4 ] =20 ; - pc->request_transfer =20 ; - pc->callback = &idetape_request_sense_callback; + pc->req_xfer =20 ; + pc->idetape_callback = &idetape_request_sense_callback; }static void idetape_init_rq (struct request *rq,u8 cmd)
@@ -963,7 +935,7 @@ static void idetape_init_rq(struct request *rq, u8 cmd)* handling functions should queue request to the lower level part and wait for * their completion using idetape_queue_pc_tail or idetape_queue_rw_tail. */ -static void idetape_queue_pc_head (ide_drive_t *drive,idetape_pc_t *pc, +static void idetape_queue_pc_head (ide_drive_t *drive,struct ide_atapi_pc *pc,struct request *rq) {struct ide_tape_obj *tape = drive->driver_data;
@@ -982,7 +954,7 @@ static void idetape_queue_pc_head(ide_drive_t *drive, idetape_pc_t *pc,static ide_startstop_t idetape_retry_pc (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t *pc; +struct ide_atapi_pc *pc;struct request *rq; (void )ide_read_error (drive);
@@ -1008,7 +980,7 @@ static void idetape_postpone_request(ide_drive_t *drive)ide_stall_queue (drive, tape->dsc_poll_freq); } -typedef void idetape_io_buf (ide_drive_t *,idetape_pc_t *,unsigned int ); +typedef void idetape_io_buf (ide_drive_t *,struct ide_atapi_pc *,unsigned int );/* * This is the usual interrupt handler which will be called during a packet
@@ -1021,7 +993,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) {ide_hwif_t *hwif = drive->hwif;idetape_tape_t *tape = drive->driver_data; -idetape_pc_t *pc = tape->pc; +struct ide_atapi_pc *pc = tape->pc;xfer_func_t *xferfunc;idetape_io_buf *iobuf;unsigned int temp;
@@ -1061,7 +1033,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)*/ pc->flags |=PC_FLAG_DMA_ERROR ; }else { - pc->actually_transferred = pc->request_transfer; + pc->xferred = pc->req_xfer;idetape_update_buffers (pc); }debug_log (DBG_PROCS ,"DMA finished\n" );
@@ -1071,7 +1043,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)/* No more interrupts */ if ((stat &DRQ_STAT ) ==0 ) {debug_log (DBG_SENSE ,"Packet command completed, %d bytes" -" transferred\n" , pc->actually_transferred); +" transferred\n" , pc->xferred); pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS ;local_irq_enable ();
@@ -1115,7 +1087,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)if (tape->failed_pc == pc) tape->failed_pc =NULL ;/* Command finished - Call the callback function */ -return pc->callback (drive); +return pc->idetape_callback (drive); }if (pc->flags &PC_FLAG_DMA_IN_PROGRESS ) {
@@ -1146,9 +1118,9 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) }if (!(pc->flags &PC_FLAG_WRITING )) {/* Reading - Check that we have enough space */ - temp = pc->actually_transferred + bcount; -if (temp > pc->request_transfer) { -if (temp > pc->buffer_size) { + temp = pc->xferred + bcount; +if (temp > pc->req_xfer) { +if (temp > pc->buf_size) {printk (KERN_ERR "ide-tape: The tape wants to " "send us more data than expected " "- discarding data\n" );
@@ -1170,11 +1142,11 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)if (pc->bh)iobuf (drive, pc, bcount);else -xferfunc (drive, pc->current_position, bcount); +xferfunc (drive, pc->cur_pos, bcount);/* Update the current position */ - pc->actually_transferred += bcount; - pc->current_position += bcount; + pc->xferred += bcount; + pc->cur_pos += bcount;debug_log (DBG_SENSE ,"[cmd %x] transferred %d bytes on that intr.\n" , pc->c[0 ], bcount);
@@ -1224,7 +1196,7 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive) {ide_hwif_t *hwif = drive->hwif;idetape_tape_t *tape = drive->driver_data; -idetape_pc_t *pc = tape->pc; +struct ide_atapi_pc *pc = tape->pc;int retries =100 ;ide_startstop_t startstop;u8 ireason;
@@ -1264,7 +1236,8 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)return ide_started; } -static ide_startstop_t idetape_issue_pc (ide_drive_t *drive,idetape_pc_t *pc) +static ide_startstop_t idetape_issue_pc (ide_drive_t *drive, +struct ide_atapi_pc *pc) {ide_hwif_t *hwif = drive->hwif;idetape_tape_t *tape = drive->driver_data;
@@ -1304,16 +1277,16 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, idetape_pc_t *pc) pc->error =IDETAPE_ERROR_GENERAL ; } tape->failed_pc =NULL ; -return pc->callback (drive); +return pc->idetape_callback (drive); }debug_log (DBG_SENSE ,"Retry #%d, cmd = %02X\n" , pc->retries, pc->c[0 ]); pc->retries++;/* We haven't transferred any data yet */ - pc->actually_transferred =0 ; - pc->current_position = pc->buffer; + pc->xferred =0 ; + pc->cur_pos = pc->buf;/* Request to transfer the entire buffer at once */ - bcount = pc->request_transfer; + bcount = pc->req_xfer;if (pc->flags &PC_FLAG_DMA_ERROR ) { pc->flags &= ~PC_FLAG_DMA_ERROR ;
@@ -1351,7 +1324,7 @@ static ide_startstop_t idetape_pc_callback(ide_drive_t *drive) }/* A mode sense command is used to "sense" tape parameters. */ -static void idetape_create_mode_sense_cmd (idetape_pc_t *pc,u8 page_code) +static void idetape_create_mode_sense_cmd (struct ide_atapi_pc *pc,u8 page_code) {idetape_init_pc (pc); pc->c[0 ] =MODE_SENSE ;
@@ -1370,12 +1343,12 @@ static void idetape_create_mode_sense_cmd(idetape_pc_t *pc, u8 page_code)/* We will just discard data in that case */ pc->c[4 ] =255 ;if (page_code ==IDETAPE_BLOCK_DESCRIPTOR ) - pc->request_transfer =12 ; + pc->req_xfer =12 ;else if (page_code ==IDETAPE_CAPABILITIES_PAGE ) - pc->request_transfer =24 ; + pc->req_xfer =24 ;else - pc->request_transfer =50 ; - pc->callback = &idetape_pc_callback; + pc->req_xfer =50 ; + pc->idetape_callback = &idetape_pc_callback; }static void idetape_calculate_speeds (ide_drive_t *drive)
@@ -1444,7 +1417,7 @@ static void idetape_calculate_speeds(ide_drive_t *drive)static ide_startstop_t idetape_media_access_finished (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t *pc = tape->pc; +struct ide_atapi_pc *pc = tape->pc;u8 stat; stat =ide_read_status (drive);
@@ -1465,14 +1438,14 @@ static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) pc->error =IDETAPE_ERROR_GENERAL ; tape->failed_pc =NULL ; } -return pc->callback (drive); +return pc->idetape_callback (drive); }static ide_startstop_t idetape_rw_callback (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data;struct request *rq =HWGROUP (drive)->rq; -int blocks = tape->pc->actually_transferred / tape->blk_size; +int blocks = tape->pc->xferred / tape->blk_size; tape->avg_size += blocks * tape->blk_size; tape->insert_size += blocks * tape->blk_size;
@@ -1504,39 +1477,41 @@ static ide_startstop_t idetape_rw_callback(ide_drive_t *drive)return ide_stopped; } -static void idetape_create_read_cmd (idetape_tape_t *tape,idetape_pc_t *pc, +static void idetape_create_read_cmd (idetape_tape_t *tape, +struct ide_atapi_pc *pc,unsigned int length,struct idetape_bh *bh) {idetape_init_pc (pc); pc->c[0 ] =READ_6 ;put_unaligned (cpu_to_be32 (length), (unsigned int *) &pc->c[1 ]); pc->c[1 ] =1 ; - pc->callback = &idetape_rw_callback; + pc->idetape_callback = &idetape_rw_callback; pc->bh = bh;atomic_set (&bh->b_count,0 ); - pc->buffer =NULL ; - pc->buffer_size = length * tape->blk_size; - pc->request_transfer = pc->buffer_size; -if (pc->request_transfer == tape->stage_size) + pc->buf =NULL ; + pc->buf_size = length * tape->blk_size; + pc->req_xfer = pc->buf_size; +if (pc->req_xfer == tape->stage_size) pc->flags |=PC_FLAG_DMA_RECOMMENDED ; } -static void idetape_create_write_cmd (idetape_tape_t *tape,idetape_pc_t *pc, +static void idetape_create_write_cmd (idetape_tape_t *tape, +struct ide_atapi_pc *pc,unsigned int length,struct idetape_bh *bh) {idetape_init_pc (pc); pc->c[0 ] =WRITE_6 ;put_unaligned (cpu_to_be32 (length), (unsigned int *) &pc->c[1 ]); pc->c[1 ] =1 ; - pc->callback = &idetape_rw_callback; + pc->idetape_callback = &idetape_rw_callback; pc->flags |=PC_FLAG_WRITING ; pc->bh = bh; pc->b_data = bh->b_data; pc->b_count =atomic_read (&bh->b_count); - pc->buffer =NULL ; - pc->buffer_size = length * tape->blk_size; - pc->request_transfer = pc->buffer_size; -if (pc->request_transfer == tape->stage_size) + pc->buf =NULL ; + pc->buf_size = length * tape->blk_size; + pc->req_xfer = pc->buf_size; +if (pc->req_xfer == tape->stage_size) pc->flags |=PC_FLAG_DMA_RECOMMENDED ; }
@@ -1544,7 +1519,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, struct request *rq, sector_t block) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t *pc =NULL ; +struct ide_atapi_pc *pc =NULL ;struct request *postponed_rq = tape->postponed_rq;u8 stat;
@@ -1631,7 +1606,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, goto out; }if (rq->cmd[0 ] &REQ_IDETAPE_PC1 ) { - pc = (idetape_pc_t *) rq->buffer; + pc = (struct ide_atapi_pc *) rq->buffer; rq->cmd[0 ] &= ~(REQ_IDETAPE_PC1 ); rq->cmd[0 ] |=REQ_IDETAPE_PC2 ; goto out;
@@ -1883,7 +1858,7 @@ static void idetape_wait_for_request(ide_drive_t *drive, struct request *rq)static ide_startstop_t idetape_read_position_callback (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data; -u8 *readpos = tape->pc->buffer; +u8 *readpos = tape->pc->buf;debug_log (DBG_PROCS ,"Enter %s\n" , __func__);
@@ -1919,20 +1894,20 @@ static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive)* writing a filemark otherwise. */ static void idetape_create_write_filemark_cmd (ide_drive_t *drive, -idetape_pc_t *pc,int write_filemark) +struct ide_atapi_pc *pc,int write_filemark) {idetape_init_pc (pc); pc->c[0 ] =WRITE_FILEMARKS ; pc->c[4 ] = write_filemark; pc->flags |=PC_FLAG_WAIT_FOR_DSC ; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback; } -static void idetape_create_test_unit_ready_cmd (idetape_pc_t *pc) +static void idetape_create_test_unit_ready_cmd (struct ide_atapi_pc *pc) {idetape_init_pc (pc); pc->c[0 ] =TEST_UNIT_READY ; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback; }/*
@@ -1948,7 +1923,7 @@ static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc)* 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,struct ide_atapi_pc *pc) {struct ide_tape_obj *tape = drive->driver_data;struct request rq;
@@ -1959,20 +1934,20 @@ static int __idetape_queue_pc_tail(ide_drive_t *drive, idetape_pc_t *pc)return ide_do_drive_cmd (drive, &rq, ide_wait); } -static void idetape_create_load_unload_cmd (ide_drive_t *drive,idetape_pc_t *pc, -int cmd) +static void idetape_create_load_unload_cmd (ide_drive_t *drive, +struct ide_atapi_pc *pc,int cmd) {idetape_init_pc (pc); pc->c[0 ] =START_STOP ; pc->c[4 ] = cmd; pc->flags |=PC_FLAG_WAIT_FOR_DSC ; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback; }static int idetape_wait_ready (ide_drive_t *drive,unsigned long timeout) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t pc; +struct ide_atapi_pc pc;int load_attempted =0 ;/* Wait for the tape to become ready */
@@ -2000,14 +1975,14 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)return -EIO ; } -static int idetape_queue_pc_tail (ide_drive_t *drive,idetape_pc_t *pc) +static int idetape_queue_pc_tail (ide_drive_t *drive,struct ide_atapi_pc *pc) {return __idetape_queue_pc_tail (drive, pc); }static int idetape_flush_tape_buffers (ide_drive_t *drive) { -idetape_pc_t pc; +struct ide_atapi_pc pc;int rc;idetape_create_write_filemark_cmd (drive, &pc,0 );
@@ -2018,18 +1993,18 @@ static int idetape_flush_tape_buffers(ide_drive_t *drive)return 0 ; } -static void idetape_create_read_position_cmd (idetape_pc_t *pc) +static void idetape_create_read_position_cmd (struct ide_atapi_pc *pc) {idetape_init_pc (pc); pc->c[0 ] =READ_POSITION ; - pc->request_transfer =20 ; - pc->callback = &idetape_read_position_callback; + pc->req_xfer =20 ; + pc->idetape_callback = &idetape_read_position_callback; }static int idetape_read_position (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t pc; +struct ide_atapi_pc pc;int position;debug_log (DBG_PROCS ,"Enter %s\n" , __func__);
@@ -2041,7 +2016,8 @@ static int idetape_read_position(ide_drive_t *drive)return position; } -static void idetape_create_locate_cmd (ide_drive_t *drive,idetape_pc_t *pc, +static void idetape_create_locate_cmd (ide_drive_t *drive, +struct ide_atapi_pc *pc,unsigned int block,u8 partition,int skip) {idetape_init_pc (pc);
@@ -2050,11 +2026,11 @@ static void idetape_create_locate_cmd(ide_drive_t *drive, idetape_pc_t *pc,put_unaligned (cpu_to_be32 (block), (unsigned int *) &pc->c[3 ]); pc->c[8 ] = partition; pc->flags |=PC_FLAG_WAIT_FOR_DSC ; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback; } -static int idetape_create_prevent_cmd (ide_drive_t *drive,idetape_pc_t *pc, -int prevent) +static int idetape_create_prevent_cmd (ide_drive_t *drive, +struct ide_atapi_pc *pc,int prevent) {idetape_tape_t *tape = drive->driver_data;
@@ -2065,7 +2041,7 @@ static int idetape_create_prevent_cmd(ide_drive_t *drive, idetape_pc_t *pc,idetape_init_pc (pc); pc->c[0 ] =ALLOW_MEDIUM_REMOVAL ; pc->c[4 ] = prevent; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback;return 1 ; }
@@ -2126,7 +2102,7 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block, {idetape_tape_t *tape = drive->driver_data;int retval; -idetape_pc_t pc; +struct ide_atapi_pc pc;if (tape->chrdev_dir ==IDETAPE_DIR_READ )__idetape_discard_read_pipeline (drive);
@@ -2209,40 +2185,41 @@ static void idetape_plug_pipeline(ide_drive_t *drive) } } -static void idetape_create_inquiry_cmd (idetape_pc_t *pc) +static void idetape_create_inquiry_cmd (struct ide_atapi_pc *pc) {idetape_init_pc (pc); pc->c[0 ] =INQUIRY ; pc->c[4 ] =254 ; - pc->request_transfer =254 ; - pc->callback = &idetape_pc_callback; + pc->req_xfer =254 ; + pc->idetape_callback = &idetape_pc_callback; } -static void idetape_create_rewind_cmd (ide_drive_t *drive,idetape_pc_t *pc) +static void idetape_create_rewind_cmd (ide_drive_t *drive, +struct ide_atapi_pc *pc) {idetape_init_pc (pc); pc->c[0 ] =REZERO_UNIT ; pc->flags |=PC_FLAG_WAIT_FOR_DSC ; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback; } -static void idetape_create_erase_cmd (idetape_pc_t *pc) +static void idetape_create_erase_cmd (struct ide_atapi_pc *pc) {idetape_init_pc (pc); pc->c[0 ] =ERASE ; pc->c[1 ] =1 ; pc->flags |=PC_FLAG_WAIT_FOR_DSC ; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback; } -static void idetape_create_space_cmd (idetape_pc_t *pc,int count,u8 cmd) +static void idetape_create_space_cmd (struct ide_atapi_pc *pc,int count,u8 cmd) {idetape_init_pc (pc); pc->c[0 ] =SPACE ;put_unaligned (cpu_to_be32 (count), (unsigned int *) &pc->c[1 ]); pc->c[1 ] = cmd; pc->flags |=PC_FLAG_WAIT_FOR_DSC ; - pc->callback = &idetape_pc_callback; + pc->idetape_callback = &idetape_pc_callback; }static void idetape_wait_first_stage (ide_drive_t *drive)
@@ -2620,7 +2597,7 @@ static int idetape_pipeline_size(ide_drive_t *drive)static int idetape_rewind_tape (ide_drive_t *drive) {int retval; -idetape_pc_t pc; +struct ide_atapi_pc pc;idetape_tape_t *tape; tape = drive->driver_data;
@@ -2683,7 +2660,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op, int mt_count) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t pc; +struct ide_atapi_pc pc;unsigned long flags;int retval, count =0 ;int sprev = !!(tape->caps[4 ] &0x20 );
@@ -2941,7 +2918,7 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,static int idetape_write_filemark (ide_drive_t *drive) { -idetape_pc_t pc; +struct ide_atapi_pc pc;/* Write a filemark */ idetape_create_write_filemark_cmd (drive, &pc,1 );
@@ -2969,7 +2946,7 @@ static int idetape_write_filemark(ide_drive_t *drive)static int idetape_mtioctop (ide_drive_t *drive,short mt_op,int mt_count) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t pc; +struct ide_atapi_pc pc;int i, retval; debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n",
@@ -3152,7 +3129,7 @@ static int idetape_chrdev_ioctl(struct inode *inode, struct file *file,static void ide_tape_get_bsize_from_bdesc (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t pc; +struct ide_atapi_pc pc;idetape_create_mode_sense_cmd (&pc,IDETAPE_BLOCK_DESCRIPTOR );if (idetape_queue_pc_tail (drive, &pc)) {
@@ -3164,10 +3141,10 @@ static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive) }return ; } - tape->blk_size = (pc.buffer[4 +5 ] <<16 ) + - (pc.buffer[4 +6 ] <<8 ) + - pc.buffer[4 +7 ]; - tape->drv_write_prot = (pc.buffer[2 ] &0x80 ) >>7 ; + tape->blk_size = (pc.buf[4 +5 ] <<16 ) + + (pc.buf[4 +6 ] <<8 ) + + pc.buf[4 +7 ]; + tape->drv_write_prot = (pc.buf[2 ] &0x80 ) >>7 ; }static int idetape_chrdev_open (struct inode *inode,struct file *filp)
@@ -3175,7 +3152,7 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp)unsigned int minor =iminor (inode), i = minor & ~0xc0 ;ide_drive_t *drive;idetape_tape_t *tape; -idetape_pc_t pc; +struct ide_atapi_pc pc;int retval;if (i >=MAX_HWIFS *MAX_DRIVES )
@@ -3275,7 +3252,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp) {struct ide_tape_obj *tape =ide_tape_f (filp);ide_drive_t *drive = tape->drive; -idetape_pc_t pc; +struct ide_atapi_pc pc;unsigned int minor =iminor (inode);lock_kernel ();
@@ -3353,7 +3330,7 @@ static int idetape_identify_device(ide_drive_t *drive)static void idetape_get_inquiry_results (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t pc; +struct ide_atapi_pc pc;char fw_rev[6 ], vendor_id[10 ], product_id[18 ];idetape_create_inquiry_cmd (&pc);
@@ -3362,9 +3339,9 @@ static void idetape_get_inquiry_results(ide_drive_t *drive) tape->name);return ; } -memcpy (vendor_id, &pc.buffer[8 ],8 ); -memcpy (product_id, &pc.buffer[16 ],16 ); -memcpy (fw_rev, &pc.buffer[32 ],4 ); +memcpy (vendor_id, &pc.buf[8 ],8 ); +memcpy (product_id, &pc.buf[16 ],16 ); +memcpy (fw_rev, &pc.buf[32 ],4 );ide_fixstring (vendor_id,10 ,0 );ide_fixstring (product_id,18 ,0 );
@@ -3381,7 +3358,7 @@ static void idetape_get_inquiry_results(ide_drive_t *drive)static void idetape_get_mode_sense_results (ide_drive_t *drive) {idetape_tape_t *tape = drive->driver_data; -idetape_pc_t pc; +struct ide_atapi_pc pc;u8 *caps;u8 speed, max_speed;
@@ -3395,7 +3372,7 @@ static void idetape_get_mode_sense_results(ide_drive_t *drive)put_unaligned (6 *52 , (u16 *)&tape->caps[16 ]);return ; } - caps = pc.buffer +4 + pc.buffer[3 ]; + caps = pc.buf +4 + pc.buf[3 ];/* convert to host order and save for later use */ speed =be16_to_cpu (*(u16 *)&caps[14 ]);
Signature · 1 line
1.5.3.7
Bartlomiej Zolnierkiewicz
AppliedQuoted 8 lines · Borislav Petkov
Hi Bart,
here's the
ide_atapi_pcunification series. It all went pretty smoothly along the search & replace line. Using driver-specific members inide_atapi_pclikeidefloppy_callbackandidetape_callbackis kinda dumb but this approach seemed the fastest versus unnecessary callback function signature change that will touch stuff all over the place. Besides, ide-tape might be gone soon so that would alleviate the problem.
applied all four patches, thanks!
Quoted 3 lines
On a different note, i noticed ide-scsi might also need a cleanup similar to the other drivers. It is next on my TODO list in case you don't have anything with a higher prio.
I was actually hoping that you'll continue unifying ATAPI handling...
[ ide-scsi is orphaned and has (probably) unfixable problems (because of having
dependencies on both IDE and SCSI subsystems) so it is not worth IMO but I will of course accept patches... ]
Thanks,
Bart
Quoted 11 lines · Bartlomiej Zolnierkiewicz
Quoted 8 lines · Borislav Petkov
Hi Bart,
here's the
ide_atapi_pcunification series. It all went pretty smoothly along the search & replace line. Using driver-specific members inide_atapi_pclikeidefloppy_callbackandidetape_callbackis kinda dumb but this approach seemed the fastest versus unnecessary callback function signature change that will touch stuff all over the place. Besides, ide-tape might be gone soon so that would alleviate the problem.
Quoted 7 lines
applied all four patches, thanks!
Quoted 3 lines
On a different note, i noticed ide-scsi might also need a cleanup similar to the other drivers. It is next on my TODO list in case you don't have anything with a higher prio.
I was actually hoping that you'll continue unifying ATAPI handling...
yeah, sure. ide-scsi simply will wander down the prio stack pushed by the other stuff :)
Quoted 1 line
[ ide-scsi is orphaned and has (probably) unfixable problems (because of having
does this mean it might have a similar to idetape's destiny...?
Signature · 2 lines
Regards/Gruß,
Boris.PATCH 1/1 ide-scsi: do non-atomic pc->flags testing
In reply to a message not in the archivecommit 272976f0f5754707f9e41da315717a6eb8d9d536
Author: Borislav Petkov <[email protected]> Date: Tue Feb 12 16:22:44 2008 +0100
ide-scsi: do non-atomic pc->flags testing
drivers/scsi/ide-scsi.c +16 -13
@@ -319,8 +319,10 @@ static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs) pc = opc; rq = pc->rq; pc->scsi_cmd->result = (CHECK_CONDITION <<1 ) | - ((test_bit (PC_TIMEDOUT , &pc->flags)?DID_TIME_OUT :DID_OK ) <<16 ); - }else if (test_bit (PC_TIMEDOUT , &pc->flags)) { + (((pc->flags &PC_TIMEDOUT ) ? +DID_TIME_OUT : +DID_OK ) <<16 ); + }else if (pc->flags &PC_TIMEDOUT ) {if (log)printk (KERN_WARNING "ide-scsi: %s: timed out for %lu\n" , drive->name, pc->scsi_cmd->serial_number);
@@ -362,7 +364,7 @@ static int idescsi_expiry(ide_drive_t *drive)#if IDESCSI_DEBUG_LOG printk (KERN_WARNING "idescsi_expiry called for %lu at %lu\n" , pc->scsi_cmd->serial_number, jiffies);#endif -set_bit (PC_TIMEDOUT , &pc->flags); + pc->flags |=PC_TIMEDOUT ;return 0 ;/* we do not want the ide subsystem to retry */ }
@@ -384,7 +386,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)printk (KERN_INFO "ide-scsi: Reached idescsi_pc_intr interrupt handler\n" );#endif /* IDESCSI_DEBUG_LOG */ -if (test_bit (PC_TIMEDOUT , &pc->flags)){ +if (pc->flags &PC_TIMEDOUT ) {#if IDESCSI_DEBUG_LOG printk (KERN_WARNING "idescsi_pc_intr: got timed out packet %lu at %lu\n" , pc->scsi_cmd->serial_number, jiffies);
@@ -393,7 +395,8 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)idescsi_end_request (drive,1 ,0 );return ide_stopped; } -if (test_and_clear_bit (PC_DMA_IN_PROGRESS , &pc->flags)) { +if (pc->flags &PC_DMA_IN_PROGRESS ) { + pc->flags &= ~PC_DMA_IN_PROGRESS ;#if IDESCSI_DEBUG_LOG printk ("ide-scsi: %s: DMA complete\n" , drive->name);#endif /* IDESCSI_DEBUG_LOG */
@@ -432,7 +435,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive) "- discarding data\n"); temp = pc->buf_size - pc->xferred;if (temp) { -clear_bit (PC_WRITING , &pc->flags); + pc->flags &= ~PC_WRITING ;if (pc->sg)idescsi_input_buffers (drive, pc, temp);
@@ -454,14 +457,14 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive) } }if (ireason &IO ) { -clear_bit (PC_WRITING , &pc->flags); + pc->flags &= ~PC_WRITING ;if (pc->sg)idescsi_input_buffers (drive, pc, bcount);else hwif->atapi_input_bytes (drive, pc->cur_pos, bcount); }else { -set_bit (PC_WRITING , &pc->flags); + pc->flags |=PC_WRITING ;if (pc->sg)idescsi_output_buffers (drive, pc, bcount);else
@@ -501,8 +504,8 @@ static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive)ide_set_handler (drive, &idescsi_pc_intr,get_timeout (pc), idescsi_expiry);/* Send the actual packet */ drive->hwif->atapi_output_bytes (drive, scsi->pc->c,12 ); -if (test_bit (PC_DMA_OK , &pc->flags)) { -set_bit (PC_DMA_IN_PROGRESS , &pc->flags); +if (pc->flags &PC_DMA_OK ) { + pc->flags |=PC_DMA_IN_PROGRESS ; hwif->dma_start (drive); }return ide_started;
@@ -512,10 +515,10 @@ static inline int idescsi_set_direction(struct ide_atapi_pc *pc) {switch (pc->c[0 ]) {case READ_6 :case READ_10 :case READ_12 : -clear_bit (PC_WRITING , &pc->flags); + pc->flags &= ~PC_WRITING ;return 0 ;case WRITE_6 :case WRITE_10 :case WRITE_12 : -set_bit (PC_WRITING , &pc->flags); + pc->flags |=PC_WRITING ;return 0 ;default :return 1 ;
@@ -572,7 +575,7 @@ static ide_startstop_t idescsi_issue_pc(ide_drive_t *drive,ide_pktcmd_tf_load (drive,IDE_TFLAG_NO_SELECT_MASK , bcount, dma);if (dma) -set_bit (PC_DMA_OK , &pc->flags); + pc->flags |=PC_DMA_OK ;if (test_bit (IDESCSI_DRQ_INTERRUPT , &scsi->flags)) { ide_execute_command(drive, WIN_PACKETCMD, &idescsi_transfer_pc,
Signature · 2 lines
Regards/Gruß,
Boris.Re: [PATCH] ide-scsi: do non-atomic pc->flags testing
Quoted 13 lines · Borislav Petkov
commit
272976f0f5754707f9e41da315717a6eb8d9d536Author: Borislav Petkov <[email protected]> Date: Tue Feb 12 16:22:44 2008 +0100ide-scsi: do non-atomic
pc->flagstestingSigned-off-by Borislav Petkov <[email protected]>drivers/scsi/ide-scsi.c +0
-0
drivers/scsi/ide-scsi.c static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs) · line 325
Quoted 9 lines
drivers/scsi/ide-scsi.c +4
-2@@ -319,8 +319,10 @@ static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs) pc = opc; rq = pc->rq; pc->scsi_cmd->result = (CHECK_CONDITION <<1 ) | - ((test_bit (PC_TIMEDOUT , &pc->flags)?DID_TIME_OUT :DID_OK ) <<16 ); - }else if (test_bit (PC_TIMEDOUT , &pc->flags)) { + (((pc->flags &PC_TIMEDOUT ) ? +DID_TIME_OUT : +DID_OK ) <<16 ); + }else if (pc->flags &PC_TIMEDOUT ) {
How's about renaming flag defines to PC_FLAG_* at the same time (like it was done for other ATAPI drivers)?
Otherwise looks good.
Quoted 10 lines · Bartlomiej Zolnierkiewicz
Quoted 4 lines
On a different note, i noticed ide-scsi might also need a cleanup similar to the other drivers. It is next on my TODO list in case you don't have anything with a higher prio.
I was actually hoping that you'll continue unifying ATAPI handling...
[ ide-scsi is orphaned and has (probably) unfixable problems
(because of having dependencies on both IDE and SCSI subsystems) so it is not worth IMO but I will of course accept patches... ]
So, why is ide-scsi still in the tree? Is there some use case besides cdrecord? (Which can use /dev/hda already without the ide-scsi blob...)
Quoted 2 lines
So, why is ide-scsi still in the tree? Is there some use case besides cdrecord? (Which can use
/dev/hdaalready without the ide-scsi blob...)
With old IDE only ide-scsi can handle some of the more obscurely weird devices, and some tape drives fail with ide-tape but work with ide-scsi
+ osst/st.
Alan