hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ide-floppy: use ide_pio_bytes() 

* Fix ide_init_sg_cmd() setup for non-fs requests.

* Convert ide_pc_intr() to use ide_pio_bytes() for floppy media.

* Remove no longer needed ide_io_buffers() and sg/sg_cnt fields
  from struct ide_atapi_pc.

* Remove partial completions; kill idefloppy_update_buffers(), as a
  result.

* Add some more debugging statements.

Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
This commit is contained in:
Bartlomiej Zolnierkiewicz 2009-03-31 20:15:26 +02:00
parent d93bc4521c
commit 349d12a1fe
3 changed files with 21 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
drivers/ide/ide-atapi.c
View File

@ -71,49 +71,6 @@ int ide_check_atapi_device(ide_drive_t *drive, const char *s)
} }
EXPORT_SYMBOL_GPL(ide_check_atapi_device); EXPORT_SYMBOL_GPL(ide_check_atapi_device);
/* PIO data transfer routine using the scatter gather table. */
int ide_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
unsigned int bcount, int write)
{
ide_hwif_t *hwif = drive->hwif;
const struct ide_tp_ops *tp_ops = hwif->tp_ops;
xfer_func_t *xf = write ? tp_ops->output_data : tp_ops->input_data;
struct scatterlist *sg = pc->sg;
char *buf;
int count, done = 0;
while (bcount) {
count = min(sg->length - pc->b_count, bcount);
if (PageHighMem(sg_page(sg))) {
unsigned long flags;
local_irq_save(flags);
buf = kmap_atomic(sg_page(sg), KM_IRQ0) + sg->offset;
xf(drive, NULL, buf + pc->b_count, count);
kunmap_atomic(buf - sg->offset, KM_IRQ0);
local_irq_restore(flags);
} else {
buf = sg_virt(sg);
xf(drive, NULL, buf + pc->b_count, count);
}
bcount -= count;
pc->b_count += count;
done += count;
if (pc->b_count == sg->length) {
if (!--pc->sg_cnt)
break;
pc->sg = sg = sg_next(sg);
pc->b_count = 0;
}
}
return done;
}
EXPORT_SYMBOL_GPL(ide_io_buffers);
void ide_init_pc(struct ide_atapi_pc *pc) void ide_init_pc(struct ide_atapi_pc *pc)
{ {
memset(pc, 0, sizeof(*pc)); memset(pc, 0, sizeof(*pc));
@ -353,6 +310,9 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
pc->xferred = pc->req_xfer; pc->xferred = pc->req_xfer;
if (drive->pc_update_buffers) if (drive->pc_update_buffers)
drive->pc_update_buffers(drive, pc); drive->pc_update_buffers(drive, pc);
if (drive->media == ide_floppy)
ide_complete_rq(drive, 0, blk_rq_bytes(rq));
} }
debug_log("%s: DMA finished\n", drive->name); debug_log("%s: DMA finished\n", drive->name);
} }
@ -408,12 +368,19 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
rq->errors = 0; rq->errors = 0;
ide_complete_rq(drive, 0, blk_rq_bytes(rq)); ide_complete_rq(drive, 0, blk_rq_bytes(rq));
} else { } else {
unsigned int done;
if (blk_fs_request(rq) == 0 && uptodate <= 0) { if (blk_fs_request(rq) == 0 && uptodate <= 0) {
if (rq->errors == 0) if (rq->errors == 0)
rq->errors = -EIO; rq->errors = -EIO;
} }
ide_complete_rq(drive, uptodate ? 0 : -EIO,
ide_rq_bytes(rq)); if (drive->media == ide_tape)
done = ide_rq_bytes(rq); /* FIXME */
else
done = blk_rq_bytes(rq);
ide_complete_rq(drive, uptodate ? 0 : -EIO, done);
} }
return ide_stopped; return ide_stopped;
@ -446,14 +413,11 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
xferfunc = write ? tp_ops->output_data : tp_ops->input_data; xferfunc = write ? tp_ops->output_data : tp_ops->input_data;
if ((drive->media == ide_floppy && !pc->buf) || if (drive->media == ide_floppy && pc->buf == NULL) {
(drive->media == ide_tape && pc->bh)) { done = min_t(unsigned int, bcount, cmd->nleft);
ide_pio_bytes(drive, cmd, write, done);
} else if (drive->media == ide_tape && pc->bh) {
done = drive->pc_io_buffers(drive, pc, bcount, write); done = drive->pc_io_buffers(drive, pc, bcount, write);
/* FIXME: don't do partial completions */
if (drive->media == ide_floppy)
ide_complete_rq(drive, 0,
done ? done : ide_rq_bytes(rq));
} else { } else {
done = min_t(unsigned int, bcount, pc->req_xfer - pc->xferred); done = min_t(unsigned int, bcount, pc->req_xfer - pc->xferred);
xferfunc(drive, NULL, pc->cur_pos, done); xferfunc(drive, NULL, pc->cur_pos, done);

24
drivers/ide/ide-floppy.c
View File

@ -61,16 +61,6 @@
*/ */
#define IDEFLOPPY_PC_DELAY (HZ/20) /* default delay for ZIP 100 (50ms) */ #define IDEFLOPPY_PC_DELAY (HZ/20) /* default delay for ZIP 100 (50ms) */
static void idefloppy_update_buffers(ide_drive_t *drive,
struct ide_atapi_pc *pc)
{
struct request *rq = pc->rq;
struct bio *bio = rq->bio;
while ((bio = rq->bio) != NULL)
ide_complete_rq(drive, 0, ide_rq_bytes(rq));
}
static int ide_floppy_callback(ide_drive_t *drive, int dsc) static int ide_floppy_callback(ide_drive_t *drive, int dsc)
{ {
struct ide_disk_obj *floppy = drive->driver_data; struct ide_disk_obj *floppy = drive->driver_data;
@ -213,7 +203,6 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
memcpy(rq->cmd, pc->c, 12); memcpy(rq->cmd, pc->c, 12);
pc->rq = rq; pc->rq = rq;
pc->b_count = 0;
if (rq->cmd_flags & REQ_RW) if (rq->cmd_flags & REQ_RW)
pc->flags |= PC_FLAG_WRITING; pc->flags |= PC_FLAG_WRITING;
pc->buf = NULL; pc->buf = NULL;
@ -227,7 +216,6 @@ static void idefloppy_blockpc_cmd(struct ide_disk_obj *floppy,
ide_init_pc(pc); ide_init_pc(pc);
memcpy(pc->c, rq->cmd, sizeof(pc->c)); memcpy(pc->c, rq->cmd, sizeof(pc->c));
pc->rq = rq; pc->rq = rq;
pc->b_count = 0;
if (rq->data_len && rq_data_dir(rq) == WRITE) if (rq->data_len && rq_data_dir(rq) == WRITE)
pc->flags |= PC_FLAG_WRITING; pc->flags |= PC_FLAG_WRITING;
pc->buf = rq->data; pc->buf = rq->data;
@ -244,10 +232,11 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
struct request *rq, sector_t block) struct request *rq, sector_t block)
{ {
struct ide_disk_obj *floppy = drive->driver_data; struct ide_disk_obj *floppy = drive->driver_data;
ide_hwif_t *hwif = drive->hwif;
struct ide_cmd cmd; struct ide_cmd cmd;
struct ide_atapi_pc *pc; struct ide_atapi_pc *pc;
ide_debug_log(IDE_DBG_FUNC, "enter, cmd: 0x%x\n", rq->cmd[0]);
if (drive->debug_mask & IDE_DBG_RQ) if (drive->debug_mask & IDE_DBG_RQ)
blk_dump_rq_flags(rq, (rq->rq_disk blk_dump_rq_flags(rq, (rq->rq_disk
? rq->rq_disk->disk_name ? rq->rq_disk->disk_name
@ -294,13 +283,10 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
cmd.rq = rq; cmd.rq = rq;
if (blk_fs_request(rq) || pc->req_xfer) { if (blk_fs_request(rq) || pc->req_xfer) {
ide_init_sg_cmd(&cmd, rq->nr_sectors << 9); ide_init_sg_cmd(&cmd, pc->req_xfer);
ide_map_sg(drive, &cmd); ide_map_sg(drive, &cmd);
} }
pc->sg = hwif->sg_table;
pc->sg_cnt = cmd.sg_nents;
pc->rq = rq; pc->rq = rq;
return ide_floppy_issue_pc(drive, &cmd, pc); return ide_floppy_issue_pc(drive, &cmd, pc);
@ -388,6 +374,8 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
u8 pc_buf[256], header_len, desc_cnt; u8 pc_buf[256], header_len, desc_cnt;
int i, rc = 1, blocks, length; int i, rc = 1, blocks, length;
ide_debug_log(IDE_DBG_FUNC, "enter");
drive->bios_cyl = 0; drive->bios_cyl = 0;
drive->bios_head = drive->bios_sect = 0; drive->bios_head = drive->bios_sect = 0;
floppy->blocks = 0; floppy->blocks = 0;
@ -488,8 +476,6 @@ static void ide_floppy_setup(ide_drive_t *drive)
u16 *id = drive->id; u16 *id = drive->id;
drive->pc_callback = ide_floppy_callback; drive->pc_callback = ide_floppy_callback;
drive->pc_update_buffers = idefloppy_update_buffers;
drive->pc_io_buffers = ide_io_buffers;
/* /*
* We used to check revisions here. At this point however I'm giving up. * We used to check revisions here. At this point however I'm giving up.

5
include/linux/ide.h
View File

@ -415,9 +415,6 @@ struct ide_atapi_pc {
struct idetape_bh *bh; struct idetape_bh *bh;
char *b_data; char *b_data;
struct scatterlist *sg;
unsigned int sg_cnt;
unsigned long timeout; unsigned long timeout;
}; };
@ -1177,8 +1174,6 @@ void ide_tf_read(ide_drive_t *, struct ide_cmd *);
void ide_input_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int); void ide_input_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int);
void ide_output_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int); void ide_output_data(ide_drive_t *, struct ide_cmd *, void *, unsigned int);
int ide_io_buffers(ide_drive_t *, struct ide_atapi_pc *, unsigned int, int);
extern void SELECT_DRIVE(ide_drive_t *); extern void SELECT_DRIVE(ide_drive_t *);
void SELECT_MASK(ide_drive_t *, int); void SELECT_MASK(ide_drive_t *, int);