Skip to content

L
linux
Commit 4a58bd1a authored by Martin Dalecki's avatar Martin Dalecki Committed by Linus Torvalds
Browse files
Options

[PATCH] 2.5.11 IDE 46 

- Remove the specific CONFIG_IDEDMA_PCI_WIP in favor of using the generic
   CONFIG_EXPERIMENTAL tag. (Pointed out by Vojtech Pavlik).

- Change the signature of the IRQ handler to take the request directly as a
   parameter. This doesn't blow the code up but makes it much more obvious and
   finally it's reducing the number of side effects of the hwgroup->rq field.

- A second sharp look after the above change allowed us to remove the wrq field
   from the hwgroup struct. It's just not used at all.

- Change the signature of the end_request member of struct ata_operations to
   take the request as a second argument. Similar for __ide_end_request()
   and ide_end_request().

- Remove BUG_ON() items just before ide_set_handler(). The check in
   ide_set_handler is clever enough now.

- Remove the rq subfield from ide-scsi packet structure. We have now the
   request context always in place. Same for floppy.

- Let the timer expiry function take the request as a direct argument.

Yes I know those changes are extensive. But they are a necessary step
in between for the following purposes:

- Consolidate the whole ATA/ATAPI stuff on passing a single unified request
   handling object. Because after eliminating those side effects it's far easier
   to see what's passed where.

- Minimizing the amount of side effects in the overall code. That's a good
   thing anyway and it *doesn't* cost us neither performance nor space, since
   the stack depths are small anyway here.

- Minimizing the usage of hwgroup - which should go away if possible.
parent b960fa03
Show whitespace changes
Inline Side-by-side
Showing with 516 additions and 640 deletions
arch/alpha/defconfig
View file @ 4a58bd1a
......@@ -252,7 +252,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
CONFIG_IDEDMA_PCI_AUTO=y
# CONFIG_IDEDMA_ONLYDISK is not set
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/arm/def-configs/footbridge
View file @ 4a58bd1a
......@@ -409,7 +409,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
CONFIG_BLK_DEV_OFFBOARD=y
CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/arm/def-configs/iq80310
View file @ 4a58bd1a
......@@ -460,7 +460,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/cris/drivers/ide.c
View file @ 4a58bd1a
......@@ -687,7 +687,7 @@ static int config_drive_for_dma (ide_drive_t *drive)
/*
* etrax_dma_intr() is the handler for disk read/write DMA interrupts
*/
static ide_startstop_t etrax_dma_intr (ide_drive_t *drive)
static ide_startstop_t etrax_dma_intr (struct ata_device *drive, struct request *rq)
{
int i, dma_stat;
byte stat;
......@@ -699,11 +699,9 @@ static ide_startstop_t etrax_dma_intr (ide_drive_t *drive)
stat = GET_STAT(); /* get drive status */
if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
if (!dma_stat) {
struct request *rq;
rq = HWGROUP(drive)->rq;
for (i = rq->nr_sectors; i > 0;) {
i -= rq->current_nr_sectors;
ide_end_request(drive, 1);
ide_end_request(drive, rq, 1);
}
return ide_stopped;
}
......
arch/i386/defconfig
View file @ 4a58bd1a
......@@ -263,7 +263,6 @@ CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_BLK_DEV_IDE_TCQ is not set
# CONFIG_BLK_DEV_IDE_TCQ_DEFAULT is not set
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ia64/defconfig
View file @ 4a58bd1a
......@@ -233,7 +233,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_IDEDMA_PCI_AUTO is not set
# CONFIG_IDEDMA_ONLYDISK is not set
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ia64/sn/configs/sn1/defconfig-bigsur-mp
View file @ 4a58bd1a
......@@ -212,7 +212,6 @@ CONFIG_BLK_DEV_ADMA=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ia64/sn/configs/sn1/defconfig-bigsur-sp
View file @ 4a58bd1a
......@@ -212,7 +212,6 @@ CONFIG_BLK_DEV_ADMA=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/mips/defconfig-ddb5476
View file @ 4a58bd1a
......@@ -227,7 +227,6 @@ CONFIG_BLK_DEV_IDEPCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
# CONFIG_BLK_DEV_IDEDMA is not set
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/mips/defconfig-it8172
View file @ 4a58bd1a
......@@ -292,7 +292,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/configs/common_defconfig
View file @ 4a58bd1a
......@@ -255,7 +255,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/configs/k2_defconfig
View file @ 4a58bd1a
......@@ -238,7 +238,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/configs/menf1_defconfig
View file @ 4a58bd1a
......@@ -242,7 +242,6 @@ CONFIG_BLK_DEV_IDEPCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
# CONFIG_BLK_DEV_IDEDMA is not set
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/configs/mvme5100_defconfig
View file @ 4a58bd1a
......@@ -236,7 +236,6 @@ CONFIG_BLK_DEV_IDEPCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
# CONFIG_BLK_DEV_IDEDMA is not set
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/configs/pmac_defconfig
View file @ 4a58bd1a
......@@ -245,7 +245,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/configs/pplus_defconfig
View file @ 4a58bd1a
......@@ -249,7 +249,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/configs/sandpoint_defconfig
View file @ 4a58bd1a
......@@ -212,7 +212,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
# CONFIG_IDEDMA_PCI_AUTO is not set
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/ppc/defconfig
View file @ 4a58bd1a
......@@ -255,7 +255,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
# CONFIG_BLK_DEV_OFFBOARD is not set
CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/sparc64/defconfig
View file @ 4a58bd1a
......@@ -289,7 +289,6 @@ CONFIG_BLK_DEV_IDEDMA_PCI=y
CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_IDEDMA_ONLYDISK=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
arch/x86_64/defconfig
View file @ 4a58bd1a
......@@ -214,7 +214,6 @@ CONFIG_IDEDMA_PCI_AUTO=y
CONFIG_BLK_DEV_IDEDMA=y
# CONFIG_BLK_DEV_IDE_TCQ is not set
# CONFIG_BLK_DEV_IDE_TCQ_DEFAULT is not set
# CONFIG_IDEDMA_PCI_WIP is not set
# CONFIG_IDEDMA_NEW_DRIVE_LISTINGS is not set
# CONFIG_BLK_DEV_AEC62XX is not set
# CONFIG_AEC62XX_TUNING is not set
......
drivers/ide/Config.help
View file @ 4a58bd1a
......@@ -299,13 +299,6 @@ CONFIG_IDEDMA_IVB
It is normally safe to answer Y; however, the default is N.
CONFIG_IDEDMA_PCI_WIP
If you enable this you will be able to use and test highly
developmental projects. If you say N, the configurator will
simply skip those options.
It is SAFEST to say N to this question.
CONFIG_BLK_DEV_PDC_ADMA
Please read the comments at the top of <file:drivers/ide/ide-pci.c>.
......
drivers/ide/Config.in
View file @ 4a58bd1a
......@@ -47,18 +47,17 @@ if [ "$CONFIG_BLK_DEV_IDE" != "n" ]; then
dep_bool ' Use PCI DMA by default when available' CONFIG_IDEDMA_PCI_AUTO $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' Enable DMA only for disks ' CONFIG_IDEDMA_ONLYDISK $CONFIG_IDEDMA_PCI_AUTO
define_bool CONFIG_BLK_DEV_IDEDMA $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' ATA Work(s) In Progress (EXPERIMENTAL)' CONFIG_IDEDMA_PCI_WIP $CONFIG_BLK_DEV_IDEDMA_PCI $CONFIG_EXPERIMENTAL
dep_bool ' Good-Bad DMA Model-Firmware (WIP)' CONFIG_IDEDMA_NEW_DRIVE_LISTINGS $CONFIG_IDEDMA_PCI_WIP
dep_bool ' Good-Bad DMA Model-Firmware (EXPERIMENTAL)' CONFIG_IDEDMA_NEW_DRIVE_LISTINGS $CONFIG_EXPERIMENTAL
dep_bool ' AEC62XX chipset support' CONFIG_BLK_DEV_AEC62XX $CONFIG_BLK_DEV_IDEDMA_PCI
dep_mbool ' AEC62XX Tuning support' CONFIG_AEC62XX_TUNING $CONFIG_BLK_DEV_AEC62XX
dep_bool ' ALI M15x3 chipset support' CONFIG_BLK_DEV_ALI15X3 $CONFIG_BLK_DEV_IDEDMA_PCI
dep_mbool ' ALI M15x3 WDC support (DANGEROUS)' CONFIG_WDC_ALI15X3 $CONFIG_BLK_DEV_ALI15X3
dep_mbool ' ALI M15x3 WDC support (DANGEROUS)' CONFIG_WDC_ALI15X3 $CONFIG_BLK_DEV_ALI15X3 $CONFIG_EXPERIMENTAL
dep_bool ' AMD and nVidia chipset support' CONFIG_BLK_DEV_AMD74XX $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' CMD64X chipset support' CONFIG_BLK_DEV_CMD64X $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' CY82C693 chipset support' CONFIG_BLK_DEV_CY82C693 $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' Cyrix CS5530 MediaGX chipset support' CONFIG_BLK_DEV_CS5530 $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' HPT34X chipset support' CONFIG_BLK_DEV_HPT34X $CONFIG_BLK_DEV_IDEDMA_PCI
dep_mbool ' HPT34X AUTODMA support (WIP)' CONFIG_HPT34X_AUTODMA $CONFIG_BLK_DEV_HPT34X $CONFIG_IDEDMA_PCI_WIP
dep_mbool ' HPT34X AUTODMA support (EXPERMENTAL)' CONFIG_HPT34X_AUTODMA $CONFIG_BLK_DEV_HPT34X $CONFIG_EXPERIMENTAL
dep_bool ' HPT366 chipset support' CONFIG_BLK_DEV_HPT366 $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' Intel and Efar (SMsC) chipset support' CONFIG_BLK_DEV_PIIX $CONFIG_BLK_DEV_IDEDMA_PCI
if [ "$CONFIG_MIPS_ITE8172" = "y" -o "$CONFIG_MIPS_IVR" = "y" ]; then
......@@ -67,7 +66,7 @@ if [ "$CONFIG_BLK_DEV_IDE" != "n" ]; then
fi
dep_bool ' NS87415 chipset support (EXPERIMENTAL)' CONFIG_BLK_DEV_NS87415 $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' OPTi 82C621 chipset enhanced support (EXPERIMENTAL)' CONFIG_BLK_DEV_OPTI621 $CONFIG_EXPERIMENTAL
dep_mbool ' Pacific Digital A-DMA support (EXPERIMENTAL)' CONFIG_BLK_DEV_PDC_ADMA $CONFIG_IDEDMA_PCI_WIP
dep_mbool ' Pacific Digital A-DMA support (EXPERIMENTAL)' CONFIG_BLK_DEV_PDC_ADMA $CONFIG_EXPERIMENTAL
dep_bool ' PROMISE PDC202{46|62|65|67|68|69|70} support' CONFIG_BLK_DEV_PDC202XX $CONFIG_BLK_DEV_IDEDMA_PCI
dep_bool ' Special UDMA Feature' CONFIG_PDC202XX_BURST $CONFIG_BLK_DEV_PDC202XX
dep_bool ' Special FastTrak Feature' CONFIG_PDC202XX_FORCE $CONFIG_BLK_DEV_PDC202XX
......
drivers/ide/aec62xx.c
View file @ 4a58bd1a
......@@ -437,7 +437,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (id && (id->capability & 1) && drive->channel->autodma) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive)) {
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL)) {
dma_func = ide_dma_off;
goto fast_ata_pio;
}
......@@ -459,7 +459,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (dma_func != ide_dma_on)
goto no_dma_set;
}
} else if (ide_dmaproc(ide_dma_good_drive, drive)) {
} else if (ide_dmaproc(ide_dma_good_drive, drive, NULL)) {
if (id->eide_dma_time > 150) {
goto no_dma_set;
}
......@@ -476,13 +476,13 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
no_dma_set:
aec62xx_tune_drive(drive, 5);
}
return drive->channel->dmaproc(dma_func, drive);
return drive->channel->udma(dma_func, drive, NULL);
}
/*
* aec62xx_dmaproc() initiates/aborts (U)DMA read/write operations on a drive.
*/
int aec62xx_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
int aec62xx_dmaproc (ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
switch (func) {
case ide_dma_check:
......@@ -507,7 +507,7 @@ int aec62xx_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
default:
break;
}
return ide_dmaproc(func, drive); /* use standard DMA stuff */
return ide_dmaproc(func, drive, rq); /* use standard DMA stuff */
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
#endif /* CONFIG_AEC62XX_TUNING */
......@@ -542,17 +542,17 @@ unsigned int __init ata66_aec62xx(struct ata_channel *hwif)
void __init ide_init_aec62xx(struct ata_channel *hwif)
{
#ifdef CONFIG_AEC62XX_TUNING
hwif->tuneproc = &aec62xx_tune_drive;
hwif->speedproc = &aec62xx_tune_chipset;
#ifdef CONFIG_BLK_DEV_IDEDMA
hwif->tuneproc = aec62xx_tune_drive;
hwif->speedproc = aec62xx_tune_chipset;
# ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base)
hwif->dmaproc = &aec62xx_dmaproc;
hwif->udma = aec62xx_dmaproc;
hwif->highmem = 1;
#else /* !CONFIG_BLK_DEV_IDEDMA */
# else
hwif->drives[0].autotune = 1;
hwif->drives[1].autotune = 1;
#endif /* CONFIG_BLK_DEV_IDEDMA */
#endif /* CONFIG_AEC62XX_TUNING */
# endif
#endif
}
void __init ide_dmacapable_aec62xx(struct ata_channel *hwif, unsigned long dmabase)
......
drivers/ide/alim15x3.c
View file @ 4a58bd1a
......@@ -437,11 +437,11 @@ static int ali15x3_config_drive_for_dma(ide_drive_t *drive)
byte can_ultra_dma = ali15x3_can_ultra(drive);
if ((m5229_revision<=0x20) && (drive->type != ATA_DISK))
return hwif->dmaproc(ide_dma_off_quietly, drive);
return hwif->udma(ide_dma_off_quietly, drive, NULL);
if ((id != NULL) && ((id->capability & 1) != 0) && hwif->autodma) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive)) {
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL)) {
dma_func = ide_dma_off;
goto fast_ata_pio;
}
......@@ -463,7 +463,7 @@ static int ali15x3_config_drive_for_dma(ide_drive_t *drive)
if (dma_func != ide_dma_on)
goto no_dma_set;
}
} else if (ide_dmaproc(ide_dma_good_drive, drive)) {
} else if (ide_dmaproc(ide_dma_good_drive, drive, NULL)) {
if (id->eide_dma_time > 150) {
goto no_dma_set;
}
......@@ -480,10 +480,10 @@ static int ali15x3_config_drive_for_dma(ide_drive_t *drive)
no_dma_set:
config_chipset_for_pio(drive);
}
return hwif->dmaproc(dma_func, drive);
return hwif->udma(dma_func, drive, NULL);
}
static int ali15x3_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
static int ali15x3_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
switch(func) {
case ide_dma_check:
......@@ -495,7 +495,7 @@ static int ali15x3_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
default:
break;
}
return ide_dmaproc(func, drive); /* use standard DMA stuff */
return ide_dmaproc(func, drive, rq); /* use standard DMA stuff */
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -672,14 +672,14 @@ void __init ide_init_ali15x3(struct ata_channel *hwif)
hwif->tuneproc = &ali15x3_tune_drive;
hwif->drives[0].autotune = 1;
hwif->drives[1].autotune = 1;
hwif->speedproc = &ali15x3_tune_chipset;
hwif->speedproc = ali15x3_tune_chipset;
#ifdef CONFIG_BLK_DEV_IDEDMA
if ((hwif->dma_base) && (m5229_revision >= 0x20)) {
/*
* M1543C or newer for DMAing
*/
hwif->dmaproc = &ali15x3_dmaproc;
hwif->udma = ali15x3_dmaproc;
hwif->autodma = 1;
}
......
drivers/ide/amd74xx.c
View file @ 4a58bd1a
......@@ -282,7 +282,7 @@ static void amd74xx_tune_drive(ide_drive_t *drive, unsigned char pio)
* else to the default ide_dmaproc().
*/
int amd74xx_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
int amd74xx_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
if (func == ide_dma_check) {
......@@ -301,7 +301,7 @@ int amd74xx_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
? ide_dma_on : ide_dma_off_quietly;
}
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -433,13 +433,13 @@ void __init ide_init_amd74xx(struct ata_channel *hwif)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base) {
hwif->highmem = 1;
hwif->dmaproc = &amd74xx_dmaproc;
#ifdef CONFIG_IDEDMA_AUTO
hwif->udma = amd74xx_dmaproc;
# ifdef CONFIG_IDEDMA_AUTO
if (!noautodma)
hwif->autodma = 1;
#endif
# endif
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
#endif
}
/*
......
drivers/ide/cmd64x.c
View file @ 4a58bd1a
......@@ -777,13 +777,13 @@ static int cmd64x_config_drive_for_dma (ide_drive_t *drive)
can_ultra_100 = 0;
break;
default:
return hwif->dmaproc(ide_dma_off, drive);
return hwif->udma(ide_dma_off, drive, NULL);
}
if ((id != NULL) && ((id->capability & 1) != 0) &&
hwif->autodma && (drive->type == ATA_DISK)) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive)) {
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL)) {
dma_func = ide_dma_off;
goto fast_ata_pio;
}
......@@ -805,7 +805,7 @@ static int cmd64x_config_drive_for_dma (ide_drive_t *drive)
if (dma_func != ide_dma_on)
goto no_dma_set;
}
} else if (ide_dmaproc(ide_dma_good_drive, drive)) {
} else if (ide_dmaproc(ide_dma_good_drive, drive, NULL)) {
if (id->eide_dma_time > 150) {
goto no_dma_set;
}
......@@ -822,10 +822,10 @@ static int cmd64x_config_drive_for_dma (ide_drive_t *drive)
no_dma_set:
config_chipset_for_pio(drive, 1);
}
return drive->channel->dmaproc(dma_func, drive);
return drive->channel->udma(dma_func, drive, NULL);
}
static int cmd680_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
static int cmd680_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
switch (func) {
case ide_dma_check:
......@@ -834,10 +834,10 @@ static int cmd680_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
break;
}
/* Other cases are done by generic IDE-DMA code. */
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
static int cmd64x_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
static int cmd64x_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
byte dma_stat = 0;
byte dma_alt_stat = 0;
......@@ -882,14 +882,14 @@ static int cmd64x_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
break;
}
/* Other cases are done by generic IDE-DMA code. */
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
/*
* ASUS P55T2P4D with CMD646 chipset revision 0x01 requires the old
* event order for DMA transfers.
*/
static int cmd646_1_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
static int cmd646_1_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
struct ata_channel *hwif = drive->channel;
unsigned long dma_base = hwif->dma_base;
......@@ -910,7 +910,7 @@ static int cmd646_1_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
}
/* Other cases are done by generic IDE-DMA code. */
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -1125,7 +1125,7 @@ void __init ide_init_cmd64x(struct ata_channel *hwif)
switch(dev->device) {
case PCI_DEVICE_ID_CMD_680:
hwif->busproc = &cmd680_busproc;
hwif->dmaproc = &cmd680_dmaproc;
hwif->udma = &cmd680_dmaproc;
hwif->resetproc = &cmd680_reset;
hwif->speedproc = &cmd680_tune_chipset;
hwif->tuneproc = &cmd680_tuneproc;
......@@ -1133,16 +1133,16 @@ void __init ide_init_cmd64x(struct ata_channel *hwif)
case PCI_DEVICE_ID_CMD_649:
case PCI_DEVICE_ID_CMD_648:
case PCI_DEVICE_ID_CMD_643:
hwif->dmaproc = &cmd64x_dmaproc;
hwif->udma = &cmd64x_dmaproc;
hwif->tuneproc = &cmd64x_tuneproc;
hwif->speedproc = &cmd64x_tune_chipset;
break;
case PCI_DEVICE_ID_CMD_646:
hwif->chipset = ide_cmd646;
if (class_rev == 0x01) {
hwif->dmaproc = &cmd646_1_dmaproc;
hwif->udma = &cmd646_1_dmaproc;
} else {
hwif->dmaproc = &cmd64x_dmaproc;
hwif->udma = &cmd64x_dmaproc;
}
hwif->tuneproc = &cmd64x_tuneproc;
hwif->speedproc = &cmd64x_tune_chipset;
......
drivers/ide/cs5530.c
View file @ 4a58bd1a
......@@ -144,7 +144,7 @@ static int cs5530_config_dma (ide_drive_t *drive)
/*
* Default to DMA-off in case we run into trouble here.
*/
(void)hwif->dmaproc(ide_dma_off_quietly, drive); /* turn off DMA while we fiddle */
hwif->udma(ide_dma_off_quietly, drive, NULL);
outb(inb(hwif->dma_base+2)&~(unit?0x40:0x20), hwif->dma_base+2); /* clear DMA_capable bit */
/*
......@@ -158,7 +158,7 @@ static int cs5530_config_dma (ide_drive_t *drive)
*/
if (mate->present) {
struct hd_driveid *mateid = mate->id;
if (mateid && (mateid->capability & 1) && !hwif->dmaproc(ide_dma_bad_drive, mate)) {
if (mateid && (mateid->capability & 1) && !hwif->udma(ide_dma_bad_drive, mate, NULL)) {
if ((mateid->field_valid & 4) && (mateid->dma_ultra & 7))
udma_ok = 1;
else if ((mateid->field_valid & 2) && (mateid->dma_mword & 7))
......@@ -172,7 +172,7 @@ static int cs5530_config_dma (ide_drive_t *drive)
* Now see what the current drive is capable of,
* selecting UDMA only if the mate said it was ok.
*/
if (id && (id->capability & 1) && hwif->autodma && !hwif->dmaproc(ide_dma_bad_drive, drive)) {
if (id && (id->capability & 1) && hwif->autodma && !hwif->udma(ide_dma_bad_drive, drive, NULL)) {
if (udma_ok && (id->field_valid & 4) && (id->dma_ultra & 7)) {
if (id->dma_ultra & 4)
mode = XFER_UDMA_2;
......@@ -229,7 +229,7 @@ static int cs5530_config_dma (ide_drive_t *drive)
/*
* Finally, turn DMA on in software, and exit.
*/
return hwif->dmaproc(ide_dma_on, drive); /* success */
return hwif->udma(ide_dma_on, drive, NULL); /* success */
}
/*
......@@ -237,7 +237,7 @@ static int cs5530_config_dma (ide_drive_t *drive)
* We need it for our custom "ide_dma_check" function.
* All other requests are forwarded to the standard ide_dmaproc().
*/
int cs5530_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
int cs5530_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
switch (func) {
case ide_dma_check:
......@@ -246,7 +246,7 @@ int cs5530_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
break;
}
/* Other cases are done by generic IDE-DMA code. */
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -353,7 +353,7 @@ void __init ide_init_cs5530(struct ata_channel *hwif)
unsigned int basereg, d0_timings;
#ifdef CONFIG_BLK_DEV_IDEDMA
hwif->dmaproc = &cs5530_dmaproc;
hwif->udma = cs5530_dmaproc;
hwif->highmem = 1;
#else
hwif->autodma = 0;
......
drivers/ide/cy82c693.c
View file @ 4a58bd1a
......@@ -234,7 +234,7 @@ static void cy82c693_dma_enable (ide_drive_t *drive, int mode, int single)
/*
* used to set DMA mode for CY82C693 (single and multi modes)
*/
static int cy82c693_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
static int cy82c693_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
/*
* if the function is dma on, set dma mode for drive everything
......@@ -262,7 +262,7 @@ static int cy82c693_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
}
}
}
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -442,7 +442,7 @@ void __init ide_init_cy82c693(struct ata_channel *hwif)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base) {
hwif->highmem = 1;
hwif->dmaproc = cy82c693_dmaproc;
hwif->udma = cy82c693_dmaproc;
if (!noautodma)
hwif->autodma = 1;
}
......
drivers/ide/hpt34x.c
View file @ 4a58bd1a
......@@ -334,7 +334,6 @@ int hpt34x_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
drive->waiting_for_dma = 1;
if (drive->type != ATA_DISK)
return 0;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &ide_dma_intr, WAIT_CMD, NULL); /* issue cmd to drive */
OUT_BYTE((reading == 9) ? WIN_READDMA : WIN_WRITEDMA, IDE_COMMAND_REG);
return 0;
......
drivers/ide/hpt366.c
View file @ 4a58bd1a
......@@ -750,7 +750,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (id && (id->capability & 1) && drive->channel->autodma) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive)) {
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL)) {
dma_func = ide_dma_off;
goto fast_ata_pio;
}
......@@ -771,7 +771,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (dma_func != ide_dma_on)
goto no_dma_set;
}
} else if (ide_dmaproc(ide_dma_good_drive, drive)) {
} else if (ide_dmaproc(ide_dma_good_drive, drive, NULL)) {
if (id->eide_dma_time > 150) {
goto no_dma_set;
}
......@@ -789,7 +789,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
config_chipset_for_pio(drive);
}
return drive->channel->dmaproc(dma_func, drive);
return drive->channel->udma(dma_func, drive, NULL);
}
/*
......@@ -798,7 +798,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
* This is specific to the HPT366 UDMA bios chipset
* by HighPoint|Triones Technologies, Inc.
*/
int hpt366_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
int hpt366_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
byte reg50h = 0, reg52h = 0, reg5ah = 0, dma_stat = 0;
unsigned long dma_base = drive->channel->dma_base;
......@@ -829,10 +829,10 @@ int hpt366_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
default:
break;
}
return ide_dmaproc(func, drive); /* use standard DMA stuff */
return ide_dmaproc(func, drive, rq); /* use standard DMA stuff */
}
int hpt370_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
int hpt370_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
struct ata_channel *hwif = drive->channel;
unsigned long dma_base = hwif->dma_base;
......@@ -883,7 +883,7 @@ int hpt370_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
default:
break;
}
return ide_dmaproc(func, drive); /* use standard DMA stuff */
return ide_dmaproc(func, drive, rq); /* use standard DMA stuff */
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -1185,9 +1185,9 @@ void __init ide_init_hpt366(struct ata_channel *hwif)
pci_read_config_byte(hwif->pci_dev, 0x5a, &reg5ah);
if (reg5ah & 0x10) /* interrupt force enable */
pci_write_config_byte(hwif->pci_dev, 0x5a, reg5ah & ~0x10);
hwif->dmaproc = &hpt370_dmaproc;
hwif->udma = hpt370_dmaproc;
} else {
hwif->dmaproc = &hpt366_dmaproc;
hwif->udma = hpt366_dmaproc;
}
if (!noautodma)
hwif->autodma = 1;
......
drivers/ide/icside.c
View file @ 4a58bd1a
......@@ -327,7 +327,7 @@ icside_set_speed(ide_drive_t *drive, byte speed)
/*
* dma_intr() is the handler for disk read/write DMA interrupts
*/
static ide_startstop_t icside_dmaintr(ide_drive_t *drive)
static ide_startstop_t icside_dmaintr(struct ata_device *drive, struct request *rq)
{
int i;
byte stat, dma_stat;
......@@ -336,8 +336,6 @@ static ide_startstop_t icside_dmaintr(ide_drive_t *drive)
stat = GET_STAT(); /* get drive status */
if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
if (!dma_stat) {
struct request *rq = HWGROUP(drive)->rq;
rq = HWGROUP(drive)->rq;
for (i = rq->nr_sectors; i > 0;) {
i -= rq->current_nr_sectors;
ide_end_request(drive, 1);
......@@ -443,8 +441,7 @@ icside_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
if (drive->type != ATA_DISK)
return 0;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &icside_dmaintr, WAIT_CMD, NULL);
ide_set_handler(drive, icside_dmaintr, WAIT_CMD, NULL);
OUT_BYTE(reading ? WIN_READDMA : WIN_WRITEDMA,
IDE_COMMAND_REG);
......
drivers/ide/ide-cd.c
View file @ 4a58bd1a
......@@ -548,26 +548,23 @@ static void cdrom_queue_request_sense(ide_drive_t *drive,
}
static void cdrom_end_request(ide_drive_t *drive, int uptodate)
static void cdrom_end_request(struct ata_device *drive, struct request *rq, int uptodate)
{
struct request *rq = HWGROUP(drive)->rq;
if ((rq->flags & REQ_SENSE) && uptodate)
cdrom_analyze_sense_data(drive, rq);
if ((rq->flags & REQ_CMD) && !rq->current_nr_sectors)
uptodate = 1;
ide_end_request(drive, uptodate);
ide_end_request(drive, rq, uptodate);
}
/* Returns 0 if the request should be continued.
Returns 1 if the request was ended. */
static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
static int cdrom_decode_status(ide_startstop_t *startstop, struct ata_device *drive, struct request *rq,
int good_stat, int *stat_ret)
{
struct request *rq = HWGROUP(drive)->rq;
int stat, err, sense_key;
struct packet_command *pc;
......@@ -583,7 +580,7 @@ static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
sense_key = err >> 4;
if (rq == NULL) {
printk("%s: missing rq in cdrom_decode_status\n", drive->name);
printk("%s: missing rq in %s\n", drive->name, __FUNCTION__);
*startstop = ide_stopped;
return 1;
}
......@@ -596,7 +593,7 @@ static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
/* FIXME --mdcki */
pc = (struct packet_command *) rq->special;
pc->stat = 1;
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
*startstop = ide_error (drive, "request sense failure", stat);
return 1;
......@@ -634,7 +631,7 @@ static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
}
pc->stat = 1;
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
/* FIXME: this is the only place where pc->sense get's used.
* Think hard about how to get rid of it...
......@@ -651,7 +648,7 @@ static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
/* Fail the request. */
printk ("%s: tray open\n", drive->name);
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
} else if (sense_key == UNIT_ATTENTION) {
/* Media change. */
cdrom_saw_media_change (drive);
......@@ -660,27 +657,27 @@ static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
But be sure to give up if we've retried
too many times. */
if (++rq->errors > ERROR_MAX)
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
} else if (sense_key == ILLEGAL_REQUEST ||
sense_key == DATA_PROTECT) {
/* No point in retrying after an illegal
request or data protect error.*/
ide_dump_status (drive, "command error", stat);
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
} else if (sense_key == MEDIUM_ERROR) {
/* No point in re-trying a zillion times on a bad
* sector. The error is not correctable at all.
*/
ide_dump_status (drive, "media error (bad sector)", stat);
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
} else if ((err & ~ABRT_ERR) != 0) {
/* Go to the default handler
for other errors. */
*startstop = ide_error (drive, "cdrom_decode_status", stat);
*startstop = ide_error (drive, __FUNCTION__, stat);
return 1;
} else if ((++rq->errors > ERROR_MAX)) {
/* We've racked up too many retries. Abort. */
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
}
/* If we got a CHECK_CONDITION status,
......@@ -695,9 +692,8 @@ static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
return 1;
}
static int cdrom_timer_expiry(ide_drive_t *drive)
static int cdrom_timer_expiry(struct ata_device *drive, struct request *rq)
{
struct request *rq = HWGROUP(drive)->rq;
unsigned long wait = 0;
/*
......@@ -727,9 +723,10 @@ static int cdrom_timer_expiry(ide_drive_t *drive)
called when the interrupt from the drive arrives. Otherwise, HANDLER
will be called immediately after the drive is prepared for the transfer. */
static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
static ide_startstop_t cdrom_start_packet_command(struct ata_device *drive,
struct request *rq,
int xferlen,
ide_handler_t *handler)
ata_handler_t handler)
{
ide_startstop_t startstop;
struct cdrom_info *info = drive->driver_data;
......@@ -740,9 +737,9 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
if (info->dma) {
if (info->cmd == READ)
info->dma = !drive->channel->dmaproc(ide_dma_read, drive);
info->dma = !drive->channel->udma(ide_dma_read, drive, rq);
else if (info->cmd == WRITE)
info->dma = !drive->channel->dmaproc(ide_dma_write, drive);
info->dma = !drive->channel->udma(ide_dma_write, drive, rq);
else
printk("ide-cd: DMA set, but not allowed\n");
}
......@@ -758,16 +755,15 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
if (info->dma)
drive->channel->dmaproc(ide_dma_begin, drive);
drive->channel->udma(ide_dma_begin, drive, NULL);
if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, handler, WAIT_CMD, cdrom_timer_expiry);
ide_set_handler(drive, handler, WAIT_CMD, cdrom_timer_expiry);
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
return ide_started;
} else {
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
return (*handler) (drive);
return handler(drive, rq);
}
}
......@@ -776,9 +772,10 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
* already been prepared by cdrom_start_packet_command. "handler" is the
* interrupt handler to call when the command completes or there's data ready.
*/
static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
static ide_startstop_t cdrom_transfer_packet_command(struct ata_device *drive,
struct request *rq,
unsigned char *cmd, unsigned long timeout,
ide_handler_t *handler)
ata_handler_t handler)
{
ide_startstop_t startstop;
......@@ -788,7 +785,7 @@ static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
int stat_dum;
/* Check for errors. */
if (cdrom_decode_status(&startstop, drive, DRQ_STAT, &stat_dum))
if (cdrom_decode_status(&startstop, drive, rq, DRQ_STAT, &stat_dum))
return startstop;
} else {
/* Otherwise, we must wait for DRQ to get set. */
......@@ -797,7 +794,6 @@ static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
}
/* Arm the interrupt handler. */
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, handler, timeout, cdrom_timer_expiry);
/* Send the command to the device. */
......@@ -861,7 +857,7 @@ static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
* ok; nonzero if the request has been terminated.
*/
static inline
int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
int cdrom_read_check_ireason(struct ata_device *drive, struct request *rq, int len, int ireason)
{
ireason &= 3;
if (ireason == 2) return 0;
......@@ -891,14 +887,14 @@ int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
drive->name, ireason);
}
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
return -1;
}
/*
* Interrupt routine. Called when a read request has completed.
*/
static ide_startstop_t cdrom_read_intr(ide_drive_t *drive)
static ide_startstop_t cdrom_read_intr(struct ata_device *drive, struct request *rq)
{
int stat;
int ireason, len, sectors_to_transfer, nskip;
......@@ -906,21 +902,19 @@ static ide_startstop_t cdrom_read_intr(ide_drive_t *drive)
int dma = info->dma, dma_error = 0;
ide_startstop_t startstop;
struct request *rq = HWGROUP(drive)->rq;
/* Check for errors. */
if (dma) {
info->dma = 0;
if ((dma_error = drive->channel->dmaproc(ide_dma_end, drive)))
drive->channel->dmaproc(ide_dma_off, drive);
if ((dma_error = drive->channel->udma(ide_dma_end, drive, NULL)))
drive->channel->udma(ide_dma_off, drive, NULL);
}
if (cdrom_decode_status (&startstop, drive, 0, &stat))
if (cdrom_decode_status(&startstop, drive, rq, 0, &stat))
return startstop;
if (dma) {
if (!dma_error) {
__ide_end_request(drive, 1, rq->nr_sectors);
__ide_end_request(drive, rq, 1, rq->nr_sectors);
return ide_stopped;
} else
return ide_error (drive, "dma error", stat);
......@@ -937,14 +931,14 @@ static ide_startstop_t cdrom_read_intr(ide_drive_t *drive)
if (rq->current_nr_sectors > 0) {
printk ("%s: cdrom_read_intr: data underrun (%u blocks)\n",
drive->name, rq->current_nr_sectors);
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
} else
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
return ide_stopped;
}
/* Check that the drive is expecting to do the same thing we are. */
if (cdrom_read_check_ireason (drive, len, ireason))
if (cdrom_read_check_ireason(drive, rq, len, ireason))
return ide_stopped;
/* Assume that the drive will always provide data in multiples
......@@ -959,7 +953,7 @@ static ide_startstop_t cdrom_read_intr(ide_drive_t *drive)
printk (" Trying to limit transfer sizes\n");
CDROM_CONFIG_FLAGS (drive)->limit_nframes = 1;
}
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
return ide_stopped;
}
......@@ -987,7 +981,7 @@ static ide_startstop_t cdrom_read_intr(ide_drive_t *drive)
/* If we've filled the present buffer but there's another
chained buffer after it, move on. */
if (rq->current_nr_sectors == 0 && rq->nr_sectors)
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
/* If the buffers are full, cache the rest of the data in our
internal buffer. */
......@@ -1015,10 +1009,8 @@ static ide_startstop_t cdrom_read_intr(ide_drive_t *drive)
}
}
/* Done moving data!
Wait for another interrupt. */
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &cdrom_read_intr, WAIT_CMD, NULL);
/* Done moving data! Wait for another interrupt. */
ide_set_handler(drive, cdrom_read_intr, WAIT_CMD, NULL);
return ide_started;
}
......@@ -1027,10 +1019,9 @@ static ide_startstop_t cdrom_read_intr(ide_drive_t *drive)
* Try to satisfy some of the current read request from our cached data.
* Returns nonzero if the request has been completed, zero otherwise.
*/
static int cdrom_read_from_buffer (ide_drive_t *drive)
static int cdrom_read_from_buffer(struct ata_device *drive, struct request *rq)
{
struct cdrom_info *info = drive->driver_data;
struct request *rq = HWGROUP(drive)->rq;
/* Can't do anything if there's no buffer. */
if (info->buffer == NULL) return 0;
......@@ -1041,7 +1032,7 @@ static int cdrom_read_from_buffer (ide_drive_t *drive)
rq->sector >= info->sector_buffered &&
rq->sector < info->sector_buffered + info->nsectors_buffered) {
if (rq->current_nr_sectors == 0)
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
memcpy (rq->buffer,
info->buffer +
......@@ -1056,13 +1047,13 @@ static int cdrom_read_from_buffer (ide_drive_t *drive)
/* If we've satisfied the current request,
terminate it successfully. */
if (rq->nr_sectors == 0) {
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
return -1;
}
/* Move on to the next buffer if needed. */
if (rq->current_nr_sectors == 0)
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
/* If this condition does not hold, then the kluge i use to
represent the number of sectors to skip at the start of a transfer
......@@ -1070,9 +1061,9 @@ static int cdrom_read_from_buffer (ide_drive_t *drive)
paranoid and check. */
if (rq->current_nr_sectors < bio_sectors(rq->bio) &&
(rq->sector % SECTORS_PER_FRAME) != 0) {
printk ("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
drive->name, rq->sector);
cdrom_end_request(drive, 0);
printk ("%s: %s: buffer botch (%ld)\n",
drive->name, __FUNCTION__, rq->sector);
cdrom_end_request(drive, rq, 0);
return -1;
}
......@@ -1084,9 +1075,8 @@ static int cdrom_read_from_buffer (ide_drive_t *drive)
* directly from cdrom_start_read. However, for drq_interrupt devices, it is
* called from an interrupt when the drive is ready to accept the command.
*/
static ide_startstop_t cdrom_start_read_continuation(ide_drive_t *drive)
static ide_startstop_t cdrom_start_read_continuation(struct ata_device *drive, struct request *rq)
{
struct request *rq = HWGROUP(drive)->rq;
int nsect, sector, nframes, frame, nskip;
/* Number of sectors to transfer. */
......@@ -1107,9 +1097,9 @@ static ide_startstop_t cdrom_start_read_continuation(ide_drive_t *drive)
/* Sanity check... */
if (rq->current_nr_sectors != bio_sectors(rq->bio) &&
(rq->sector % CD_FRAMESIZE != 0)) {
printk ("%s: cdrom_start_read_continuation: buffer botch (%u)\n",
drive->name, rq->current_nr_sectors);
cdrom_end_request(drive, 0);
printk ("%s: %s: buffer botch (%u)\n",
drive->name, __FUNCTION__, rq->current_nr_sectors);
cdrom_end_request(drive, rq, 0);
return ide_stopped;
}
sector -= nskip;
......@@ -1128,7 +1118,7 @@ static ide_startstop_t cdrom_start_read_continuation(ide_drive_t *drive)
(65534 / CD_FRAMESIZE) : 65535);
/* Send the command to the drive and return. */
return cdrom_transfer_packet_command(drive, rq->cmd, WAIT_CMD, &cdrom_read_intr);
return cdrom_transfer_packet_command(drive, rq, rq->cmd, WAIT_CMD, &cdrom_read_intr);
}
......@@ -1136,14 +1126,14 @@ static ide_startstop_t cdrom_start_read_continuation(ide_drive_t *drive)
#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
#define IDECD_SEEK_TIMEOUT WAIT_CMD /* 10 sec */
static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
static ide_startstop_t cdrom_seek_intr(struct ata_device *drive, struct request *rq)
{
struct cdrom_info *info = drive->driver_data;
int stat;
static int retry = 10;
ide_startstop_t startstop;
if (cdrom_decode_status (&startstop, drive, 0, &stat))
if (cdrom_decode_status (&startstop, drive, rq, 0, &stat))
return startstop;
CDROM_CONFIG_FLAGS(drive)->seeking = 1;
......@@ -1162,10 +1152,9 @@ static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
return ide_stopped;
}
static ide_startstop_t cdrom_start_seek_continuation(struct ata_device *drive)
static ide_startstop_t cdrom_start_seek_continuation(struct ata_device *drive, struct request *rq)
{
unsigned char cmd[CDROM_PACKET_SIZE];
struct request *rq = HWGROUP(drive)->rq;
sector_t sector;
int frame, nskip;
......@@ -1179,17 +1168,17 @@ static ide_startstop_t cdrom_start_seek_continuation(struct ata_device *drive)
cmd[0] = GPCMD_SEEK;
put_unaligned(cpu_to_be32(frame), (unsigned int *) &cmd[2]);
return cdrom_transfer_packet_command(drive, cmd, WAIT_CMD, &cdrom_seek_intr);
return cdrom_transfer_packet_command(drive, rq, cmd, WAIT_CMD, &cdrom_seek_intr);
}
static ide_startstop_t cdrom_start_seek(struct ata_device *drive, sector_t block)
static ide_startstop_t cdrom_start_seek(struct ata_device *drive, struct request *rq, sector_t block)
{
struct cdrom_info *info = drive->driver_data;
info->dma = 0;
info->cmd = 0;
info->start_seek = jiffies;
return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
return cdrom_start_packet_command(drive, rq, 0, cdrom_start_seek_continuation);
}
/*
......@@ -1214,15 +1203,14 @@ static void restore_request (struct request *rq)
/*
* Start a read request from the CD-ROM.
*/
static ide_startstop_t cdrom_start_read(struct ata_device *drive, sector_t block)
static ide_startstop_t cdrom_start_read(struct ata_device *drive, struct request *rq, sector_t block)
{
struct cdrom_info *info = drive->driver_data;
struct request *rq = HWGROUP(drive)->rq;
restore_request(rq);
/* Satisfy whatever we can of this request from our cached sector. */
if (cdrom_read_from_buffer(drive))
if (cdrom_read_from_buffer(drive, rq))
return ide_stopped;
blk_attempt_remerge(&drive->queue, rq);
......@@ -1239,7 +1227,7 @@ static ide_startstop_t cdrom_start_read(struct ata_device *drive, sector_t block
info->cmd = READ;
/* Start sending the read request to the drive. */
return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
return cdrom_start_packet_command(drive, rq, 32768, cdrom_start_read_continuation);
}
/****************************************************************************
......@@ -1247,17 +1235,16 @@ static ide_startstop_t cdrom_start_read(struct ata_device *drive, sector_t block
*/
/* Interrupt routine for packet command completion. */
static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
static ide_startstop_t cdrom_pc_intr(struct ata_device *drive, struct request *rq)
{
int ireason, len, stat, thislen;
struct request *rq = HWGROUP(drive)->rq;
/* FIXME --mdcki */
struct packet_command *pc = (struct packet_command *) rq->special;
ide_startstop_t startstop;
/* Check for errors. */
if (cdrom_decode_status (&startstop, drive, 0, &stat))
if (cdrom_decode_status (&startstop, drive, rq, 0, &stat))
return startstop;
/* Read the interrupt reason and the transfer length. */
......@@ -1279,7 +1266,7 @@ static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
}
if (pc->buflen == 0)
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
else {
/* Comment this out, because this always happens
right after a reset occurs, and it is annoying to
......@@ -1289,7 +1276,7 @@ static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
drive->name, pc->buflen);
*/
pc->stat = 1;
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
}
return ide_stopped;
}
......@@ -1341,15 +1328,13 @@ static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
}
/* Now we wait for another interrupt. */
ide_set_handler(drive, cdrom_pc_intr, WAIT_CMD, cdrom_timer_expiry);
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, &cdrom_pc_intr, WAIT_CMD, cdrom_timer_expiry);
return ide_started;
}
static ide_startstop_t cdrom_do_pc_continuation(ide_drive_t *drive)
static ide_startstop_t cdrom_do_pc_continuation(struct ata_device *drive, struct request *rq)
{
struct request *rq = HWGROUP(drive)->rq;
unsigned long timeout;
/* FIXME --mdcki */
......@@ -1361,13 +1346,12 @@ static ide_startstop_t cdrom_do_pc_continuation(ide_drive_t *drive)
timeout = WAIT_CMD;
/* Send the command to the drive and return. */
return cdrom_transfer_packet_command(drive, rq->cmd, timeout, &cdrom_pc_intr);
return cdrom_transfer_packet_command(drive, rq, rq->cmd, timeout, &cdrom_pc_intr);
}
static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
static ide_startstop_t cdrom_do_packet_command(struct ata_device *drive, struct request *rq)
{
int len;
struct request *rq = HWGROUP(drive)->rq;
/* FIXME --mdcki */
struct packet_command *pc = (struct packet_command *) rq->special;
......@@ -1379,7 +1363,7 @@ static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
len = pc->buflen;
/* Start sending the command to the drive. */
return cdrom_start_packet_command (drive, len, cdrom_do_pc_continuation);
return cdrom_start_packet_command (drive, rq, len, cdrom_do_pc_continuation);
}
......@@ -1455,7 +1439,8 @@ int cdrom_queue_packet_command(ide_drive_t *drive, unsigned char *cmd,
/*
* Write handling
*/
static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
static inline int cdrom_write_check_ireason(struct ata_device *drive, struct request *rq,
int len, int ireason)
{
/* Two notes about IDE interrupt reason here - 0 means that
* the drive wants to receive data from us, 2 means that
......@@ -1481,29 +1466,27 @@ static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ire
drive->name, ireason);
}
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
return 1;
}
static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
static ide_startstop_t cdrom_write_intr(struct ata_device *drive, struct request *rq)
{
int stat, ireason, len, sectors_to_transfer, uptodate;
struct cdrom_info *info = drive->driver_data;
int dma_error = 0, dma = info->dma;
ide_startstop_t startstop;
struct request *rq = HWGROUP(drive)->rq;
/* Check for errors. */
if (dma) {
info->dma = 0;
if ((dma_error = drive->channel->dmaproc(ide_dma_end, drive))) {
if ((dma_error = drive->channel->udma(ide_dma_end, drive, NULL))) {
printk("ide-cd: write dma error\n");
drive->channel->dmaproc(ide_dma_off, drive);
drive->channel->udma(ide_dma_off, drive, NULL);
}
}
if (cdrom_decode_status(&startstop, drive, 0, &stat)) {
if (cdrom_decode_status(&startstop, drive, rq, 0, &stat)) {
printk("ide-cd: write_intr decode_status bad\n");
return startstop;
}
......@@ -1515,8 +1498,7 @@ static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
if (dma_error)
return ide_error(drive, "dma error", stat);
rq = HWGROUP(drive)->rq;
__ide_end_request(drive, 1, rq->nr_sectors);
__ide_end_request(drive, rq, 1, rq->nr_sectors);
return ide_stopped;
}
......@@ -1535,13 +1517,13 @@ static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
drive->name, rq->current_nr_sectors);
uptodate = 0;
}
cdrom_end_request(drive, uptodate);
cdrom_end_request(drive, rq, uptodate);
return ide_stopped;
}
/* Check that the drive is expecting to do the same thing we are. */
if (ireason & 3)
if (cdrom_write_check_ireason(drive, len, ireason))
if (cdrom_write_check_ireason(drive, rq, len, ireason))
return ide_stopped;
sectors_to_transfer = len / SECTOR_SIZE;
......@@ -1576,23 +1558,21 @@ static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
* current buffer complete, move on
*/
if (rq->current_nr_sectors == 0 && rq->nr_sectors)
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
}
/* re-arm handler */
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &cdrom_write_intr, 5 * WAIT_CMD, NULL);
ide_set_handler(drive, cdrom_write_intr, 5 * WAIT_CMD, NULL);
return ide_started;
}
static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
static ide_startstop_t cdrom_start_write_cont(struct ata_device *drive, struct request *rq)
{
struct request *rq = HWGROUP(drive)->rq;
return cdrom_transfer_packet_command(drive, rq->cmd, 2 * WAIT_CMD, cdrom_write_intr);
return cdrom_transfer_packet_command(drive, rq, rq->cmd, 2 * WAIT_CMD, cdrom_write_intr);
}
static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
static ide_startstop_t cdrom_start_write(struct ata_device *drive, struct request *rq)
{
struct cdrom_info *info = drive->driver_data;
......@@ -1600,7 +1580,7 @@ static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
* writes *must* be 2kB frame aligned
*/
if ((rq->nr_sectors & 3) || (rq->sector & 3)) {
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
return ide_stopped;
}
......@@ -1620,7 +1600,7 @@ static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
info->cmd = WRITE;
/* Start sending the read request to the drive. */
return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
return cdrom_start_packet_command(drive, rq, 32768, cdrom_start_write_cont);
}
#define IDE_LARGE_SEEK(b1,b2,t) (((b1) > (b2) + (t)) || ((b2) > (b1) + (t)))
......@@ -1649,17 +1629,17 @@ ide_cdrom_do_request(struct ata_device *drive, struct request *rq, sector_t bloc
CDROM_CONFIG_FLAGS(drive)->seeking = 0;
}
if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap)
action = cdrom_start_seek(drive, block);
action = cdrom_start_seek(drive, rq, block);
else {
if (rq_data_dir(rq) == READ)
action = cdrom_start_read(drive, block);
action = cdrom_start_read(drive, rq, block);
else
action = cdrom_start_write(drive, rq);
}
info->last_block = block;
return action;
} else if (rq->flags & (REQ_PC | REQ_SENSE)) {
return cdrom_do_packet_command(drive);
return cdrom_do_packet_command(drive, rq);
} else if (rq->flags & REQ_SPECIAL) {
/*
* FIXME: Kill REQ_SEPCIAL and replace it with commands queued
......@@ -1668,7 +1648,7 @@ ide_cdrom_do_request(struct ata_device *drive, struct request *rq, sector_t bloc
* right now this can only be a reset...
*/
cdrom_end_request(drive, 1);
cdrom_end_request(drive, rq, 1);
return ide_stopped;
} else if (rq->flags & REQ_BLOCK_PC) {
struct packet_command pc;
......@@ -1681,7 +1661,7 @@ ide_cdrom_do_request(struct ata_device *drive, struct request *rq, sector_t bloc
/* FIXME --mdcki */
rq->special = (char *) &pc;
startstop = cdrom_do_packet_command(drive);
startstop = cdrom_do_packet_command(drive, rq);
if (pc.stat)
++rq->errors;
......@@ -1689,7 +1669,7 @@ ide_cdrom_do_request(struct ata_device *drive, struct request *rq, sector_t bloc
}
blk_dump_rq_flags(rq, "ide-cd bad flags");
cdrom_end_request(drive, 0);
cdrom_end_request(drive, rq, 0);
return ide_stopped;
}
......@@ -2672,8 +2652,8 @@ int ide_cdrom_probe_capabilities (ide_drive_t *drive)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (drive->using_dma)
(void) drive->channel->dmaproc(ide_dma_verbose, drive);
#endif /* CONFIG_BLK_DEV_IDEDMA */
(void) drive->channel->udma(ide_dma_verbose, drive, NULL);
#endif
printk("\n");
return nslots;
......
drivers/ide/ide-disk.c
View file @ 4a58bd1a
......@@ -275,7 +275,7 @@ static ide_startstop_t idedisk_do_request(struct ata_device *drive, struct reque
if (!(rq->flags & REQ_CMD)) {
blk_dump_rq_flags(rq, "idedisk_do_request - bad command");
ide_end_request(drive, 0);
ide_end_request(drive, rq, 0);
return ide_stopped;
}
......@@ -1050,7 +1050,7 @@ static void idedisk_setup(struct ata_device *drive)
drive->bios_cyl, drive->bios_head, drive->bios_sect);
#ifdef CONFIG_BLK_DEV_IDEDMA
if (drive->using_dma)
(void) drive->channel->dmaproc(ide_dma_verbose, drive);
(void) drive->channel->udma(ide_dma_verbose, drive, NULL);
#endif
printk("\n");
......
drivers/ide/ide-dma.c
View file @ 4a58bd1a
......@@ -5,7 +5,7 @@
* May be copied or modified under the terms of the GNU General Public License
*
* Special Thanks to Mark for his Six years of work.
*
*
* This module provides support for the bus-master IDE DMA functions
* of various PCI chipsets, including the Intel PIIX (i82371FB for
* the 430 FX chipset), the PIIX3 (i82371SB for the 430 HX/VX and
......@@ -194,17 +194,14 @@ const char *bad_dma_drives[] = {"WDC AC11000H",
/*
* dma_intr() is the handler for disk read/write DMA interrupts
*/
ide_startstop_t ide_dma_intr (ide_drive_t *drive)
ide_startstop_t ide_dma_intr(struct ata_device *drive, struct request *rq)
{
byte stat, dma_stat;
dma_stat = drive->channel->dmaproc(ide_dma_end, drive);
stat = GET_STAT(); /* get drive status */
if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
dma_stat = drive->channel->udma(ide_dma_end, drive, rq);
if (OK_STAT(stat = GET_STAT(),DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
if (!dma_stat) {
struct request *rq = HWGROUP(drive)->rq;
__ide_end_request(drive, 1, rq->nr_sectors);
__ide_end_request(drive, rq, 1, rq->nr_sectors);
return ide_stopped;
}
printk("%s: dma_intr: bad DMA status (dma_stat=%x)\n",
......@@ -461,38 +458,39 @@ static int config_drive_for_dma (ide_drive_t *drive)
if (id && (id->capability & 1) && hwif->autodma && config_allows_dma) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive))
return hwif->dmaproc(ide_dma_off, drive);
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL))
return hwif->udma(ide_dma_off, drive, NULL);
/* Enable DMA on any drive that has UltraDMA (mode 6/7/?) enabled */
if ((id->field_valid & 4) && (eighty_ninty_three(drive)))
if ((id->dma_ultra & (id->dma_ultra >> 14) & 2))
return hwif->dmaproc(ide_dma_on, drive);
return hwif->udma(ide_dma_on, drive, NULL);
/* Enable DMA on any drive that has UltraDMA (mode 3/4/5) enabled */
if ((id->field_valid & 4) && (eighty_ninty_three(drive)))
if ((id->dma_ultra & (id->dma_ultra >> 11) & 7))
return hwif->dmaproc(ide_dma_on, drive);
return hwif->udma(ide_dma_on, drive, NULL);
/* Enable DMA on any drive that has UltraDMA (mode 0/1/2) enabled */
if (id->field_valid & 4) /* UltraDMA */
if ((id->dma_ultra & (id->dma_ultra >> 8) & 7))
return hwif->dmaproc(ide_dma_on, drive);
return hwif->udma(ide_dma_on, drive, NULL);
/* Enable DMA on any drive that has mode2 DMA (multi or single) enabled */
if (id->field_valid & 2) /* regular DMA */
if ((id->dma_mword & 0x404) == 0x404 || (id->dma_1word & 0x404) == 0x404)
return hwif->dmaproc(ide_dma_on, drive);
return hwif->udma(ide_dma_on, drive, NULL);
/* Consult the list of known "good" drives */
if (ide_dmaproc(ide_dma_good_drive, drive))
return hwif->dmaproc(ide_dma_on, drive);
if (ide_dmaproc(ide_dma_good_drive, drive, NULL))
return hwif->udma(ide_dma_on, drive, NULL);
}
return hwif->dmaproc(ide_dma_off_quietly, drive);
return hwif->udma(ide_dma_off_quietly, drive, NULL);
}
/*
* 1 dma-ing, 2 error, 4 intr
*/
static int dma_timer_expiry(ide_drive_t *drive)
static int dma_timer_expiry(struct ata_device *drive, struct request *__rq)
{
byte dma_stat = inb(drive->channel->dma_base+2);
/* FIXME: What's that? */
u8 dma_stat = inb(drive->channel->dma_base+2);
#ifdef DEBUG
printk("%s: dma_timer_expiry: dma status == 0x%02x\n", drive->name, dma_stat);
......@@ -503,7 +501,7 @@ static int dma_timer_expiry(ide_drive_t *drive)
#endif
if (dma_stat & 2) { /* ERROR */
byte stat = GET_STAT();
u8 stat = GET_STAT();
return ide_error(drive, "dma_timer_expiry", stat);
}
if (dma_stat & 1) /* DMAing */
......@@ -526,7 +524,7 @@ static void ide_toggle_bounce(ide_drive_t *drive, int on)
}
/*
* ide_dmaproc() initiates/aborts DMA read/write operations on a drive.
* This initiates/aborts DMA read/write operations on a drive.
*
* The caller is assumed to have selected the drive and programmed the drive's
* sector address using CHS or LBA. All that remains is to prepare for DMA
......@@ -541,7 +539,7 @@ static void ide_toggle_bounce(ide_drive_t *drive, int on)
* the caller should revert to PIO for the current request.
* May also be invoked from trm290.c
*/
int ide_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
int ide_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
struct ata_channel *hwif = drive->channel;
unsigned long dma_base = hwif->dma_base;
......@@ -579,11 +577,9 @@ int ide_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
if (drive->type != ATA_DISK)
return 0;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &ide_dma_intr, WAIT_CMD, dma_timer_expiry); /* issue cmd to drive */
if ((HWGROUP(drive)->rq->flags & REQ_DRIVE_ACB) &&
(drive->addressing == 1)) {
struct ata_taskfile *args = HWGROUP(drive)->rq->special;
ide_set_handler(drive, ide_dma_intr, WAIT_CMD, dma_timer_expiry); /* issue cmd to drive */
if ((rq->flags & REQ_DRIVE_ACB) && (drive->addressing == 1)) {
struct ata_taskfile *args = rq->special;
OUT_BYTE(args->taskfile.command, IDE_COMMAND_REG);
} else if (drive->addressing) {
......@@ -591,7 +587,7 @@ int ide_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
} else {
OUT_BYTE(reading ? WIN_READDMA : WIN_WRITEDMA, IDE_COMMAND_REG);
}
return drive->channel->dmaproc(ide_dma_begin, drive);
return drive->channel->udma(ide_dma_begin, drive, NULL);
case ide_dma_begin:
/* Note that this is done *after* the cmd has
* been issued to the drive, as per the BM-IDE spec.
......@@ -685,7 +681,7 @@ void ide_setup_dma(struct ata_channel *hwif, unsigned long dma_base, unsigned in
goto dma_alloc_failure;
}
hwif->dmaproc = &ide_dmaproc;
hwif->udma = ide_dmaproc;
if (hwif->chipset != ide_trm290) {
byte dma_stat = inb(dma_base+2);
......
drivers/ide/ide-floppy.c
View file @ 4a58bd1a
......@@ -152,10 +152,9 @@ typedef struct idefloppy_packet_command_s {
int buffer_size; /* Size of our data buffer */
char *b_data; /* Pointer which runs on the buffers */
int b_count; /* Missing/Available data on the current buffer */
struct request *rq; /* The corresponding request */
byte *buffer; /* Data buffer */
byte *current_position; /* Pointer into the above buffer */
void (*callback) (ide_drive_t *); /* Called when this packet command is completed */
void (*callback) (struct ata_device *, struct request *); /* Called when this packet command is completed */
byte pc_buffer[IDEFLOPPY_PC_BUFFER_SIZE]; /* Temporary buffer */
unsigned long flags; /* Status/Action bit flags: long for set_bit */
} idefloppy_pc_t;
......@@ -669,10 +668,9 @@ static void idefloppy_write_zeros (ide_drive_t *drive, unsigned int bcount)
* For read/write requests, we will call ide_end_request to pass to the
* next buffer.
*/
static int idefloppy_end_request(ide_drive_t *drive, int uptodate)
static int idefloppy_end_request(struct ata_device *drive, struct request *rq, int uptodate)
{
idefloppy_floppy_t *floppy = drive->driver_data;
struct request *rq = HWGROUP(drive)->rq;
int error;
#if IDEFLOPPY_DEBUG_LOG
......@@ -690,7 +688,7 @@ static int idefloppy_end_request(ide_drive_t *drive, int uptodate)
if (!rq)
return 0;
if (!(rq->flags & IDEFLOPPY_RQ)) {
ide_end_request(drive, uptodate);
ide_end_request(drive, rq, uptodate);
return 0;
}
rq->errors = error;
......@@ -699,9 +697,9 @@ static int idefloppy_end_request(ide_drive_t *drive, int uptodate)
return 0;
}
static void idefloppy_input_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, unsigned int bcount)
static void idefloppy_input_buffers(struct ata_device *drive, struct request *rq,
idefloppy_pc_t *pc, unsigned int bcount)
{
struct request *rq = pc->rq;
struct bio *bio = rq->bio;
int count;
......@@ -709,12 +707,12 @@ static void idefloppy_input_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, uns
if (pc->b_count == bio->bi_size) {
rq->sector += rq->current_nr_sectors;
rq->nr_sectors -= rq->current_nr_sectors;
idefloppy_end_request(drive, 1);
idefloppy_end_request(drive, rq, 1);
if ((bio = rq->bio) != NULL)
pc->b_count = 0;
}
if (bio == NULL) {
printk (KERN_ERR "%s: bio == NULL in idefloppy_input_buffers, bcount == %d\n", drive->name, bcount);
printk (KERN_ERR "%s: bio == NULL in %s, bcount == %d\n", drive->name, __FUNCTION__, bcount);
idefloppy_discard_data (drive, bcount);
return;
}
......@@ -724,9 +722,9 @@ static void idefloppy_input_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, uns
}
}
static void idefloppy_output_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, unsigned int bcount)
static void idefloppy_output_buffers(struct ata_device *drive, struct request *rq,
idefloppy_pc_t *pc, unsigned int bcount)
{
struct request *rq = pc->rq;
struct bio *bio = rq->bio;
int count;
......@@ -734,7 +732,7 @@ static void idefloppy_output_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, un
if (!pc->b_count) {
rq->sector += rq->current_nr_sectors;
rq->nr_sectors -= rq->current_nr_sectors;
idefloppy_end_request(drive, 1);
idefloppy_end_request(drive, rq, 1);
if ((bio = rq->bio) != NULL) {
pc->b_data = bio_data(bio);
pc->b_count = bio->bi_size;
......@@ -752,13 +750,13 @@ static void idefloppy_output_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, un
}
#ifdef CONFIG_BLK_DEV_IDEDMA
static void idefloppy_update_buffers (ide_drive_t *drive, idefloppy_pc_t *pc)
static void idefloppy_update_buffers (struct ata_device *drive, struct request *rq,
idefloppy_pc_t *pc)
{
struct request *rq = pc->rq;
struct bio *bio = rq->bio;
while ((bio = rq->bio) != NULL)
idefloppy_end_request(drive, 1);
idefloppy_end_request(drive, rq, 1);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -812,7 +810,7 @@ static void idefloppy_analyze_error (ide_drive_t *drive,idefloppy_request_sense_
#endif /* IDEFLOPPY_DEBUG_LOG */
}
static void idefloppy_request_sense_callback (ide_drive_t *drive)
static void idefloppy_request_sense_callback(struct ata_device *drive, struct request *rq)
{
idefloppy_floppy_t *floppy = drive->driver_data;
......@@ -821,17 +819,17 @@ static void idefloppy_request_sense_callback (ide_drive_t *drive)
#endif /* IDEFLOPPY_DEBUG_LOG */
if (!floppy->pc->error) {
idefloppy_analyze_error (drive,(idefloppy_request_sense_result_t *) floppy->pc->buffer);
idefloppy_end_request(drive, 1);
idefloppy_end_request(drive, rq, 1);
} else {
printk (KERN_ERR "Error in REQUEST SENSE itself - Aborting request!\n");
idefloppy_end_request(drive, 0);
idefloppy_end_request(drive, rq, 0);
}
}
/*
* General packet command callback function.
*/
static void idefloppy_pc_callback (ide_drive_t *drive)
static void idefloppy_pc_callback(struct ata_device *drive, struct request *rq)
{
idefloppy_floppy_t *floppy = drive->driver_data;
......@@ -839,7 +837,7 @@ static void idefloppy_pc_callback (ide_drive_t *drive)
printk (KERN_INFO "ide-floppy: Reached idefloppy_pc_callback\n");
#endif /* IDEFLOPPY_DEBUG_LOG */
idefloppy_end_request(drive, floppy->pc->error ? 0:1);
idefloppy_end_request(drive, rq, floppy->pc->error ? 0:1);
}
/*
......@@ -854,7 +852,7 @@ static void idefloppy_init_pc (idefloppy_pc_t *pc)
pc->buffer = pc->pc_buffer;
pc->buffer_size = IDEFLOPPY_PC_BUFFER_SIZE;
pc->b_data = NULL;
pc->callback = &idefloppy_pc_callback;
pc->callback = idefloppy_pc_callback;
}
static void idefloppy_create_request_sense_cmd (idefloppy_pc_t *pc)
......@@ -888,33 +886,32 @@ static void idefloppy_retry_pc (ide_drive_t *drive)
* idefloppy_pc_intr is the usual interrupt handler which will be called
* during a packet command.
*/
static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
static ide_startstop_t idefloppy_pc_intr(struct ata_device *drive, struct request *rq)
{
idefloppy_floppy_t *floppy = drive->driver_data;
idefloppy_status_reg_t status;
idefloppy_bcount_reg_t bcount;
idefloppy_ireason_reg_t ireason;
idefloppy_pc_t *pc=floppy->pc;
struct request *rq = pc->rq;
unsigned int temp;
#if IDEFLOPPY_DEBUG_LOG
printk (KERN_INFO "ide-floppy: Reached idefloppy_pc_intr interrupt handler\n");
#endif /* IDEFLOPPY_DEBUG_LOG */
#endif
#ifdef CONFIG_BLK_DEV_IDEDMA
if (test_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
if (drive->channel->dmaproc(ide_dma_end, drive)) {
if (drive->channel->udma(ide_dma_end, drive, NULL)) {
set_bit (PC_DMA_ERROR, &pc->flags);
} else {
pc->actually_transferred=pc->request_transfer;
idefloppy_update_buffers (drive, pc);
idefloppy_update_buffers(drive, rq, pc);
}
#if IDEFLOPPY_DEBUG_LOG
# if IDEFLOPPY_DEBUG_LOG
printk (KERN_INFO "ide-floppy: DMA finished\n");
#endif /* IDEFLOPPY_DEBUG_LOG */
# endif
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
#endif
status.all = GET_STAT(); /* Clear the interrupt */
......@@ -941,13 +938,13 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
pc->error = 0;
if (floppy->failed_pc == pc)
floppy->failed_pc=NULL;
pc->callback(drive); /* Command finished - Call the callback function */
pc->callback(drive, rq); /* Command finished - Call the callback function */
return ide_stopped;
}
#ifdef CONFIG_BLK_DEV_IDEDMA
if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
printk (KERN_ERR "ide-floppy: The floppy wants to issue more interrupts in DMA mode\n");
drive->channel->dmaproc(ide_dma_off, drive);
drive->channel->udma(ide_dma_off, drive, NULL);
return ide_stopped;
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -970,8 +967,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
if (temp > pc->buffer_size) {
printk (KERN_ERR "ide-floppy: The floppy wants to send us more data than expected - discarding data\n");
idefloppy_discard_data (drive,bcount.all);
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive,&idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD, NULL);
ide_set_handler(drive, idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD, NULL);
return ide_started;
}
#if IDEFLOPPY_DEBUG_LOG
......@@ -983,18 +979,17 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
if (pc->buffer != NULL)
atapi_write(drive,pc->current_position,bcount.all); /* Write the current buffer */
else
idefloppy_output_buffers (drive, pc, bcount.all);
idefloppy_output_buffers(drive, rq, pc, bcount.all);
} else {
if (pc->buffer != NULL)
atapi_read(drive,pc->current_position,bcount.all); /* Read the current buffer */
else
idefloppy_input_buffers (drive, pc, bcount.all);
idefloppy_input_buffers (drive, rq, pc, bcount.all);
}
pc->actually_transferred+=bcount.all; /* Update the current position */
pc->current_position+=bcount.all;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive,&idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD, NULL); /* And set the interrupt handler again */
ide_set_handler(drive, idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD, NULL); /* And set the interrupt handler again */
return ide_started;
}
......@@ -1004,7 +999,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t *drive)
* It fails at high speeds on the Iomega ZIP drive, so there's a slower version
* for that drive below. The algorithm is chosen based on drive type
*/
static ide_startstop_t idefloppy_transfer_pc (ide_drive_t *drive)
static ide_startstop_t idefloppy_transfer_pc(struct ata_device *drive, struct request *rq)
{
ide_startstop_t startstop;
idefloppy_floppy_t *floppy = drive->driver_data;
......@@ -1020,8 +1015,7 @@ static ide_startstop_t idefloppy_transfer_pc (ide_drive_t *drive)
return ide_stopped;
}
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, &idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL); /* Set the interrupt routine */
ide_set_handler (drive, idefloppy_pc_intr, IDEFLOPPY_WAIT_CMD, NULL); /* Set the interrupt routine */
atapi_write(drive, floppy->pc->c, 12); /* Send the actual packet */
return ide_started;
......@@ -1040,7 +1034,7 @@ static ide_startstop_t idefloppy_transfer_pc (ide_drive_t *drive)
* packet, we schedule the packet transfer to occur about 2-3 ticks
* later in transfer_pc2.
*/
static int idefloppy_transfer_pc2 (ide_drive_t *drive)
static int idefloppy_transfer_pc2(struct ata_device *drive, struct request *__rq)
{
idefloppy_floppy_t *floppy = drive->driver_data;
......@@ -1048,7 +1042,7 @@ static int idefloppy_transfer_pc2 (ide_drive_t *drive)
return IDEFLOPPY_WAIT_CMD; /* Timeout for the packet command */
}
static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t *drive)
static ide_startstop_t idefloppy_transfer_pc1(struct ata_device *drive, struct request *__rq)
{
idefloppy_floppy_t *floppy = drive->driver_data;
ide_startstop_t startstop;
......@@ -1070,11 +1064,10 @@ static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t *drive)
* 25msec is too short, 40 and 50msec work well. idefloppy_pc_intr will
* not be actually used until after the packet is moved in about 50 msec.
*/
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive,
&idefloppy_pc_intr, /* service routine for packet command */
ide_set_handler(drive,
idefloppy_pc_intr, /* service routine for packet command */
floppy->ticks, /* wait this long before "failing" */
&idefloppy_transfer_pc2); /* fail == transfer_pc2 */
idefloppy_transfer_pc2); /* fail == transfer_pc2 */
return ide_started;
}
......@@ -1082,12 +1075,12 @@ static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t *drive)
/*
* Issue a packet command
*/
static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t *pc)
static ide_startstop_t idefloppy_issue_pc(struct ata_device *drive, struct request *rq, idefloppy_pc_t *pc)
{
idefloppy_floppy_t *floppy = drive->driver_data;
idefloppy_bcount_reg_t bcount;
int dma_ok = 0;
ide_handler_t *pkt_xfer_routine;
ata_handler_t *pkt_xfer_routine;
#if IDEFLOPPY_DEBUG_BUGS
if (floppy->pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD && pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD) {
......@@ -1113,7 +1106,7 @@ static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t *p
pc->error = IDEFLOPPY_ERROR_GENERAL; /* Giving up */
}
floppy->failed_pc=NULL;
pc->callback(drive);
pc->callback(drive, rq);
return ide_stopped;
}
#if IDEFLOPPY_DEBUG_LOG
......@@ -1127,10 +1120,10 @@ static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t *p
#ifdef CONFIG_BLK_DEV_IDEDMA
if (test_and_clear_bit (PC_DMA_ERROR, &pc->flags)) {
(void) drive->channel->dmaproc(ide_dma_off, drive);
(void) drive->channel->udma(ide_dma_off, drive, NULL);
}
if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
dma_ok=!drive->channel->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
dma_ok=!drive->channel->udma(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive, rq);
#endif /* CONFIG_BLK_DEV_IDEDMA */
if (IDE_CONTROL_REG)
......@@ -1143,7 +1136,7 @@ static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t *p
#ifdef CONFIG_BLK_DEV_IDEDMA
if (dma_ok) { /* Begin DMA, if necessary */
set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
(void) drive->channel->dmaproc(ide_dma_begin, drive);
(void) drive->channel->udma(ide_dma_begin, drive, NULL);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -1155,23 +1148,22 @@ static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t *p
}
if (test_bit (IDEFLOPPY_DRQ_INTERRUPT, &floppy->flags)) {
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, pkt_xfer_routine, IDEFLOPPY_WAIT_CMD, NULL);
ide_set_handler(drive, pkt_xfer_routine, IDEFLOPPY_WAIT_CMD, NULL);
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* Issue the packet command */
return ide_started;
} else {
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG);
return (*pkt_xfer_routine) (drive);
return pkt_xfer_routine(drive, rq);
}
}
static void idefloppy_rw_callback (ide_drive_t *drive)
static void idefloppy_rw_callback(struct ata_device *drive, struct request *rq)
{
#if IDEFLOPPY_DEBUG_LOG
printk (KERN_INFO "ide-floppy: Reached idefloppy_rw_callback\n");
#endif /* IDEFLOPPY_DEBUG_LOG */
idefloppy_end_request(drive, 1);
idefloppy_end_request(drive, rq, 1);
return;
}
......@@ -1266,7 +1258,7 @@ static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy, idefloppy_pc_t *
2 * test_bit (IDEFLOPPY_USE_READ12, &floppy->flags), block, blocks);
#endif /* IDEFLOPPY_DEBUG_LOG */
idefloppy_init_pc (pc);
idefloppy_init_pc(pc);
if (test_bit (IDEFLOPPY_USE_READ12, &floppy->flags)) {
pc->c[0] = cmd == READ ? IDEFLOPPY_READ12_CMD : IDEFLOPPY_WRITE12_CMD;
put_unaligned (htonl (blocks), (unsigned int *) &pc->c[6]);
......@@ -1275,8 +1267,7 @@ static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy, idefloppy_pc_t *
put_unaligned (htons (blocks), (unsigned short *) &pc->c[7]);
}
put_unaligned (htonl (block), (unsigned int *) &pc->c[2]);
pc->callback = &idefloppy_rw_callback;
pc->rq = rq;
pc->callback = idefloppy_rw_callback;
pc->b_data = rq->buffer;
pc->b_count = cmd == READ ? 0 : rq->bio->bi_size;
if (rq->flags & REQ_RW)
......@@ -1305,13 +1296,13 @@ static ide_startstop_t idefloppy_do_request(struct ata_device *drive, struct req
drive->name, floppy->failed_pc->c[0], floppy->sense_key, floppy->asc, floppy->ascq);
else
printk (KERN_ERR "ide-floppy: %s: I/O error\n", drive->name);
idefloppy_end_request(drive, 0);
idefloppy_end_request(drive, rq, 0);
return ide_stopped;
}
if (rq->flags & REQ_CMD) {
if (rq->sector % floppy->bs_factor || rq->nr_sectors % floppy->bs_factor) {
printk ("%s: unsupported r/w request size\n", drive->name);
idefloppy_end_request(drive, 0);
idefloppy_end_request(drive, rq, 0);
return ide_stopped;
}
pc = idefloppy_next_pc_storage(drive);
......@@ -1320,11 +1311,11 @@ static ide_startstop_t idefloppy_do_request(struct ata_device *drive, struct req
pc = (idefloppy_pc_t *) rq->buffer;
} else {
blk_dump_rq_flags(rq, "ide-floppy: unsupported command in queue");
idefloppy_end_request(drive, 0);
idefloppy_end_request(drive, rq, 0);
return ide_stopped;
}
pc->rq = rq;
return idefloppy_issue_pc (drive, pc);
return idefloppy_issue_pc(drive, rq, pc);
}
/*
......
drivers/ide/ide-pmac.c
View file @ 4a58bd1a
......@@ -1384,8 +1384,7 @@ int pmac_ide_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
drive->waiting_for_dma = 1;
if (drive->type != ATA_DISK)
return 0;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &ide_dma_intr, WAIT_CMD, NULL);
ide_set_handler(drive, ide_dma_intr, WAIT_CMD, NULL);
if ((HWGROUP(drive)->rq->flags & REQ_DRIVE_ACB) &&
(drive->addressing == 1)) {
struct ata_taskfile *args = HWGROUP(drive)->rq->special;
......
drivers/ide/ide-tape.c
View file @ 4a58bd1a
......@@ -726,7 +726,8 @@ typedef struct idetape_packet_command_s {
int b_count;
byte *buffer; /* Data buffer */
byte *current_position; /* Pointer into the above buffer */
ide_startstop_t (*callback) (ide_drive_t *); /* Called when this packet command is completed */
/* Called when this packet command is completed */
ide_startstop_t (*callback) (struct ata_device *, struct request *);
byte pc_buffer[IDETAPE_PC_BUFFER_SIZE]; /* Temporary buffer */
unsigned long flags; /* Status/Action bit flags: long for set_bit */
} idetape_pc_t;
......@@ -1835,9 +1836,8 @@ static void idetape_remove_stage_head (ide_drive_t *drive)
* idetape_end_request is used to finish servicing a request, and to
* insert a pending pipeline request into the main device queue.
*/
static int idetape_end_request(ide_drive_t *drive, int uptodate)
static int idetape_end_request(struct ata_device *drive, struct request *rq, int uptodate)
{
struct request *rq = HWGROUP(drive)->rq;
idetape_tape_t *tape = drive->driver_data;
unsigned long flags;
int error;
......@@ -1935,7 +1935,7 @@ static int idetape_end_request(ide_drive_t *drive, int uptodate)
return 0;
}
static ide_startstop_t idetape_request_sense_callback (ide_drive_t *drive)
static ide_startstop_t idetape_request_sense_callback(struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
......@@ -1945,10 +1945,10 @@ static ide_startstop_t idetape_request_sense_callback (ide_drive_t *drive)
#endif /* IDETAPE_DEBUG_LOG */
if (!tape->pc->error) {
idetape_analyze_error (drive, (idetape_request_sense_result_t *) tape->pc->buffer);
idetape_end_request(drive, 1);
idetape_end_request(drive, rq, 1);
} else {
printk (KERN_ERR "ide-tape: Error in REQUEST SENSE itself - Aborting request!\n");
idetape_end_request(drive, 0);
idetape_end_request(drive, rq, 0);
}
return ide_stopped;
}
......@@ -2015,7 +2015,7 @@ static ide_startstop_t idetape_retry_pc (ide_drive_t *drive)
* ide.c will be able to service requests from another device on
* the same interface while we are polling for DSC.
*/
static void idetape_postpone_request (ide_drive_t *drive)
static void idetape_postpone_request(struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
......@@ -2023,7 +2023,7 @@ static void idetape_postpone_request (ide_drive_t *drive)
if (tape->debug_level >= 4)
printk(KERN_INFO "ide-tape: idetape_postpone_request\n");
#endif
tape->postponed_rq = HWGROUP(drive)->rq;
tape->postponed_rq = rq;
ide_stall_queue(drive, tape->dsc_polling_frequency);
}
......@@ -2035,7 +2035,7 @@ static void idetape_postpone_request (ide_drive_t *drive)
* algorithm described before idetape_issue_packet_command.
*
*/
static ide_startstop_t idetape_pc_intr (ide_drive_t *drive)
static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
idetape_status_reg_t status;
......@@ -2058,7 +2058,7 @@ static ide_startstop_t idetape_pc_intr (ide_drive_t *drive)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (test_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
if (drive->channel->dmaproc(ide_dma_end, drive)) {
if (drive->channel->udma(ide_dma_end, drive, NULL)) {
/*
* A DMA error is sometimes expected. For example,
* if the tape is crossing a filemark during a
......@@ -2121,18 +2121,18 @@ static ide_startstop_t idetape_pc_intr (ide_drive_t *drive)
tape->dsc_polling_start = jiffies;
tape->dsc_polling_frequency = IDETAPE_DSC_MA_FAST;
tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT;
idetape_postpone_request (drive); /* Allow ide.c to handle other requests */
idetape_postpone_request(drive, rq); /* Allow ide.c to handle other requests */
return ide_stopped;
}
if (tape->failed_pc == pc)
tape->failed_pc = NULL;
return pc->callback(drive); /* Command finished - Call the callback function */
return pc->callback(drive, rq); /* Command finished - Call the callback function */
}
#ifdef CONFIG_BLK_DEV_IDEDMA
if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
printk (KERN_ERR "ide-tape: The tape wants to issue more interrupts in DMA mode\n");
printk (KERN_ERR "ide-tape: DMA disabled, reverting to PIO\n");
drive->channel->dmaproc(ide_dma_off, drive);
drive->channel->udma(ide_dma_off, drive, NULL);
return ide_stopped;
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -2155,8 +2155,7 @@ static ide_startstop_t idetape_pc_intr (ide_drive_t *drive)
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);
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);
ide_set_handler(drive, idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);
return ide_started;
}
#if IDETAPE_DEBUG_LOG
......@@ -2182,8 +2181,7 @@ static ide_startstop_t idetape_pc_intr (ide_drive_t *drive)
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
BUG_ON(HWGROUP(drive)->handler);
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;
}
......@@ -2229,7 +2227,7 @@ static ide_startstop_t idetape_pc_intr (ide_drive_t *drive)
* we will handle the next request.
*
*/
static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)
static ide_startstop_t idetape_transfer_pc(struct ata_device *drive, struct request *__rq)
{
idetape_tape_t *tape = drive->driver_data;
idetape_pc_t *pc = tape->pc;
......@@ -2257,13 +2255,12 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)
return ide_stopped;
}
tape->cmd_start_time = jiffies;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL); /* Set the interrupt routine */
ide_set_handler(drive, idetape_pc_intr, IDETAPE_WAIT_CMD, NULL); /* Set the interrupt routine */
atapi_write(drive,pc->c,12); /* Send the actual packet */
return ide_started;
}
static ide_startstop_t idetape_issue_packet_command (ide_drive_t *drive, idetape_pc_t *pc)
static ide_startstop_t idetape_issue_packet_command(struct ata_device *drive, struct request *rq, idetape_pc_t *pc)
{
idetape_tape_t *tape = drive->driver_data;
idetape_bcount_reg_t bcount;
......@@ -2297,7 +2294,7 @@ static ide_startstop_t idetape_issue_packet_command (ide_drive_t *drive, idetape
pc->error = IDETAPE_ERROR_GENERAL; /* Giving up */
}
tape->failed_pc = NULL;
return pc->callback(drive);
return pc->callback(drive, rq);
}
#if IDETAPE_DEBUG_LOG
if (tape->debug_level >= 2)
......@@ -2312,10 +2309,10 @@ static ide_startstop_t idetape_issue_packet_command (ide_drive_t *drive, idetape
#ifdef CONFIG_BLK_DEV_IDEDMA
if (test_and_clear_bit (PC_DMA_ERROR, &pc->flags)) {
printk (KERN_WARNING "ide-tape: DMA disabled, reverting to PIO\n");
(void) drive->channel->dmaproc(ide_dma_off, drive);
(void) drive->channel->udma(ide_dma_off, drive, NULL);
}
if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
dma_ok = !drive->channel->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
dma_ok = !drive->channel->udma(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive, rq);
#endif /* CONFIG_BLK_DEV_IDEDMA */
if (IDE_CONTROL_REG)
......@@ -2327,24 +2324,23 @@ static ide_startstop_t idetape_issue_packet_command (ide_drive_t *drive, idetape
#ifdef CONFIG_BLK_DEV_IDEDMA
if (dma_ok) { /* Begin DMA, if necessary */
set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
(void) drive->channel->dmaproc(ide_dma_begin, drive);
(void) drive->channel->udma(ide_dma_begin, drive, NULL);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
if (test_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags)) {
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &idetape_transfer_pc, IDETAPE_WAIT_CMD, NULL);
ide_set_handler(drive, idetape_transfer_pc, IDETAPE_WAIT_CMD, NULL);
OUT_BYTE(WIN_PACKETCMD, IDE_COMMAND_REG);
return ide_started;
} else {
OUT_BYTE(WIN_PACKETCMD, IDE_COMMAND_REG);
return idetape_transfer_pc(drive);
return idetape_transfer_pc(drive, rq);
}
}
/*
* General packet command callback function.
*/
static ide_startstop_t idetape_pc_callback (ide_drive_t *drive)
static ide_startstop_t idetape_pc_callback(struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
......@@ -2353,7 +2349,7 @@ static ide_startstop_t idetape_pc_callback (ide_drive_t *drive)
printk (KERN_INFO "ide-tape: Reached idetape_pc_callback\n");
#endif /* IDETAPE_DEBUG_LOG */
idetape_end_request(drive, tape->pc->error ? 0 : 1);
idetape_end_request(drive, rq, tape->pc->error ? 0 : 1);
return ide_stopped;
}
......@@ -2375,10 +2371,10 @@ static void idetape_create_mode_sense_cmd (idetape_pc_t *pc, byte page_code)
pc->request_transfer = 24;
else
pc->request_transfer = 50;
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
static ide_startstop_t idetape_onstream_buffer_fill_callback (ide_drive_t *drive)
static ide_startstop_t idetape_onstream_buffer_fill_callback (struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
......@@ -2402,7 +2398,7 @@ static ide_startstop_t idetape_onstream_buffer_fill_callback (ide_drive_t *drive
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(drive, tape->pc->error ? 0 : 1);
idetape_end_request(drive, rq, tape->pc->error ? 0 : 1);
return ide_stopped;
}
......@@ -2466,7 +2462,7 @@ static void calculate_speeds(ide_drive_t *drive)
tape->max_insert_speed = max(tape->max_insert_speed, 500);
}
static ide_startstop_t idetape_media_access_finished (ide_drive_t *drive)
static ide_startstop_t idetape_media_access_finished(struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
idetape_pc_t *pc = tape->pc;
......@@ -2487,13 +2483,12 @@ 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->callback(drive, rq);
}
static ide_startstop_t idetape_rw_callback (ide_drive_t *drive)
static ide_startstop_t idetape_rw_callback(struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
struct request *rq = HWGROUP(drive)->rq;
int blocks = tape->pc->actually_transferred / tape->tape_block_size;
tape->avg_size += blocks * tape->tape_block_size;
......@@ -2522,9 +2517,9 @@ static ide_startstop_t idetape_rw_callback (ide_drive_t *drive)
rq->current_nr_sectors -= blocks;
if (!tape->pc->error)
idetape_end_request(drive, 1);
idetape_end_request(drive, rq, 1);
else
idetape_end_request(drive, tape->pc->error);
idetape_end_request(drive, rq, tape->pc->error);
return ide_stopped;
}
......@@ -2536,7 +2531,7 @@ static void idetape_create_read_cmd (idetape_tape_t *tape, idetape_pc_t *pc, uns
pc->c[0] = IDETAPE_READ_CMD;
put_unaligned (htonl (length), (unsigned int *) &pc->c[1]);
pc->c[1] = 1;
pc->callback = &idetape_rw_callback;
pc->callback = idetape_rw_callback;
pc->bio = bio;
bv->bv_len = 0;
pc->buffer = NULL;
......@@ -2569,7 +2564,7 @@ static void idetape_create_read_buffer_cmd(idetape_tape_t *tape, idetape_pc_t *p
pc->c[1] = IDETAPE_RETRIEVE_FAULTY_BLOCK;
pc->c[7] = size >> 8;
pc->c[8] = size & 0xff;
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
pc->bio = bio;
atomic_set(&bio->bi_cnt, 0);
pc->buffer = NULL;
......@@ -2588,7 +2583,7 @@ static void idetape_create_write_cmd (idetape_tape_t *tape, idetape_pc_t *pc, un
pc->c[0] = IDETAPE_WRITE_CMD;
put_unaligned (htonl (length), (unsigned int *) &pc->c[1]);
pc->c[1] = 1;
pc->callback = &idetape_rw_callback;
pc->callback = idetape_rw_callback;
set_bit (PC_WRITING, &pc->flags);
if (tape->onstream) {
while (p) {
......@@ -2635,7 +2630,7 @@ static ide_startstop_t idetape_do_request(struct ata_device *drive, struct reque
* We do not support buffer cache originated requests.
*/
printk (KERN_NOTICE "ide-tape: %s: Unsupported command in request queue (%ld)\n", drive->name, rq->flags);
ide_end_request(drive, 0); /* Let the common code handle it */
ide_end_request(drive, rq, 0); /* Let the common code handle it */
return ide_stopped;
}
......@@ -2643,13 +2638,13 @@ static ide_startstop_t idetape_do_request(struct ata_device *drive, struct reque
* Retry a failed packet command
*/
if (tape->failed_pc != NULL && tape->pc->c[0] == IDETAPE_REQUEST_SENSE_CMD) {
return idetape_issue_packet_command (drive, tape->failed_pc);
return idetape_issue_packet_command(drive, rq, tape->failed_pc);
}
#if IDETAPE_DEBUG_BUGS
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(drive, 0);
idetape_end_request(drive, rq, 0);
return ide_stopped;
}
#endif /* IDETAPE_DEBUG_BUGS */
......@@ -2726,14 +2721,14 @@ static ide_startstop_t idetape_do_request(struct ata_device *drive, struct reque
} else if ((signed long) (jiffies - tape->dsc_timeout) > 0) {
printk (KERN_ERR "ide-tape: %s: DSC timeout\n", tape->name);
if (rq->flags == IDETAPE_PC_RQ2) {
idetape_media_access_finished (drive);
idetape_media_access_finished(drive, rq);
return ide_stopped;
} else {
return ide_stopped;
}
} else if (jiffies - tape->dsc_polling_start > IDETAPE_DSC_MA_THRESHOLD)
tape->dsc_polling_frequency = IDETAPE_DSC_MA_SLOW;
idetape_postpone_request (drive);
idetape_postpone_request(drive, rq);
return ide_stopped;
}
switch (rq->flags) {
......@@ -2777,7 +2772,7 @@ static ide_startstop_t idetape_do_request(struct ata_device *drive, struct reque
break;
case IDETAPE_ABORTED_WRITE_RQ:
rq->flags = IDETAPE_WRITE_RQ;
idetape_end_request(drive, IDETAPE_ERROR_EOD);
idetape_end_request(drive, rq, IDETAPE_ERROR_EOD);
return ide_stopped;
case IDETAPE_ABORTED_READ_RQ:
#if IDETAPE_DEBUG_LOG
......@@ -2785,21 +2780,21 @@ static ide_startstop_t idetape_do_request(struct ata_device *drive, struct reque
printk(KERN_INFO "ide-tape: %s: detected aborted read rq\n", tape->name);
#endif
rq->flags = IDETAPE_READ_RQ;
idetape_end_request(drive, IDETAPE_ERROR_EOD);
idetape_end_request(drive, rq, IDETAPE_ERROR_EOD);
return ide_stopped;
case IDETAPE_PC_RQ1:
pc = (idetape_pc_t *) rq->buffer;
rq->flags = IDETAPE_PC_RQ2;
break;
case IDETAPE_PC_RQ2:
idetape_media_access_finished (drive);
idetape_media_access_finished(drive, rq);
return ide_stopped;
default:
printk (KERN_ERR "ide-tape: bug in IDETAPE_RQ_CMD macro\n");
idetape_end_request(drive, 0);
idetape_end_request(drive, rq, 0);
return ide_stopped;
}
return idetape_issue_packet_command (drive, pc);
return idetape_issue_packet_command(drive, rq, pc);
}
/*
......@@ -3102,7 +3097,7 @@ static void idetape_wait_for_request (ide_drive_t *drive, struct request *rq)
spin_lock_irq(&tape->spinlock);
}
static ide_startstop_t idetape_read_position_callback (ide_drive_t *drive)
static ide_startstop_t idetape_read_position_callback(struct ata_device *drive, struct request *rq)
{
idetape_tape_t *tape = drive->driver_data;
idetape_read_position_result_t *result;
......@@ -3123,7 +3118,7 @@ static ide_startstop_t idetape_read_position_callback (ide_drive_t *drive)
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(drive, 0);
idetape_end_request(drive, rq, 0);
} else {
#if IDETAPE_DEBUG_LOG
if (tape->debug_level >= 2)
......@@ -3134,10 +3129,10 @@ static ide_startstop_t idetape_read_position_callback (ide_drive_t *drive)
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(drive, 1);
idetape_end_request(drive, rq, 1);
}
} else {
idetape_end_request(drive, 0);
idetape_end_request(drive, rq, 0);
}
return ide_stopped;
}
......@@ -3160,14 +3155,14 @@ static void idetape_create_write_filemark_cmd (ide_drive_t *drive, idetape_pc_t
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;
pc->callback = idetape_pc_callback;
}
static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc)
{
idetape_init_pc(pc);
pc->c[0] = IDETAPE_TEST_UNIT_READY_CMD;
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
/*
......@@ -3213,7 +3208,7 @@ static void idetape_create_load_unload_cmd (ide_drive_t *drive, idetape_pc_t *pc
pc->c[4] = 4;
}
set_bit (PC_WAIT_FOR_DSC, &pc->flags);
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
static int idetape_wait_ready (ide_drive_t *drive, unsigned long long timeout)
......@@ -3275,7 +3270,7 @@ static void idetape_create_read_position_cmd (idetape_pc_t *pc)
idetape_init_pc (pc);
pc->c[0] = IDETAPE_READ_POSITION_CMD;
pc->request_transfer = 20;
pc->callback = &idetape_read_position_callback;
pc->callback = idetape_read_position_callback;
}
static int idetape_read_position (ide_drive_t *drive)
......@@ -3331,7 +3326,7 @@ static void idetape_create_locate_cmd (ide_drive_t *drive, idetape_pc_t *pc, uns
*/
pc->c[9] = skip << 7;
set_bit (PC_WAIT_FOR_DSC, &pc->flags);
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
static int idetape_create_prevent_cmd (ide_drive_t *drive, idetape_pc_t *pc, int prevent)
......@@ -3344,7 +3339,7 @@ static int idetape_create_prevent_cmd (ide_drive_t *drive, idetape_pc_t *pc, int
idetape_init_pc(pc);
pc->c[0] = IDETAPE_PREVENT_CMD;
pc->c[4] = prevent;
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
return 1;
}
......@@ -3603,7 +3598,7 @@ static void idetape_create_inquiry_cmd (idetape_pc_t *pc)
idetape_init_pc(pc);
pc->c[0] = IDETAPE_INQUIRY_CMD;
pc->c[4] = pc->request_transfer = 254;
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
static void idetape_create_rewind_cmd (ide_drive_t *drive, idetape_pc_t *pc)
......@@ -3615,7 +3610,7 @@ static void idetape_create_rewind_cmd (ide_drive_t *drive, idetape_pc_t *pc)
if (tape->onstream)
pc->c[1] = 1;
set_bit (PC_WAIT_FOR_DSC, &pc->flags);
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
static void idetape_create_mode_select_cmd (idetape_pc_t *pc, int length)
......@@ -3626,7 +3621,7 @@ static void idetape_create_mode_select_cmd (idetape_pc_t *pc, int length)
pc->c[1] = 0x10;
put_unaligned (htons(length), (unsigned short *) &pc->c[3]);
pc->request_transfer = 255;
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
static void idetape_create_erase_cmd (idetape_pc_t *pc)
......@@ -3635,7 +3630,7 @@ static void idetape_create_erase_cmd (idetape_pc_t *pc)
pc->c[0] = IDETAPE_ERASE_CMD;
pc->c[1] = 1;
set_bit (PC_WAIT_FOR_DSC, &pc->flags);
pc->callback = &idetape_pc_callback;
pc->callback = idetape_pc_callback;
}
static void idetape_create_space_cmd (idetape_pc_t *pc,int count,byte cmd)
......
drivers/ide/ide-taskfile.c
View file @ 4a58bd1a
......@@ -260,7 +260,7 @@ int drive_is_ready(ide_drive_t *drive)
{
byte stat = 0;
if (drive->waiting_for_dma)
return drive->channel->dmaproc(ide_dma_test_irq, drive);
return drive->channel->udma(ide_dma_test_irq, drive, NULL);
#if 0
/* need to guarantee 400ns since last command was issued */
udelay(1);
......@@ -294,7 +294,6 @@ void ata_poll_drive_ready(ide_drive_t *drive)
{
int i;
if (drive_is_ready(drive))
return;
......@@ -306,28 +305,22 @@ void ata_poll_drive_ready(ide_drive_t *drive)
}
}
static ide_startstop_t pre_task_mulout_intr(ide_drive_t *drive, struct request *rq)
static ide_startstop_t pre_task_mulout_intr(struct ata_device *drive, struct request *rq)
{
struct ata_taskfile *args = rq->special;
ide_startstop_t startstop;
/*
* assign private copy for multi-write
*/
memcpy(&HWGROUP(drive)->wrq, rq, sizeof(struct request));
if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ))
return startstop;
ata_poll_drive_ready(drive);
return args->handler(drive);
return args->handler(drive, rq);
}
static ide_startstop_t task_mulout_intr (ide_drive_t *drive)
static ide_startstop_t task_mulout_intr(struct ata_device *drive, struct request *rq)
{
byte stat = GET_STAT();
struct request *rq = &HWGROUP(drive)->wrq;
u8 stat = GET_STAT();
ide_hwgroup_t *hwgroup = HWGROUP(drive);
int mcount = drive->mult_count;
ide_startstop_t startstop;
......@@ -339,11 +332,11 @@ static ide_startstop_t task_mulout_intr (ide_drive_t *drive)
if (!rq->nr_sectors) {
if (stat & (ERR_STAT|DRQ_STAT)) {
startstop = ide_error(drive, "task_mulout_intr", stat);
memcpy(rq, HWGROUP(drive)->rq, sizeof(struct request));
return startstop;
}
__ide_end_request(drive, 1, rq->hard_nr_sectors);
__ide_end_request(drive, rq, 1, rq->hard_nr_sectors);
rq->bio = NULL;
return ide_stopped;
......@@ -352,7 +345,7 @@ static ide_startstop_t task_mulout_intr (ide_drive_t *drive)
if (!OK_STAT(stat, DATA_READY, BAD_R_STAT)) {
if (stat & (ERR_STAT | DRQ_STAT)) {
startstop = ide_error(drive, "task_mulout_intr", stat);
memcpy(rq, HWGROUP(drive)->rq, sizeof(struct request));
return startstop;
}
......@@ -465,9 +458,9 @@ ide_startstop_t ata_taskfile(ide_drive_t *drive,
} else {
/* for dma commands we down set the handler */
if (drive->using_dma &&
!(drive->channel->dmaproc(((args->taskfile.command == WIN_WRITEDMA)
!(drive->channel->udma(((args->taskfile.command == WIN_WRITEDMA)
|| (args->taskfile.command == WIN_WRITEDMA_EXT))
? ide_dma_write : ide_dma_read, drive)));
? ide_dma_write : ide_dma_read, drive, rq)));
}
return ide_started;
......@@ -476,11 +469,11 @@ ide_startstop_t ata_taskfile(ide_drive_t *drive,
/*
* This is invoked on completion of a WIN_SETMULT cmd.
*/
ide_startstop_t set_multmode_intr(struct ata_device *drive)
ide_startstop_t set_multmode_intr(struct ata_device *drive, struct request *__rq)
{
u8 stat;
if (OK_STAT(stat=GET_STAT(),READY_STAT,BAD_STAT)) {
if (OK_STAT(stat = GET_STAT(),READY_STAT,BAD_STAT)) {
drive->mult_count = drive->mult_req;
} else {
drive->mult_req = drive->mult_count = 0;
......@@ -493,9 +486,9 @@ ide_startstop_t set_multmode_intr(struct ata_device *drive)
/*
* This is invoked on completion of a WIN_SPECIFY cmd.
*/
ide_startstop_t set_geometry_intr (ide_drive_t *drive)
ide_startstop_t set_geometry_intr(struct ata_device *drive, struct request *__rq)
{
byte stat;
u8 stat;
if (OK_STAT(stat=GET_STAT(),READY_STAT,BAD_STAT))
return ide_stopped;
......@@ -503,18 +496,18 @@ ide_startstop_t set_geometry_intr (ide_drive_t *drive)
if (stat & (ERR_STAT|DRQ_STAT))
return ide_error(drive, "set_geometry_intr", stat);
ide_set_handler(drive, &set_geometry_intr, WAIT_CMD, NULL);
ide_set_handler(drive, set_geometry_intr, WAIT_CMD, NULL);
return ide_started;
}
/*
* This is invoked on completion of a WIN_RESTORE (recalibrate) cmd.
*/
ide_startstop_t recal_intr(ide_drive_t *drive)
ide_startstop_t recal_intr(struct ata_device *drive, struct request *__rq)
{
byte stat = GET_STAT();
u8 stat;
if (!OK_STAT(stat,READY_STAT,BAD_STAT))
if (!OK_STAT(stat = GET_STAT(),READY_STAT,BAD_STAT))
return ide_error(drive, "recal_intr", stat);
return ide_stopped;
}
......@@ -522,14 +515,14 @@ ide_startstop_t recal_intr(ide_drive_t *drive)
/*
* Handler for commands without a data phase
*/
ide_startstop_t task_no_data_intr (ide_drive_t *drive)
ide_startstop_t task_no_data_intr(struct ata_device *drive, struct request *rq)
{
struct ata_taskfile *args = HWGROUP(drive)->rq->special;
byte stat = GET_STAT();
u8 stat;
struct ata_taskfile *args = rq->special;
ide__sti(); /* local CPU only */
if (!OK_STAT(stat, READY_STAT, BAD_STAT))
if (!OK_STAT(stat = GET_STAT(), READY_STAT, BAD_STAT))
return ide_error(drive, "task_no_data_intr", stat);
/* calls ide_end_drive_cmd */
if (args)
......@@ -541,10 +534,9 @@ ide_startstop_t task_no_data_intr (ide_drive_t *drive)
/*
* Handler for command with PIO data-in phase
*/
static ide_startstop_t task_in_intr (ide_drive_t *drive)
static ide_startstop_t task_in_intr (struct ata_device *drive, struct request *rq)
{
byte stat = GET_STAT();
struct request *rq = HWGROUP(drive)->rq;
u8 stat = GET_STAT();
char *pBuf = NULL;
unsigned long flags;
......@@ -554,7 +546,7 @@ static ide_startstop_t task_in_intr (ide_drive_t *drive)
}
if (!(stat & BUSY_STAT)) {
DTF("task_in_intr to Soon wait for next interrupt\n");
ide_set_handler(drive, &task_in_intr, WAIT_CMD, NULL);
ide_set_handler(drive, task_in_intr, WAIT_CMD, NULL);
return ide_started;
}
}
......@@ -572,18 +564,18 @@ static ide_startstop_t task_in_intr (ide_drive_t *drive)
*/
if (--rq->current_nr_sectors <= 0) {
DTF("Request Ended stat: %02x\n", GET_STAT());
if (!ide_end_request(drive, 1))
if (!ide_end_request(drive, rq, 1))
return ide_stopped;
}
/*
* still data left to transfer
*/
ide_set_handler(drive, &task_in_intr, WAIT_CMD, NULL);
ide_set_handler(drive, task_in_intr, WAIT_CMD, NULL);
return ide_started;
}
static ide_startstop_t pre_task_out_intr(ide_drive_t *drive, struct request *rq)
static ide_startstop_t pre_task_out_intr(struct ata_device *drive, struct request *rq)
{
struct ata_taskfile *args = rq->special;
ide_startstop_t startstop;
......@@ -604,7 +596,7 @@ static ide_startstop_t pre_task_out_intr(ide_drive_t *drive, struct request *rq)
ide_unmap_rq(rq, buf, &flags);
} else {
ata_poll_drive_ready(drive);
return args->handler(drive);
return args->handler(drive, rq);
}
return ide_started;
}
......@@ -612,10 +604,9 @@ static ide_startstop_t pre_task_out_intr(ide_drive_t *drive, struct request *rq)
/*
* Handler for command with PIO data-out phase
*/
static ide_startstop_t task_out_intr(ide_drive_t *drive)
static ide_startstop_t task_out_intr(struct ata_device *drive, struct request *rq)
{
byte stat = GET_STAT();
struct request *rq = HWGROUP(drive)->rq;
u8 stat = GET_STAT();
char *pBuf = NULL;
unsigned long flags;
......@@ -623,11 +614,10 @@ static ide_startstop_t task_out_intr(ide_drive_t *drive)
return ide_error(drive, "task_out_intr", stat);
if (!rq->current_nr_sectors)
if (!ide_end_request(drive, 1))
if (!ide_end_request(drive, rq, 1))
return ide_stopped;
if ((rq->current_nr_sectors==1) ^ (stat & DRQ_STAT)) {
rq = HWGROUP(drive)->rq;
pBuf = ide_map_rq(rq, &flags);
DTF("write: %p, rq->current_nr_sectors: %d\n", pBuf, (int) rq->current_nr_sectors);
......@@ -644,15 +634,14 @@ static ide_startstop_t task_out_intr(ide_drive_t *drive)
/*
* Handler for command with Read Multiple
*/
static ide_startstop_t task_mulin_intr(ide_drive_t *drive)
static ide_startstop_t task_mulin_intr(struct ata_device *drive, struct request *rq)
{
unsigned int msect, nsect;
byte stat = GET_STAT();
struct request *rq = HWGROUP(drive)->rq;
u8 stat;
char *pBuf = NULL;
unsigned int msect, nsect;
unsigned long flags;
if (!OK_STAT(stat,DATA_READY,BAD_R_STAT)) {
if (!OK_STAT(stat = GET_STAT(),DATA_READY,BAD_R_STAT)) {
if (stat & (ERR_STAT|DRQ_STAT)) {
return ide_error(drive, "task_mulin_intr", stat);
}
......@@ -679,7 +668,7 @@ static ide_startstop_t task_mulin_intr(ide_drive_t *drive)
rq->current_nr_sectors -= nsect;
msect -= nsect;
if (!rq->current_nr_sectors) {
if (!ide_end_request(drive, 1))
if (!ide_end_request(drive, rq, 1))
return ide_stopped;
}
} while (msect);
......
drivers/ide/ide.c
View file @ 4a58bd1a
......@@ -369,14 +369,12 @@ int drive_is_flashcard (ide_drive_t *drive)
return 0; /* no, it is not a flash memory card */
}
int __ide_end_request(struct ata_device *drive, int uptodate, int nr_secs)
int __ide_end_request(struct ata_device *drive, struct request *rq, int uptodate, int nr_secs)
{
struct request *rq;
unsigned long flags;
int ret = 1;
spin_lock_irqsave(&ide_lock, flags);
rq = HWGROUP(drive)->rq;
BUG_ON(!(rq->flags & REQ_STARTED));
......@@ -394,7 +392,7 @@ int __ide_end_request(struct ata_device *drive, int uptodate, int nr_secs)
if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) {
drive->state = 0;
drive->channel->dmaproc(ide_dma_on, drive);
drive->channel->udma(ide_dma_on, drive, rq);
}
if (!end_that_request_first(rq, uptodate, nr_secs)) {
......@@ -416,8 +414,8 @@ int __ide_end_request(struct ata_device *drive, int uptodate, int nr_secs)
* timer is started to prevent us from waiting forever in case
* something goes wrong (see the ide_timer_expiry() handler later on).
*/
void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
unsigned int timeout, ide_expiry_t *expiry)
void ide_set_handler(struct ata_device *drive, ata_handler_t handler,
unsigned long timeout, ata_expiry_t expiry)
{
unsigned long flags;
ide_hwgroup_t *hwgroup = HWGROUP(drive);
......@@ -434,7 +432,7 @@ void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
spin_unlock_irqrestore(&ide_lock, flags);
}
static void ata_pre_reset(ide_drive_t *drive)
static void ata_pre_reset(struct ata_device *drive)
{
if (ata_ops(drive) && ata_ops(drive)->pre_reset)
ata_ops(drive)->pre_reset(drive);
......@@ -444,13 +442,13 @@ static void ata_pre_reset(ide_drive_t *drive)
/* check the DMA crc count */
if (drive->crc_count) {
drive->channel->dmaproc(ide_dma_off_quietly, drive);
drive->channel->udma(ide_dma_off_quietly, drive, NULL);
if ((drive->channel->speedproc) != NULL)
drive->channel->speedproc(drive, ide_auto_reduce_xfer(drive));
if (drive->current_speed >= XFER_SW_DMA_0)
drive->channel->dmaproc(ide_dma_on, drive);
drive->channel->udma(ide_dma_on, drive, NULL);
} else
drive->channel->dmaproc(ide_dma_off, drive);
drive->channel->udma(ide_dma_off, drive, NULL);
}
/*
......@@ -536,7 +534,7 @@ static ide_startstop_t do_reset1(ide_drive_t *, int); /* needed below */
* operation. If the drive has not yet responded, and we have not yet hit our
* maximum waiting time, then the timer is restarted for another 50ms.
*/
static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
static ide_startstop_t atapi_reset_pollfunc(struct ata_device *drive, struct request *__rq)
{
ide_hwgroup_t *hwgroup = HWGROUP(drive);
byte stat;
......@@ -548,8 +546,7 @@ static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
printk("%s: ATAPI reset complete\n", drive->name);
} else {
if (time_before(jiffies, hwgroup->poll_timeout)) {
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20, NULL);
ide_set_handler (drive, atapi_reset_pollfunc, HZ/20, NULL);
return ide_started; /* continue polling */
}
hwgroup->poll_timeout = 0; /* end of polling */
......@@ -557,6 +554,7 @@ static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
return do_reset1 (drive, 1); /* do it the old fashioned way */
}
hwgroup->poll_timeout = 0; /* done polling */
return ide_stopped;
}
......@@ -565,7 +563,7 @@ static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
* If the drives have not yet responded, and we have not yet hit our maximum
* waiting time, then the timer is restarted for another 50ms.
*/
static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
static ide_startstop_t reset_pollfunc(struct ata_device *drive, struct request *__rq)
{
ide_hwgroup_t *hwgroup = HWGROUP(drive);
struct ata_channel *hwif = drive->channel;
......@@ -573,8 +571,7 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
if (!OK_STAT(stat=GET_STAT(), 0, BUSY_STAT)) {
if (time_before(jiffies, hwgroup->poll_timeout)) {
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, &reset_pollfunc, HZ/20, NULL);
ide_set_handler(drive, reset_pollfunc, HZ/20, NULL);
return ide_started; /* continue polling */
}
printk("%s: reset timed-out, status=0x%02x\n", hwif->name, stat);
......@@ -589,7 +586,7 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
#if FANCY_STATUS_DUMPS
u8 val;
static const char *messages[5] = {
static char *messages[5] = {
" passed",
" formatter device",
" sector buffer",
......@@ -645,11 +642,10 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
ata_pre_reset(drive);
SELECT_DRIVE(hwif,drive);
udelay (20);
OUT_BYTE (WIN_SRST, IDE_COMMAND_REG);
OUT_BYTE(WIN_SRST, IDE_COMMAND_REG);
hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20, NULL);
__restore_flags (flags); /* local CPU only */
ide_set_handler(drive, atapi_reset_pollfunc, HZ/20, NULL);
__restore_flags(flags); /* local CPU only */
return ide_started;
}
......@@ -682,8 +678,7 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
}
udelay(10); /* more than enough time */
hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
ide_set_handler(drive, reset_pollfunc, HZ/20, NULL);
/*
* Some weird controller like resetting themselves to a strange
......@@ -912,9 +907,9 @@ ide_startstop_t ide_error(ide_drive_t *drive, const char *msg, byte stat)
if (rq->errors >= ERROR_MAX) {
if (ata_ops(drive) && ata_ops(drive)->end_request)
ata_ops(drive)->end_request(drive, 0);
ata_ops(drive)->end_request(drive, rq, 0);
else
ide_end_request(drive, 0);
ide_end_request(drive, rq, 0);
} else {
if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
++rq->errors;
......@@ -930,9 +925,8 @@ ide_startstop_t ide_error(ide_drive_t *drive, const char *msg, byte stat)
/*
* Issue a simple drive command. The drive must be selected beforehand.
*/
void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler)
void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ata_handler_t handler)
{
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, handler, WAIT_CMD, NULL);
if (IDE_CONTROL_REG)
OUT_BYTE(drive->ctl,IDE_CONTROL_REG); /* clear nIEN */
......@@ -944,9 +938,8 @@ void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler)
/*
* Invoked on completion of a special DRIVE_CMD.
*/
static ide_startstop_t drive_cmd_intr(ide_drive_t *drive)
static ide_startstop_t drive_cmd_intr(struct ata_device *drive, struct request *rq)
{
struct request *rq = HWGROUP(drive)->rq;
u8 *args = rq->buffer;
u8 stat = GET_STAT();
int retries = 10;
......@@ -1135,7 +1128,7 @@ static ide_startstop_t start_request(ide_drive_t *drive, struct request *rq)
if (ata_ops(drive)->do_request)
return ata_ops(drive)->do_request(drive, rq, block);
else {
ide_end_request(drive, 0);
ide_end_request(drive, rq, 0);
return ide_stopped;
}
}
......@@ -1149,9 +1142,9 @@ static ide_startstop_t start_request(ide_drive_t *drive, struct request *rq)
kill_rq:
if (ata_ops(drive) && ata_ops(drive)->end_request)
ata_ops(drive)->end_request(drive, 0);
ata_ops(drive)->end_request(drive, rq, 0);
else
ide_end_request(drive, 0);
ide_end_request(drive, rq, 0);
return ide_stopped;
......@@ -1368,21 +1361,20 @@ void do_ide_request(request_queue_t *q)
* retry the current request in PIO mode instead of risking tossing it
* all away
*/
void ide_dma_timeout_retry(ide_drive_t *drive)
static void dma_timeout_retry(ide_drive_t *drive, struct request *rq)
{
struct ata_channel *hwif = drive->channel;
struct request *rq;
/*
* end current dma transaction
*/
hwif->dmaproc(ide_dma_end, drive);
hwif->udma(ide_dma_end, drive, rq);
/*
* complain a little, later we might remove some of this verbosity
*/
printk("%s: timeout waiting for DMA\n", drive->name);
hwif->dmaproc(ide_dma_timeout, drive);
hwif->udma(ide_dma_timeout, drive, rq);
/*
* Disable dma for now, but remember that we did so because of
......@@ -1391,13 +1383,12 @@ void ide_dma_timeout_retry(ide_drive_t *drive)
*/
drive->retry_pio++;
drive->state = DMA_PIO_RETRY;
hwif->dmaproc(ide_dma_off_quietly, drive);
hwif->udma(ide_dma_off_quietly, drive, rq);
/*
* un-busy drive etc (hwgroup->busy is cleared on return) and
* make sure request is sane
*/
rq = HWGROUP(drive)->rq;
HWGROUP(drive)->rq = NULL;
rq->errors = 0;
......@@ -1416,8 +1407,8 @@ void ide_dma_timeout_retry(ide_drive_t *drive)
void ide_timer_expiry(unsigned long data)
{
ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data;
ide_handler_t *handler;
ide_expiry_t *expiry;
ata_handler_t *handler;
ata_expiry_t *expiry;
unsigned long flags;
unsigned long wait;
......@@ -1454,7 +1445,7 @@ void ide_timer_expiry(unsigned long data)
printk("%s: ide_timer_expiry: hwgroup was not busy??\n", drive->name);
if ((expiry = hwgroup->expiry) != NULL) {
/* continue */
if ((wait = expiry(drive)) != 0) {
if ((wait = expiry(drive, HWGROUP(drive)->rq)) != 0) {
/* reengage timer */
hwgroup->timer.expires = jiffies + wait;
add_timer(&hwgroup->timer);
......@@ -1477,17 +1468,17 @@ void ide_timer_expiry(unsigned long data)
#endif
__cli(); /* local CPU only, as if we were handling an interrupt */
if (hwgroup->poll_timeout != 0) {
startstop = handler(drive);
startstop = handler(drive, ch->hwgroup->rq);
} else if (drive_is_ready(drive)) {
if (drive->waiting_for_dma)
ch->dmaproc(ide_dma_lostirq, drive);
ch->udma(ide_dma_lostirq, drive, ch->hwgroup->rq);
(void) ide_ack_intr(ch);
printk("%s: lost interrupt\n", drive->name);
startstop = handler(drive);
startstop = handler(drive, ch->hwgroup->rq);
} else {
if (drive->waiting_for_dma) {
startstop = ide_stopped;
ide_dma_timeout_retry(drive);
dma_timeout_retry(drive, ch->hwgroup->rq);
} else
startstop = ide_error(drive, "irq timeout", GET_STAT());
}
......@@ -1559,7 +1550,7 @@ static void unexpected_irq(int irq)
}
/*
* entry point for all interrupts, caller does __cli() for us
* Entry point for all interrupts, caller does __cli() for us.
*/
void ata_irq_request(int irq, void *data, struct pt_regs *regs)
{
......@@ -1568,7 +1559,7 @@ void ata_irq_request(int irq, void *data, struct pt_regs *regs)
unsigned long flags;
struct ata_device *drive;
ide_handler_t *handler;
ata_handler_t *handler = hwgroup->handler;
ide_startstop_t startstop;
spin_lock_irqsave(&ide_lock, flags);
......@@ -1576,7 +1567,7 @@ void ata_irq_request(int irq, void *data, struct pt_regs *regs)
if (!ide_ack_intr(ch))
goto out_lock;
if ((handler = hwgroup->handler) == NULL || hwgroup->poll_timeout != 0) {
if (handler == NULL || hwgroup->poll_timeout != 0) {
#if 0
printk(KERN_INFO "ide: unexpected interrupt %d %d\n", ch->unit, irq);
#endif
......@@ -1636,7 +1627,9 @@ void ata_irq_request(int irq, void *data, struct pt_regs *regs)
if (ch->unmask)
ide__sti(); /* local CPU only */
startstop = handler(drive); /* service this interrupt, may set handler for next interrupt */
/* service this interrupt, may set handler for next interrupt */
startstop = handler(drive, hwgroup->rq);
spin_lock_irq(&ide_lock);
/*
......@@ -2123,7 +2116,7 @@ void ide_unregister(struct ata_channel *ch)
ch->ata_write = old_hwif.ata_write;
ch->atapi_read = old_hwif.atapi_read;
ch->atapi_write = old_hwif.atapi_write;
ch->dmaproc = old_hwif.dmaproc;
ch->udma = old_hwif.udma;
ch->busproc = old_hwif.busproc;
ch->bus_state = old_hwif.bus_state;
ch->dma_base = old_hwif.dma_base;
......@@ -2398,13 +2391,13 @@ static int set_io_32bit(struct ata_device *drive, int arg)
return 0;
}
static int set_using_dma (ide_drive_t *drive, int arg)
static int set_using_dma(ide_drive_t *drive, int arg)
{
if (!drive->driver)
return -EPERM;
if (!drive->id || !(drive->id->capability & 1) || !drive->channel->dmaproc)
if (!drive->id || !(drive->id->capability & 1) || !drive->channel->udma)
return -EPERM;
if (drive->channel->dmaproc(arg ? ide_dma_on : ide_dma_off, drive))
if (drive->channel->udma(arg ? ide_dma_on : ide_dma_off, drive, NULL))
return -EIO;
return 0;
}
......@@ -3122,9 +3115,9 @@ int __init ide_setup (char *s)
/****************************************************************************/
/* This is the default end request function as well */
int ide_end_request(ide_drive_t *drive, int uptodate)
int ide_end_request(struct ata_device *drive, struct request *rq, int uptodate)
{
return __ide_end_request(drive, uptodate, 0);
return __ide_end_request(drive, rq, uptodate, 0);
}
/*
......@@ -3173,7 +3166,7 @@ int ide_register_subdriver(ide_drive_t *drive, struct ata_operations *driver)
restore_flags(flags); /* all CPUs */
/* FIXME: Check what this magic number is supposed to be about? */
if (drive->autotune != 2) {
if (drive->channel->dmaproc != NULL) {
if (drive->channel->udma) {
/*
* Force DMAing for the beginning of the check. Some
......@@ -3183,8 +3176,8 @@ int ide_register_subdriver(ide_drive_t *drive, struct ata_operations *driver)
* PARANOIA!!!
*/
drive->channel->dmaproc(ide_dma_off_quietly, drive);
drive->channel->dmaproc(ide_dma_check, drive);
drive->channel->udma(ide_dma_off_quietly, drive, NULL);
drive->channel->udma(ide_dma_check, drive, NULL);
}
/* Only CD-ROMs and tape drives support DSC overlap. */
drive->dsc_overlap = (drive->next != drive
......
drivers/ide/ns87415.c
View file @ 4a58bd1a
......@@ -82,7 +82,7 @@ static void ns87415_selectproc (ide_drive_t *drive)
}
#ifdef CONFIG_BLK_DEV_IDEDMA
static int ns87415_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
static int ns87415_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
struct ata_channel *hwif = drive->channel;
byte dma_stat;
......@@ -98,16 +98,16 @@ static int ns87415_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
case ide_dma_write:
case ide_dma_read:
ns87415_prepare_drive(drive, 1); /* select DMA xfer */
if (!ide_dmaproc(func, drive)) /* use standard DMA stuff */
if (!ide_dmaproc(func, drive, rq)) /* use standard DMA stuff */
return 0;
ns87415_prepare_drive(drive, 0); /* DMA failed: select PIO xfer */
return 1;
case ide_dma_check:
if (drive->type != ATA_DISK)
return ide_dmaproc(ide_dma_off_quietly, drive);
return ide_dmaproc(ide_dma_off_quietly, drive, rq);
/* Fallthrough... */
default:
return ide_dmaproc(func, drive); /* use standard DMA stuff */
return ide_dmaproc(func, drive, rq); /* use standard DMA stuff */
}
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -206,7 +206,7 @@ void __init ide_init_ns87415(struct ata_channel *hwif)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base)
hwif->dmaproc = &ns87415_dmaproc;
hwif->udma = ns87415_dmaproc;
#endif
hwif->selectproc = &ns87415_selectproc;
......
drivers/ide/pdc202xx.c
View file @ 4a58bd1a
......@@ -929,7 +929,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (id && (id->capability & 1) && hwif->autodma) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive)) {
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL)) {
dma_func = ide_dma_off;
goto fast_ata_pio;
}
......@@ -951,7 +951,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (dma_func != ide_dma_on)
goto no_dma_set;
}
} else if (ide_dmaproc(ide_dma_good_drive, drive)) {
} else if (ide_dmaproc(ide_dma_good_drive, drive, NULL)) {
if (id->eide_dma_time > 150) {
goto no_dma_set;
}
......@@ -969,7 +969,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
(void) config_chipset_for_pio(drive, 5);
}
return drive->channel->dmaproc(dma_func, drive);
return drive->channel->udma(dma_func, drive, NULL);
}
int pdc202xx_quirkproc (ide_drive_t *drive)
......@@ -980,7 +980,7 @@ int pdc202xx_quirkproc (ide_drive_t *drive)
/*
* pdc202xx_dmaproc() initiates/aborts (U)DMA read/write operations on a drive.
*/
int pdc202xx_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
int pdc202xx_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
byte dma_stat = 0;
byte sc1d = 0;
......@@ -1060,7 +1060,7 @@ int pdc202xx_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
default:
break;
}
return ide_dmaproc(func, drive); /* use standard DMA stuff */
return ide_dmaproc(func, drive, rq); /* use standard DMA stuff */
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -1268,7 +1268,7 @@ void __init ide_init_pdc202xx(struct ata_channel *hwif)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base) {
hwif->dmaproc = &pdc202xx_dmaproc;
hwif->udma = pdc202xx_dmaproc;
hwif->highmem = 1;
if (!noautodma)
hwif->autodma = 1;
......
drivers/ide/pdc4030.c
View file @ 4a58bd1a
......@@ -306,13 +306,12 @@ void __init ide_probe_for_pdc4030(void)
/*
* promise_read_intr() is the handler for disk read/multread interrupts
*/
static ide_startstop_t promise_read_intr (ide_drive_t *drive)
static ide_startstop_t promise_read_intr(struct ata_device *drive, struct request *rq)
{
byte stat;
int total_remaining;
unsigned int sectors_left, sectors_avail, nsect;
unsigned long flags;
struct request *rq;
char *to;
if (!OK_STAT(stat=GET_STAT(),DATA_READY,BAD_R_STAT)) {
......@@ -324,13 +323,11 @@ static ide_startstop_t promise_read_intr (ide_drive_t *drive)
sectors_left = IN_BYTE(IDE_NSECTOR_REG);
IN_BYTE(IDE_SECTOR_REG);
} while (IN_BYTE(IDE_NSECTOR_REG) != sectors_left);
rq = HWGROUP(drive)->rq;
sectors_avail = rq->nr_sectors - sectors_left;
if (!sectors_avail)
goto read_again;
read_next:
rq = HWGROUP(drive)->rq;
nsect = rq->current_nr_sectors;
if (nsect > sectors_avail)
nsect = sectors_avail;
......@@ -348,7 +345,7 @@ static ide_startstop_t promise_read_intr (ide_drive_t *drive)
rq->nr_sectors -= nsect;
total_remaining = rq->nr_sectors;
if ((rq->current_nr_sectors -= nsect) <= 0) {
ide_end_request(drive, 1);
ide_end_request(drive, rq, 1);
}
/*
* Now the data has been read in, do the following:
......@@ -368,7 +365,7 @@ static ide_startstop_t promise_read_intr (ide_drive_t *drive)
if (stat & DRQ_STAT)
goto read_again;
if (stat & BUSY_STAT) {
ide_set_handler (drive, &promise_read_intr, WAIT_CMD, NULL);
ide_set_handler(drive, promise_read_intr, WAIT_CMD, NULL);
#ifdef DEBUG_READ
printk(KERN_DEBUG "%s: promise_read: waiting for"
"interrupt\n", drive->name);
......@@ -383,22 +380,19 @@ static ide_startstop_t promise_read_intr (ide_drive_t *drive)
}
/*
* promise_complete_pollfunc()
* This is the polling function for waiting (nicely!) until drive stops
* being busy. It is invoked at the end of a write, after the previous poll
* has finished.
*
* Once not busy, the end request is called.
*/
static ide_startstop_t promise_complete_pollfunc(ide_drive_t *drive)
static ide_startstop_t promise_complete_pollfunc(struct ata_device *drive, struct request *rq)
{
ide_hwgroup_t *hwgroup = HWGROUP(drive);
struct request *rq = hwgroup->rq;
if (GET_STAT() & BUSY_STAT) {
if (time_before(jiffies, hwgroup->poll_timeout)) {
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &promise_complete_pollfunc, HZ/100, NULL);
ide_set_handler(drive, promise_complete_pollfunc, HZ/100, NULL);
return ide_started; /* continue polling... */
}
hwgroup->poll_timeout = 0;
......@@ -411,7 +405,7 @@ static ide_startstop_t promise_complete_pollfunc(ide_drive_t *drive)
#ifdef DEBUG_WRITE
printk(KERN_DEBUG "%s: Write complete - end_request\n", drive->name);
#endif
__ide_end_request(drive, 1, rq->nr_sectors);
__ide_end_request(drive, rq, 1, rq->nr_sectors);
return ide_stopped;
}
......@@ -427,11 +421,8 @@ static ide_startstop_t promise_complete_pollfunc(ide_drive_t *drive)
* full "mcount" number of sectors, so we must make sure we update the
* state _before_ we output the final part of the data!
*/
int promise_multwrite (ide_drive_t *drive, unsigned int mcount)
int promise_multwrite(struct ata_device *drive, struct request *rq, unsigned int mcount)
{
ide_hwgroup_t *hwgroup= HWGROUP(drive);
struct request *rq = &hwgroup->wrq;
do {
char *buffer;
int nsect = rq->current_nr_sectors;
......@@ -474,14 +465,13 @@ int promise_multwrite (ide_drive_t *drive, unsigned int mcount)
/*
* promise_write_pollfunc() is the handler for disk write completion polling.
*/
static ide_startstop_t promise_write_pollfunc (ide_drive_t *drive)
static ide_startstop_t promise_write_pollfunc(struct ata_device *drive, struct request *rq)
{
ide_hwgroup_t *hwgroup = HWGROUP(drive);
if (IN_BYTE(IDE_NSECTOR_REG) != 0) {
if (time_before(jiffies, hwgroup->poll_timeout)) {
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, &promise_write_pollfunc, HZ/100, NULL);
ide_set_handler(drive, promise_write_pollfunc, HZ/100, NULL);
return ide_started; /* continue polling... */
}
hwgroup->poll_timeout = 0;
......@@ -492,10 +482,9 @@ static ide_startstop_t promise_write_pollfunc (ide_drive_t *drive)
/*
* Now write out last 4 sectors and poll for not BUSY
*/
promise_multwrite(drive, 4);
promise_multwrite(drive, rq, 4);
hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &promise_complete_pollfunc, HZ/100, NULL);
ide_set_handler(drive, promise_complete_pollfunc, HZ/100, NULL);
#ifdef DEBUG_WRITE
printk(KERN_DEBUG "%s: Done last 4 sectors - status = %02x\n",
drive->name, GET_STAT());
......@@ -510,10 +499,9 @@ static ide_startstop_t promise_write_pollfunc (ide_drive_t *drive)
* before the final 4 sectors are transferred. There is no interrupt generated
* on writes (at least on the DC4030VL-2), we just have to poll for NOT BUSY.
*/
static ide_startstop_t promise_write (ide_drive_t *drive)
static ide_startstop_t promise_write(struct ata_device *drive, struct request *rq)
{
ide_hwgroup_t *hwgroup = HWGROUP(drive);
struct request *rq = &hwgroup->wrq;
#ifdef DEBUG_WRITE
printk(KERN_DEBUG "%s: promise_write: sectors(%ld-%ld), "
......@@ -526,22 +514,20 @@ static ide_startstop_t promise_write (ide_drive_t *drive)
* the polling strategy as defined above.
*/
if (rq->nr_sectors > 4) {
if (promise_multwrite(drive, rq->nr_sectors - 4))
if (promise_multwrite(drive, rq, rq->nr_sectors - 4))
return ide_stopped;
hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler (drive, &promise_write_pollfunc, HZ/100, NULL);
ide_set_handler(drive, promise_write_pollfunc, HZ/100, NULL);
return ide_started;
} else {
/*
* There are 4 or fewer sectors to transfer, do them all in one go
* and wait for NOT BUSY.
*/
if (promise_multwrite(drive, rq->nr_sectors))
if (promise_multwrite(drive, rq, rq->nr_sectors))
return ide_stopped;
hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &promise_complete_pollfunc, HZ/100, NULL);
ide_set_handler(drive, promise_complete_pollfunc, HZ/100, NULL);
#ifdef DEBUG_WRITE
printk(KERN_DEBUG "%s: promise_write: <= 4 sectors, "
"status = %02x\n", drive->name, GET_STAT());
......@@ -555,9 +541,8 @@ static ide_startstop_t promise_write (ide_drive_t *drive)
* already set up. It issues a READ or WRITE command to the Promise
* controller, assuming LBA has been used to set up the block number.
*/
ide_startstop_t do_pdc4030_io(ide_drive_t *drive, struct ata_taskfile *task)
ide_startstop_t do_pdc4030_io(struct ata_device *drive, struct ata_taskfile *task, struct request *rq)
{
struct request *rq = HWGROUP(drive)->rq;
struct hd_drive_task_hdr *taskfile = &task->taskfile;
unsigned long timeout;
byte stat;
......@@ -565,7 +550,7 @@ ide_startstop_t do_pdc4030_io(ide_drive_t *drive, struct ata_taskfile *task)
/* Check that it's a regular command. If not, bomb out early. */
if (!(rq->flags & REQ_CMD)) {
blk_dump_rq_flags(rq, "pdc4030 bad flags");
ide_end_request(drive, 0);
ide_end_request(drive, rq, 0);
return ide_stopped;
}
......@@ -600,15 +585,14 @@ ide_startstop_t do_pdc4030_io(ide_drive_t *drive, struct ata_taskfile *task)
stat=GET_STAT();
if (stat & DRQ_STAT) {
udelay(1);
return promise_read_intr(drive);
return promise_read_intr(drive, rq);
}
if (IN_BYTE(IDE_SELECT_REG) & 0x01) {
#ifdef DEBUG_READ
printk(KERN_DEBUG "%s: read: waiting for "
"interrupt\n", drive->name);
#endif
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &promise_read_intr, WAIT_CMD, NULL);
ide_set_handler(drive, promise_read_intr, WAIT_CMD, NULL);
return ide_started;
}
udelay(1);
......@@ -634,39 +618,34 @@ ide_startstop_t do_pdc4030_io(ide_drive_t *drive, struct ata_taskfile *task)
}
if (!drive->channel->unmask)
__cli(); /* local CPU only */
HWGROUP(drive)->wrq = *rq; /* scratchpad */
return promise_write(drive);
return promise_write(drive, rq);
}
default:
printk(KERN_ERR "pdc4030: command not READ or WRITE! Huh?\n");
ide_end_request(drive, 0);
ide_end_request(drive, rq, 0);
return ide_stopped;
}
}
ide_startstop_t promise_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
ide_startstop_t promise_rw_disk(struct ata_device *drive, struct request *rq, sector_t block)
{
struct hd_drive_task_hdr taskfile;
struct ata_taskfile args;
memset(&taskfile, 0, sizeof(struct hd_drive_task_hdr));
memset(&args, 0, sizeof(args));
/* The four drives on the two logical (one physical) interfaces
are distinguished by writing the drive number (0-3) to the
Feature register.
FIXME: Is promise_selectproc now redundant??
*/
taskfile.feature = (drive->channel->unit << 1) + drive->select.b.unit;
taskfile.sector_count = rq->nr_sectors;
taskfile.sector_number = block;
taskfile.low_cylinder = (block>>=8);
taskfile.high_cylinder = (block>>=8);
taskfile.device_head = ((block>>8)&0x0f)|drive->select.all;
taskfile.command = (rq_data_dir(rq)==READ)?PROMISE_READ:PROMISE_WRITE;
args.taskfile = taskfile;
memset(&args.hobfile, 0, sizeof(struct hd_drive_hob_hdr));
args.taskfile.feature = (drive->channel->unit << 1) + drive->select.b.unit;
args.taskfile.sector_count = rq->nr_sectors;
args.taskfile.sector_number = block;
args.taskfile.low_cylinder = (block>>=8);
args.taskfile.high_cylinder = (block>>=8);
args.taskfile.device_head = ((block>>8)&0x0f)|drive->select.all;
args.taskfile.command = (rq_data_dir(rq)==READ)?PROMISE_READ:PROMISE_WRITE;
ide_cmd_type_parser(&args);
/* We don't use the generic inerrupt handlers here? */
......@@ -674,6 +653,6 @@ ide_startstop_t promise_rw_disk (ide_drive_t *drive, struct request *rq, unsigne
args.handler = NULL;
rq->special = &args;
return do_pdc4030_io(drive, &args);
return do_pdc4030_io(drive, &args, rq);
}
drivers/ide/piix.c
View file @ 4a58bd1a
......@@ -376,7 +376,7 @@ static void piix_tune_drive(ide_drive_t *drive, unsigned char pio)
* else to the default ide_dmaproc().
*/
int piix_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
int piix_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
if (func == ide_dma_check) {
......@@ -397,7 +397,7 @@ int piix_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
}
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -555,7 +555,7 @@ void __init ide_init_piix(struct ata_channel *hwif)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base) {
hwif->highmem = 1;
hwif->dmaproc = &piix_dmaproc;
hwif->udma = piix_dmaproc;
#ifdef CONFIG_IDEDMA_AUTO
if (!noautodma)
hwif->autodma = 1;
......
drivers/ide/serverworks.c
View file @ 4a58bd1a
......@@ -438,7 +438,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (id && (id->capability & 1) && drive->channel->autodma) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive)) {
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL)) {
dma_func = ide_dma_off;
goto fast_ata_pio;
}
......@@ -460,7 +460,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (dma_func != ide_dma_on)
goto no_dma_set;
}
} else if (ide_dmaproc(ide_dma_good_drive, drive)) {
} else if (ide_dmaproc(ide_dma_good_drive, drive, NULL)) {
if (id->eide_dma_time > 150) {
goto no_dma_set;
}
......@@ -477,10 +477,10 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
no_dma_set:
config_chipset_for_pio(drive);
}
return drive->channel->dmaproc(dma_func, drive);
return drive->channel->udma(dma_func, drive, NULL);
}
static int svwks_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
static int svwks_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
switch (func) {
case ide_dma_check:
......@@ -523,7 +523,7 @@ static int svwks_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
break;
}
/* Other cases are done by generic IDE-DMA code. */
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -645,7 +645,7 @@ void __init ide_init_svwks(struct ata_channel *hwif)
if (!noautodma)
hwif->autodma = 1;
#endif
hwif->dmaproc = &svwks_dmaproc;
hwif->udma = svwks_dmaproc;
hwif->highmem = 1;
} else {
hwif->autodma = 0;
......
drivers/ide/sis5513.c
View file @ 4a58bd1a
......@@ -685,7 +685,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (id && (id->capability & 1) && drive->channel->autodma) {
/* Consult the list of known "bad" drives */
if (ide_dmaproc(ide_dma_bad_drive, drive)) {
if (ide_dmaproc(ide_dma_bad_drive, drive, NULL)) {
dma_func = ide_dma_off;
goto fast_ata_pio;
}
......@@ -707,7 +707,7 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
if (dma_func != ide_dma_on)
goto no_dma_set;
}
} else if ((ide_dmaproc(ide_dma_good_drive, drive)) &&
} else if ((ide_dmaproc(ide_dma_good_drive, drive, NULL)) &&
(id->eide_dma_time > 150)) {
/* Consult the list of known "good" drives */
dma_func = config_chipset_for_dma(drive, 0);
......@@ -723,11 +723,11 @@ static int config_drive_xfer_rate (ide_drive_t *drive)
(void) config_chipset_for_pio(drive, 5);
}
return drive->channel->dmaproc(dma_func, drive);
return drive->channel->udma(dma_func, drive, NULL);
}
/* initiates/aborts (U)DMA read/write operations on a drive. */
int sis5513_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
int sis5513_dmaproc (ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
switch (func) {
case ide_dma_check:
......@@ -737,7 +737,7 @@ int sis5513_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
default:
break;
}
return ide_dmaproc(func, drive); /* use standard DMA stuff */
return ide_dmaproc(func, drive, rq); /* use standard DMA stuff */
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -852,7 +852,7 @@ void __init ide_init_sis5513(struct ata_channel *hwif)
if (chipset_family > ATA_16) {
hwif->autodma = noautodma ? 0 : 1;
hwif->highmem = 1;
hwif->dmaproc = &sis5513_dmaproc;
hwif->udma = sis5513_dmaproc;
} else {
#endif
hwif->autodma = 0;
......
drivers/ide/trm290.c
View file @ 4a58bd1a
......@@ -194,7 +194,6 @@ static int trm290_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
outw((count * 2) - 1, hwif->dma_base+2); /* start DMA */
if (drive->type != ATA_DISK)
return 0;
BUG_ON(HWGROUP(drive)->handler);
ide_set_handler(drive, &ide_dma_intr, WAIT_CMD, NULL);
OUT_BYTE(reading ? WIN_READDMA : WIN_WRITEDMA, IDE_COMMAND_REG);
return 0;
......
drivers/ide/via82cxxx.c
View file @ 4a58bd1a
......@@ -363,7 +363,7 @@ static void via82cxxx_tune_drive(ide_drive_t *drive, unsigned char pio)
* else to the default ide_dmaproc().
*/
int via82cxxx_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
int via82cxxx_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
{
if (func == ide_dma_check) {
......@@ -383,7 +383,7 @@ int via82cxxx_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
? ide_dma_on : ide_dma_off_quietly;
}
return ide_dmaproc(func, drive);
return ide_dmaproc(func, drive, rq);
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
......@@ -546,7 +546,7 @@ void __init ide_init_via82cxxx(struct ata_channel *hwif)
#ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base) {
hwif->highmem = 1;
hwif->dmaproc = &via82cxxx_dmaproc;
hwif->udma = &via82cxxx_dmaproc;
#ifdef CONFIG_IDEDMA_AUTO
if (!noautodma)
hwif->autodma = 1;
......
drivers/scsi/ide-scsi.c
View file @ 4a58bd1a
......@@ -59,7 +59,6 @@ typedef struct idescsi_pc_s {
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 */
byte *buffer; /* Data buffer */
byte *current_position; /* Pointer into the above buffer */
struct scatterlist *sg; /* Scatter gather table */
......@@ -259,10 +258,9 @@ static void hexdump(u8 *x, int len)
printk("]\n");
}
static int idescsi_end_request(ide_drive_t *drive, int uptodate)
static int idescsi_end_request(struct ata_device *drive, struct request *rq, int uptodate)
{
idescsi_scsi_t *scsi = drive->driver_data;
struct request *rq = HWGROUP(drive)->rq;
idescsi_pc_t *pc = (idescsi_pc_t *) rq->special;
int log = test_bit(IDESCSI_LOG_CMD, &scsi->log);
struct Scsi_Host *host;
......@@ -270,7 +268,7 @@ static int idescsi_end_request(ide_drive_t *drive, int uptodate)
unsigned long flags;
if (!(rq->flags & REQ_SPECIAL)) {
ide_end_request(drive, uptodate);
ide_end_request(drive, rq, uptodate);
return 0;
}
ide_end_drive_cmd (drive, 0, 0);
......@@ -313,13 +311,12 @@ static inline unsigned long get_timeout(idescsi_pc_t *pc)
/*
* Our interrupt handler.
*/
static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
static ide_startstop_t idescsi_pc_intr(struct ata_device *drive, struct request *rq)
{
idescsi_scsi_t *scsi = drive->driver_data;
byte status, ireason;
int bcount;
idescsi_pc_t *pc=scsi->pc;
struct request *rq = pc->rq;
unsigned int temp;
#if IDESCSI_DEBUG_LOG
......@@ -331,7 +328,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
printk ("ide-scsi: %s: DMA complete\n", drive->name);
#endif /* IDESCSI_DEBUG_LOG */
pc->actually_transferred=pc->request_transfer;
(void) drive->channel->dmaproc(ide_dma_end, drive);
(void) drive->channel->udma(ide_dma_end, drive, NULL);
}
status = GET_STAT(); /* Clear the interrupt */
......@@ -342,7 +339,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
ide__sti();
if (status & ERR_STAT)
rq->errors++;
idescsi_end_request(drive, 1);
idescsi_end_request(drive, rq, 1);
return ide_stopped;
}
bcount = IN_BYTE (IDE_BCOUNTH_REG) << 8 | IN_BYTE (IDE_BCOUNTL_REG);
......@@ -369,7 +366,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
pc->actually_transferred += temp;
pc->current_position += temp;
idescsi_discard_data (drive,bcount - temp);
ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), NULL);
ide_set_handler(drive, idescsi_pc_intr, get_timeout(pc), NULL);
return ide_started;
}
#if IDESCSI_DEBUG_LOG
......@@ -393,11 +390,11 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
pc->actually_transferred+=bcount; /* Update the current position */
pc->current_position+=bcount;
ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), NULL); /* And set the interrupt handler again */
ide_set_handler(drive, idescsi_pc_intr, get_timeout(pc), NULL); /* And set the interrupt handler again */
return ide_started;
}
static ide_startstop_t idescsi_transfer_pc (ide_drive_t *drive)
static ide_startstop_t idescsi_transfer_pc(struct ata_device *drive, struct request *rq)
{
idescsi_scsi_t *scsi = drive->driver_data;
idescsi_pc_t *pc = scsi->pc;
......@@ -413,7 +410,7 @@ static ide_startstop_t idescsi_transfer_pc (ide_drive_t *drive)
printk (KERN_ERR "ide-scsi: (IO,CoD) != (0,1) while issuing a packet command\n");
return ide_stopped;
}
ide_set_handler(drive, &idescsi_pc_intr, get_timeout(pc), NULL); /* Set the interrupt routine */
ide_set_handler(drive, idescsi_pc_intr, get_timeout(pc), NULL); /* Set the interrupt routine */
atapi_write(drive, scsi->pc->c, 12); /* Send the actual packet */
return ide_started;
}
......@@ -421,11 +418,10 @@ static ide_startstop_t idescsi_transfer_pc (ide_drive_t *drive)
/*
* 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(struct ata_device *drive, struct request *rq, idescsi_pc_t *pc)
{
idescsi_scsi_t *scsi = drive->driver_data;
int bcount;
struct request *rq = pc->rq;
int dma_ok = 0;
scsi->pc=pc; /* Set the current packet command */
......@@ -434,7 +430,7 @@ static ide_startstop_t idescsi_issue_pc (ide_drive_t *drive, idescsi_pc_t *pc)
bcount = min(pc->request_transfer, 63 * 1024); /* Request to transfer the entire buffer at once */
if (drive->using_dma && rq->bio)
dma_ok = !drive->channel->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
dma_ok = !drive->channel->udma(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive, rq);
SELECT_DRIVE(drive->channel, drive);
if (IDE_CONTROL_REG)
......@@ -445,15 +441,15 @@ static ide_startstop_t idescsi_issue_pc (ide_drive_t *drive, idescsi_pc_t *pc)
if (dma_ok) {
set_bit(PC_DMA_IN_PROGRESS, &pc->flags);
(void) drive->channel->dmaproc(ide_dma_begin, drive);
(void) drive->channel->udma(ide_dma_begin, drive, NULL);
}
if (test_bit (IDESCSI_DRQ_INTERRUPT, &scsi->flags)) {
ide_set_handler (drive, &idescsi_transfer_pc, get_timeout(pc), NULL);
ide_set_handler(drive, idescsi_transfer_pc, get_timeout(pc), NULL);
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* Issue the packet command */
return ide_started;
} else {
OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG);
return idescsi_transfer_pc (drive);
return idescsi_transfer_pc(drive, rq);
}
}
......@@ -468,10 +464,10 @@ static ide_startstop_t idescsi_do_request(struct ata_device *drive, struct reque
#endif /* IDESCSI_DEBUG_LOG */
if (rq->flags & REQ_SPECIAL) {
return idescsi_issue_pc(drive, (idescsi_pc_t *) rq->special);
return idescsi_issue_pc(drive, rq, (idescsi_pc_t *) rq->special);
}
blk_dump_rq_flags(rq, "ide-scsi: unsup command");
idescsi_end_request(drive, 0);
idescsi_end_request(drive, rq, 0);
return ide_stopped;
}
......@@ -760,7 +756,6 @@ int idescsi_queue (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
memset (pc->c, 0, 12);
pc->flags = 0;
pc->rq = rq;
memcpy (pc->c, cmd->cmnd, cmd->cmd_len);
if (cmd->use_sg) {
pc->buffer = NULL;
......
include/linux/ide.h
View file @ 4a58bd1a
......@@ -374,7 +374,7 @@ struct ata_device {
} ide_drive_t;
/*
* An ide_dmaproc_t() initiates/aborts DMA read/write operations on a drive.
* This initiates/aborts DMA read/write operations on a drive.
*
* The caller is assumed to have selected the drive and programmed the drive's
* sector address using CHS or LBA. All that remains is to prepare for DMA
......@@ -392,8 +392,6 @@ typedef enum { ide_dma_read, ide_dma_write, ide_dma_begin,
ide_dma_lostirq, ide_dma_timeout
} ide_dma_action_t;
typedef int (ide_dmaproc_t)(ide_dma_action_t, ide_drive_t *);
enum {
ATA_PRIMARY = 0,
ATA_SECONDARY = 1
......@@ -446,7 +444,7 @@ struct ata_channel {
void (*atapi_read)(ide_drive_t *, void *, unsigned int);
void (*atapi_write)(ide_drive_t *, void *, unsigned int);
ide_dmaproc_t *dmaproc; /* dma read/write/abort routine */
int (*udma)(ide_dma_action_t, struct ata_device *, struct request *); /* dma read/write/abort routine */
unsigned int *dmatable_cpu; /* dma physical region descriptor table (cpu view) */
dma_addr_t dmatable_dma; /* dma physical region descriptor table (dma view) */
struct scatterlist *sg_table; /* Scatter-gather list used to build the above */
......@@ -500,31 +498,25 @@ typedef enum {
} ide_startstop_t;
/*
* Interrupt handler types.
* Interrupt and timeout handler type.
*/
struct ata_taskfile;
typedef ide_startstop_t (ide_pre_handler_t)(ide_drive_t *, struct request *);
typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
typedef ide_startstop_t (ata_handler_t)(struct ata_device *, struct request *);
typedef int (ata_expiry_t)(struct ata_device *, struct request *);
/*
* when ide_timer_expiry fires, invoke a handler of this type
* to decide what to do.
*/
typedef int (ide_expiry_t)(ide_drive_t *);
struct ata_taskfile;
#define IDE_BUSY 0 /* awaiting an interrupt */
#define IDE_SLEEP 1
#define IDE_DMA 2 /* DMA in progress */
typedef struct hwgroup_s {
ide_handler_t *handler; /* irq handler, if active */
ide_startstop_t (*handler)(struct ata_device *, struct request *); /* irq handler, if active */
unsigned long flags; /* BUSY, SLEEPING */
struct ata_device *drive; /* current drive */
struct request *rq; /* current request */
struct timer_list timer; /* failsafe timer */
struct request wrq; /* local copy of current write rq */
unsigned long poll_timeout; /* timeout value during long polls */
ide_expiry_t *expiry; /* queried upon timeouts */
int (*expiry)(struct ata_device *, struct request *); /* irq handler, if active */
} ide_hwgroup_t;
/* structure attached to the request for IDE_TASK_CMDS */
......@@ -616,7 +608,7 @@ struct ata_operations {
int (*cleanup)(struct ata_device *);
int (*standby)(struct ata_device *);
ide_startstop_t (*do_request)(struct ata_device *, struct request *, sector_t);
int (*end_request)(struct ata_device *, int);
int (*end_request)(struct ata_device *, struct request *, int);
int (*ioctl)(struct ata_device *, struct inode *, struct file *, unsigned int, unsigned long);
int (*open)(struct inode *, struct file *, struct ata_device *);
......@@ -663,14 +655,15 @@ extern int noautodma;
#define LOCAL_END_REQUEST /* Don't generate end_request in blk.h */
#include <linux/blk.h>
extern int __ide_end_request(ide_drive_t *drive, int uptodate, int nr_secs);
extern int ide_end_request(ide_drive_t *drive, int uptodate);
extern int __ide_end_request(struct ata_device *, struct request *, int, int);
extern int ide_end_request(struct ata_device *drive, struct request *, int);
/*
* This is used on exit from the driver, to designate the next irq handler
* and also to start the safety timer.
*/
void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry);
extern void ide_set_handler(struct ata_device *drive, ata_handler_t handler,
unsigned long timeout, ata_expiry_t expiry);
/*
* Error reporting, in human readable form (luxurious, but a memory hog).
......@@ -687,7 +680,7 @@ ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat);
* Issue a simple drive command
* The drive must be selected beforehand.
*/
void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler);
void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ata_handler_t handler);
/*
* ide_fixstring() cleans up and (optionally) byte-swaps a text string,
......@@ -757,8 +750,8 @@ struct ata_taskfile {
struct hd_drive_task_hdr taskfile;
struct hd_drive_hob_hdr hobfile;
int command_type;
ide_pre_handler_t *prehandler;
ide_handler_t *handler;
ide_startstop_t (*prehandler)(struct ata_device *, struct request *);
ide_startstop_t (*handler)(struct ata_device *, struct request *);
};
extern void ata_read(ide_drive_t *drive, void *buffer, unsigned int wcount);
......@@ -774,10 +767,10 @@ extern ide_startstop_t ata_taskfile(ide_drive_t *drive,
* Special Flagged Register Validation Caller
*/
extern ide_startstop_t recal_intr(ide_drive_t *drive);
extern ide_startstop_t set_geometry_intr(ide_drive_t *drive);
extern ide_startstop_t set_multmode_intr(ide_drive_t *drive);
extern ide_startstop_t task_no_data_intr(ide_drive_t *drive);
extern ide_startstop_t recal_intr(struct ata_device *, struct request *);
extern ide_startstop_t set_geometry_intr(struct ata_device *, struct request *);
extern ide_startstop_t set_multmode_intr(struct ata_device *, struct request *);
extern ide_startstop_t task_no_data_intr(struct ata_device *, struct request *);
/* This is setting up all fields in args, which depend upon the command type.
......@@ -871,9 +864,9 @@ void __init ide_scan_pcibus(int scan_direction);
#ifdef CONFIG_BLK_DEV_IDEDMA
int ide_build_dmatable (ide_drive_t *drive, ide_dma_action_t func);
void ide_destroy_dmatable (ide_drive_t *drive);
ide_startstop_t ide_dma_intr (ide_drive_t *drive);
extern ide_startstop_t ide_dma_intr(struct ata_device *, struct request *);
int check_drive_lists (ide_drive_t *drive, int good_bad);
int ide_dmaproc (ide_dma_action_t func, ide_drive_t *drive);
int ide_dmaproc (ide_dma_action_t func, struct ata_device *drive, struct request *);
extern void ide_release_dma(struct ata_channel *hwif);
extern void ide_setup_dma(struct ata_channel *hwif,
unsigned long dmabase, unsigned int num_ports) __init;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7