lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ide: move command related fields from ide_hwif_t to struct ide_cmd

Browse Source 
* Move command related fields from ide_hwif_t to struct ide_cmd.

* Make ide_init_sg_cmd() take command and sectors number as arguments.

There should be no functional changes caused by this patch.

Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
This commit is contained in:
Bartlomiej Zolnierkiewicz
2009-03-27 12:46:38 +01:00
parent adb1af9803
commit b6308ee0c5
12 changed files with 61 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/ide/au1xxx-ide.c
View File

@@ -215,7 +215,7 @@ static int auide_build_dmatable(ide_drive_t *drive)
struct request *rq = hwif->rq; struct request *rq = hwif->rq;
_auide_hwif *ahwif = &auide_hwif; _auide_hwif *ahwif = &auide_hwif;
struct scatterlist *sg; struct scatterlist *sg;
int i = hwif->sg_nents, iswrite, count = 0; int i = hwif->cmd.sg_nents, iswrite, count = 0;
iswrite = (rq_data_dir(rq) == WRITE); iswrite = (rq_data_dir(rq) == WRITE);
/* Save for interrupt context */ /* Save for interrupt context */

2
drivers/ide/icside.c
View File

@@ -344,7 +344,7 @@ static int icside_dma_setup(ide_drive_t *drive)
* Tell the DMA engine about the SG table and * Tell the DMA engine about the SG table and
* data direction. * data direction.
*/ */
set_dma_sg(ec->dma, hwif->sg_table, hwif->sg_nents); set_dma_sg(ec->dma, hwif->sg_table, hwif->cmd.sg_nents);
set_dma_mode(ec->dma, dma_mode); set_dma_mode(ec->dma, dma_mode);
drive->waiting_for_dma = 1; drive->waiting_for_dma = 1;

12
drivers/ide/ide-disk.c
View File

@@ -104,14 +104,14 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
lba48 = 0; lba48 = 0;
} }
if (!dma) {
ide_init_sg_cmd(drive, rq);
ide_map_sg(drive, rq);
}
memset(&cmd, 0, sizeof(cmd)); memset(&cmd, 0, sizeof(cmd));
cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; cmd.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
if (dma == 0) {
ide_init_sg_cmd(&cmd, nsectors);
ide_map_sg(drive, rq);
}
if (drive->dev_flags & IDE_DFLAG_LBA) { if (drive->dev_flags & IDE_DFLAG_LBA) {
if (lba48) { if (lba48) {
pr_debug("%s: LBA=0x%012llx\n", drive->name, pr_debug("%s: LBA=0x%012llx\n", drive->name,
@@ -170,7 +170,7 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
/* fallback to PIO */ /* fallback to PIO */
cmd.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK; cmd.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
ide_tf_set_cmd(drive, &cmd, 0); ide_tf_set_cmd(drive, &cmd, 0);
ide_init_sg_cmd(drive, rq); ide_init_sg_cmd(&cmd, nsectors);
rc = do_rw_taskfile(drive, &cmd); rc = do_rw_taskfile(drive, &cmd);
} }

2
drivers/ide/ide-dma-sff.c
View File

@@ -120,7 +120,7 @@ int ide_build_dmatable(ide_drive_t *drive, struct request *rq)
struct scatterlist *sg; struct scatterlist *sg;
u8 is_trm290 = !!(hwif->host_flags & IDE_HFLAG_TRM290); u8 is_trm290 = !!(hwif->host_flags & IDE_HFLAG_TRM290);
for_each_sg(hwif->sg_table, sg, hwif->sg_nents, i) { for_each_sg(hwif->sg_table, sg, hwif->cmd.sg_nents, i) {
u32 cur_addr, cur_len, xcount, bcount; u32 cur_addr, cur_len, xcount, bcount;
cur_addr = sg_dma_address(sg); cur_addr = sg_dma_address(sg);

16
drivers/ide/ide-dma.c
View File

@@ -128,21 +128,22 @@ int ide_build_sglist(ide_drive_t *drive, struct request *rq)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
struct scatterlist *sg = hwif->sg_table; struct scatterlist *sg = hwif->sg_table;
struct ide_cmd *cmd = &hwif->cmd;
int i; int i;
ide_map_sg(drive, rq); ide_map_sg(drive, rq);
if (rq_data_dir(rq) == READ) if (rq_data_dir(rq) == READ)
hwif->sg_dma_direction = DMA_FROM_DEVICE; cmd->sg_dma_direction = DMA_FROM_DEVICE;
else else
hwif->sg_dma_direction = DMA_TO_DEVICE; cmd->sg_dma_direction = DMA_TO_DEVICE;
i = dma_map_sg(hwif->dev, sg, hwif->sg_nents, hwif->sg_dma_direction); i = dma_map_sg(hwif->dev, sg, cmd->sg_nents, cmd->sg_dma_direction);
if (i == 0) if (i == 0)
ide_map_sg(drive, rq); ide_map_sg(drive, rq);
else { else {
hwif->orig_sg_nents = hwif->sg_nents; cmd->orig_sg_nents = cmd->sg_nents;
hwif->sg_nents = i; cmd->sg_nents = i;
} }
return i; return i;
@@ -162,9 +163,10 @@ int ide_build_sglist(ide_drive_t *drive, struct request *rq)
void ide_destroy_dmatable(ide_drive_t *drive) void ide_destroy_dmatable(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
struct ide_cmd *cmd = &hwif->cmd;
dma_unmap_sg(hwif->dev, hwif->sg_table, hwif->orig_sg_nents, dma_unmap_sg(hwif->dev, hwif->sg_table, cmd->orig_sg_nents,
hwif->sg_dma_direction); cmd->sg_dma_direction);
} }
EXPORT_SYMBOL_GPL(ide_destroy_dmatable); EXPORT_SYMBOL_GPL(ide_destroy_dmatable);

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

@@ -244,6 +244,7 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
{ {
struct ide_disk_obj *floppy = drive->driver_data; struct ide_disk_obj *floppy = drive->driver_data;
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
struct ide_cmd *cmd = &hwif->cmd;
struct ide_atapi_pc *pc; struct ide_atapi_pc *pc;
if (drive->debug_mask & IDE_DBG_RQ) if (drive->debug_mask & IDE_DBG_RQ)
@@ -285,12 +286,12 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
} }
if (blk_fs_request(rq) || pc->req_xfer) { if (blk_fs_request(rq) || pc->req_xfer) {
ide_init_sg_cmd(drive, rq); ide_init_sg_cmd(cmd, rq->nr_sectors);
ide_map_sg(drive, rq); ide_map_sg(drive, rq);
} }
pc->sg = hwif->sg_table; pc->sg = hwif->sg_table;
pc->sg_cnt = hwif->sg_nents; pc->sg_cnt = cmd->sg_nents;
pc->rq = rq; pc->rq = rq;

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

@@ -274,30 +274,26 @@ static ide_startstop_t do_special (ide_drive_t *drive)
void ide_map_sg(ide_drive_t *drive, struct request *rq) void ide_map_sg(ide_drive_t *drive, struct request *rq)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
struct ide_cmd *cmd = &hwif->cmd;
struct scatterlist *sg = hwif->sg_table; struct scatterlist *sg = hwif->sg_table;
if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE); sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE);
hwif->sg_nents = 1; cmd->sg_nents = 1;
} else if (!rq->bio) { } else if (!rq->bio) {
sg_init_one(sg, rq->data, rq->data_len); sg_init_one(sg, rq->data, rq->data_len);
hwif->sg_nents = 1; cmd->sg_nents = 1;
} else { } else
hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
} }
}
EXPORT_SYMBOL_GPL(ide_map_sg); EXPORT_SYMBOL_GPL(ide_map_sg);
void ide_init_sg_cmd(ide_drive_t *drive, struct request *rq) void ide_init_sg_cmd(struct ide_cmd *cmd, int nsect)
{ {
ide_hwif_t *hwif = drive->hwif; cmd->nsect = cmd->nleft = nsect;
cmd->cursg_ofs = 0;
hwif->nsect = hwif->nleft = rq->nr_sectors; cmd->cursg = NULL;
hwif->cursg_ofs = 0;
hwif->cursg = NULL;
} }
EXPORT_SYMBOL_GPL(ide_init_sg_cmd); EXPORT_SYMBOL_GPL(ide_init_sg_cmd);
/** /**
@@ -323,7 +319,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
case TASKFILE_OUT: case TASKFILE_OUT:
case TASKFILE_MULTI_IN: case TASKFILE_MULTI_IN:
case TASKFILE_IN: case TASKFILE_IN:
ide_init_sg_cmd(drive, rq); ide_init_sg_cmd(cmd, rq->nr_sectors);
ide_map_sg(drive, rq); ide_map_sg(drive, rq);
default: default:
break; break;

33
drivers/ide/ide-taskfile.c
View File

@@ -209,7 +209,7 @@ static void ide_pio_sector(ide_drive_t *drive, struct ide_cmd *cmd,
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
struct scatterlist *sg = hwif->sg_table; struct scatterlist *sg = hwif->sg_table;
struct scatterlist *cursg = hwif->cursg; struct scatterlist *cursg = cmd->cursg;
struct page *page; struct page *page;
#ifdef CONFIG_HIGHMEM #ifdef CONFIG_HIGHMEM
unsigned long flags; unsigned long flags;
@@ -217,14 +217,14 @@ static void ide_pio_sector(ide_drive_t *drive, struct ide_cmd *cmd,
unsigned int offset; unsigned int offset;
u8 *buf; u8 *buf;
cursg = hwif->cursg; cursg = cmd->cursg;
if (!cursg) { if (!cursg) {
cursg = sg; cursg = sg;
hwif->cursg = sg; cmd->cursg = sg;
} }
page = sg_page(cursg); page = sg_page(cursg);
offset = cursg->offset + hwif->cursg_ofs * SECTOR_SIZE; offset = cursg->offset + cmd->cursg_ofs * SECTOR_SIZE;
/* get the current page and offset */ /* get the current page and offset */
page = nth_page(page, (offset >> PAGE_SHIFT)); page = nth_page(page, (offset >> PAGE_SHIFT));
@@ -235,12 +235,12 @@ static void ide_pio_sector(ide_drive_t *drive, struct ide_cmd *cmd,
#endif #endif
buf = kmap_atomic(page, KM_BIO_SRC_IRQ) + offset; buf = kmap_atomic(page, KM_BIO_SRC_IRQ) + offset;
hwif->nleft--; cmd->nleft--;
hwif->cursg_ofs++; cmd->cursg_ofs++;
if ((hwif->cursg_ofs * SECTOR_SIZE) == cursg->length) { if ((cmd->cursg_ofs * SECTOR_SIZE) == cursg->length) {
hwif->cursg = sg_next(hwif->cursg); cmd->cursg = sg_next(cmd->cursg);
hwif->cursg_ofs = 0; cmd->cursg_ofs = 0;
} }
/* do the actual data transfer */ /* do the actual data transfer */
@@ -260,7 +260,7 @@ static void ide_pio_multi(ide_drive_t *drive, struct ide_cmd *cmd,
{ {
unsigned int nsect; unsigned int nsect;
nsect = min_t(unsigned int, drive->hwif->nleft, drive->mult_count); nsect = min_t(unsigned int, cmd->nleft, drive->mult_count);
while (nsect--) while (nsect--)
ide_pio_sector(drive, cmd, write); ide_pio_sector(drive, cmd, write);
} }
@@ -295,19 +295,18 @@ static ide_startstop_t task_error(ide_drive_t *drive, struct ide_cmd *cmd,
const char *s, u8 stat) const char *s, u8 stat)
{ {
if (cmd->tf_flags & IDE_TFLAG_FS) { if (cmd->tf_flags & IDE_TFLAG_FS) {
ide_hwif_t *hwif = drive->hwif; int sectors = cmd->nsect - cmd->nleft;
int sectors = hwif->nsect - hwif->nleft;
switch (cmd->data_phase) { switch (cmd->data_phase) {
case TASKFILE_IN: case TASKFILE_IN:
if (hwif->nleft) if (cmd->nleft)
break; break;
/* fall through */ /* fall through */
case TASKFILE_OUT: case TASKFILE_OUT:
sectors--; sectors--;
break; break;
case TASKFILE_MULTI_IN: case TASKFILE_MULTI_IN:
if (hwif->nleft) if (cmd->nleft)
break; break;
/* fall through */ /* fall through */
case TASKFILE_MULTI_OUT: case TASKFILE_MULTI_OUT:
@@ -375,7 +374,7 @@ static ide_startstop_t task_in_intr(ide_drive_t *drive)
ide_pio_datablock(drive, cmd, 0); ide_pio_datablock(drive, cmd, 0);
/* Are we done? Check status and finish transfer. */ /* Are we done? Check status and finish transfer. */
if (!hwif->nleft) { if (cmd->nleft == 0) {
stat = wait_drive_not_busy(drive); stat = wait_drive_not_busy(drive);
if (!OK_STAT(stat, 0, BAD_STAT)) if (!OK_STAT(stat, 0, BAD_STAT))
return task_error(drive, cmd, __func__, stat); return task_error(drive, cmd, __func__, stat);
@@ -402,10 +401,10 @@ static ide_startstop_t task_out_intr (ide_drive_t *drive)
return task_error(drive, cmd, __func__, stat); return task_error(drive, cmd, __func__, stat);
/* Deal with unexpected ATA data phase. */ /* Deal with unexpected ATA data phase. */
if (((stat & ATA_DRQ) == 0) ^ !hwif->nleft) if (((stat & ATA_DRQ) == 0) ^ (cmd->nleft == 0))
return task_error(drive, cmd, __func__, stat); return task_error(drive, cmd, __func__, stat);
if (!hwif->nleft) { if (cmd->nleft == 0) {
ide_finish_cmd(drive, cmd, stat); ide_finish_cmd(drive, cmd, stat);
return ide_stopped; return ide_stopped;
} }

2
drivers/ide/pmac.c
View File

@@ -1432,7 +1432,7 @@ pmac_ide_build_dmatable(ide_drive_t *drive, struct request *rq)
volatile struct dbdma_regs __iomem *dma = pmif->dma_regs; volatile struct dbdma_regs __iomem *dma = pmif->dma_regs;
struct scatterlist *sg; struct scatterlist *sg;
int wr = (rq_data_dir(rq) == WRITE); int wr = (rq_data_dir(rq) == WRITE);
int i = hwif->sg_nents, count = 0; int i = hwif->cmd.sg_nents, count = 0;
/* DMA table is already aligned */ /* DMA table is already aligned */
table = (struct dbdma_cmd *) pmif->dma_table_cpu; table = (struct dbdma_cmd *) pmif->dma_table_cpu;

2
drivers/ide/sgiioc4.c
View File

@@ -429,7 +429,7 @@ sgiioc4_build_dma_table(ide_drive_t * drive, struct request *rq, int ddir)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
unsigned int *table = hwif->dmatable_cpu; unsigned int *table = hwif->dmatable_cpu;
unsigned int count = 0, i = hwif->sg_nents; unsigned int count = 0, i = hwif->cmd.sg_nents;
struct scatterlist *sg = hwif->sg_table; struct scatterlist *sg = hwif->sg_table;
while (i && sg_dma_len(sg)) { while (i && sg_dma_len(sg)) {

2
drivers/ide/tx4939ide.c
View File

@@ -240,7 +240,7 @@ static int tx4939ide_build_dmatable(ide_drive_t *drive, struct request *rq)
int i; int i;
struct scatterlist *sg; struct scatterlist *sg;
for_each_sg(hwif->sg_table, sg, hwif->sg_nents, i) { for_each_sg(hwif->sg_table, sg, hwif->cmd.sg_nents, i) {
u32 cur_addr, cur_len, bcount; u32 cur_addr, cur_len, bcount;
cur_addr = sg_dma_address(sg); cur_addr = sg_dma_address(sg);

20
include/linux/ide.h
View File

@@ -344,6 +344,16 @@ struct ide_cmd {
u8 ftf_flags; /* for TASKFILE ioctl */ u8 ftf_flags; /* for TASKFILE ioctl */
u32 tf_flags; u32 tf_flags;
int data_phase; int data_phase;
int sg_nents; /* number of sg entries */
int orig_sg_nents;
int sg_dma_direction; /* DMA transfer direction */
unsigned int nsect;
unsigned int nleft;
struct scatterlist *cursg;
unsigned int cursg_ofs;
struct request *rq; /* copy of request */ struct request *rq; /* copy of request */
void *special; /* valid_t generally */ void *special; /* valid_t generally */
}; };
@@ -772,17 +782,9 @@ typedef struct hwif_s {
/* Scatter-gather list used to build the above */ /* Scatter-gather list used to build the above */
struct scatterlist *sg_table; struct scatterlist *sg_table;
int sg_max_nents; /* Maximum number of entries in it */ int sg_max_nents; /* Maximum number of entries in it */
int sg_nents; /* Current number of entries in it */
int orig_sg_nents;
int sg_dma_direction; /* dma transfer direction */
struct ide_cmd cmd; /* current command */ struct ide_cmd cmd; /* current command */
unsigned int nsect;
unsigned int nleft;
struct scatterlist *cursg;
unsigned int cursg_ofs;
int rqsize; /* max sectors per request */ int rqsize; /* max sectors per request */
int irq; /* our irq number */ int irq; /* our irq number */
@@ -1410,7 +1412,7 @@ int ide_pci_resume(struct pci_dev *);
#endif #endif
void ide_map_sg(ide_drive_t *, struct request *); void ide_map_sg(ide_drive_t *, struct request *);
void ide_init_sg_cmd(ide_drive_t *, struct request *); void ide_init_sg_cmd(struct ide_cmd *, int);
#define BAD_DMA_DRIVE 0 #define BAD_DMA_DRIVE 0
#define GOOD_DMA_DRIVE 1 #define GOOD_DMA_DRIVE 1