Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6

Browse source 
* git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6: (46 commits)
  ide: constify struct ide_dma_ops
  ide: add struct ide_dma_ops (take 3)
  ide: add IDE_HFLAG_SERIALIZE_DMA host flag
  sl82c105: check bridge revision in sl82c105_init_one()
  au1xxx-ide: use ->init_dma method
  palm_bk3710: use ->init_dma method
  sgiioc4: use ->init_dma method
  icside: use ->init_dma method
  ide-pmac: use ->init_dma method
  ide: do complete DMA setup in ->init_dma method (take 2)
  au1xxx-ide: fix MWDMA support
  ide: cleanup ide_setup_dma()
  ide: factor out setting PCI bus-mastering from ide_hwif_setup_dma()
  ide: export ide_allocate_dma_engine()
  ide: move ide_setup_dma() call out from ->init_dma method
  alim15x3: skip DMA initialization completely on revs < 0x20
  pdc202xx_old: remove init_dma_pdc202xx()
  ide: don't display "BIOS" settings in ide_setup_dma()
  ide: remove ->cds field from ide_hwif_t (take 2)
  ide: remove ide_dma_iobase()
  ...
This commit is contained in:
Linus Torvalds 2008-04-26 13:44:19 -07:00
commit a52b0d25a7
77 changed files with 1782 additions and 1880 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

46
Documentation/mips/AU1xxx_IDE.README
View file

@ -46,8 +46,6 @@ Two files are introduced:
a) 'include/asm-mips/mach-au1x00/au1xxx_ide.h' a) 'include/asm-mips/mach-au1x00/au1xxx_ide.h'
containes : struct _auide_hwif containes : struct _auide_hwif
struct drive_list_entry dma_white_list
struct drive_list_entry dma_black_list
timing parameters for PIO mode 0/1/2/3/4 timing parameters for PIO mode 0/1/2/3/4
timing parameters for MWDMA 0/1/2 timing parameters for MWDMA 0/1/2
@ -63,12 +61,6 @@ Four configs variables are introduced:
CONFIG_BLK_DEV_IDE_AU1XXX_SEQTS_PER_RQ - maximum transfer size CONFIG_BLK_DEV_IDE_AU1XXX_SEQTS_PER_RQ - maximum transfer size
per descriptor per descriptor
If MWDMA is enabled and the connected hard disc is not on the white list, the
kernel switches to a "safe mwdma mode" at boot time. In this mode the IDE
performance is substantial slower then in full speed mwdma. In this case
please add your hard disc to the white list (follow instruction from 'ADD NEW
HARD DISC TO WHITE OR BLACK LIST' section).
SUPPORTED IDE MODES SUPPORTED IDE MODES
------------------- -------------------
@ -120,44 +112,6 @@ CONFIG_IDEDMA_AUTO=y
Also undefine 'IDE_AU1XXX_BURSTMODE' in 'drivers/ide/mips/au1xxx-ide.c' to Also undefine 'IDE_AU1XXX_BURSTMODE' in 'drivers/ide/mips/au1xxx-ide.c' to
disable the burst support on DBDMA controller. disable the burst support on DBDMA controller.
ADD NEW HARD DISC TO WHITE OR BLACK LIST
----------------------------------------
Step 1 : detect the model name of your hard disc
a) connect your hard disc to the AU1XXX
b) boot your kernel and get the hard disc model.
Example boot log:
--snipped--
Uniform Multi-Platform E-IDE driver Revision: 7.00alpha2
ide: Assuming 50MHz system bus speed for PIO modes; override with idebus=xx
Au1xxx IDE(builtin) configured for MWDMA2
Probing IDE interface ide0...
hda: Maxtor 6E040L0, ATA DISK drive
ide0 at 0xac800000-0xac800007,0xac8001c0 on irq 64
hda: max request size: 64KiB
hda: 80293248 sectors (41110 MB) w/2048KiB Cache, CHS=65535/16/63, (U)DMA
--snipped--
In this example 'Maxtor 6E040L0'.
Step 2 : edit 'include/asm-mips/mach-au1x00/au1xxx_ide.h'
Add your hard disc to the dma_white_list or dma_black_list structur.
Step 3 : Recompile the kernel
Enable MWDMA support in the kernel configuration. Recompile the kernel and
reboot.
Step 4 : Tests
If you have add a hard disc to the white list, please run some stress tests
for verification.
ACKNOWLEDGMENTS ACKNOWLEDGMENTS
--------------- ---------------

3
drivers/ide/arm/bast-ide.c
View file

@ -55,8 +55,7 @@ static int __init bastide_register(unsigned int base, unsigned int aux, int irq)
ide_init_port_data(hwif, i); ide_init_port_data(hwif, i);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1; hwif->port_ops = NULL;
hwif->quirkproc = NULL;
idx[0] = i; idx[0] = i;

54
drivers/ide/arm/icside.c
View file

@ -191,6 +191,10 @@ static void icside_maskproc(ide_drive_t *drive, int mask)
local_irq_restore(flags); local_irq_restore(flags);
} }
static const struct ide_port_ops icside_v6_no_dma_port_ops = {
.maskproc = icside_maskproc,
};
#ifdef CONFIG_BLK_DEV_IDEDMA_ICS #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
/* /*
* SG-DMA support. * SG-DMA support.
@ -266,6 +270,11 @@ static void icside_set_dma_mode(ide_drive_t *drive, const u8 xfer_mode)
ide_xfer_verbose(xfer_mode), 2000 / drive->drive_data); ide_xfer_verbose(xfer_mode), 2000 / drive->drive_data);
} }
static const struct ide_port_ops icside_v6_port_ops = {
.set_dma_mode = icside_set_dma_mode,
.maskproc = icside_maskproc,
};
static void icside_dma_host_set(ide_drive_t *drive, int on) static void icside_dma_host_set(ide_drive_t *drive, int on)
{ {
} }
@ -375,25 +384,33 @@ static void icside_dma_lost_irq(ide_drive_t *drive)
printk(KERN_ERR "%s: IRQ lost\n", drive->name); printk(KERN_ERR "%s: IRQ lost\n", drive->name);
} }
static void icside_dma_init(ide_hwif_t *hwif) static int icside_dma_init(ide_hwif_t *hwif, const struct ide_port_info *d)
{ {
hwif->dmatable_cpu = NULL; hwif->dmatable_cpu = NULL;
hwif->dmatable_dma = 0; hwif->dmatable_dma = 0;
hwif->set_dma_mode = icside_set_dma_mode;
hwif->dma_host_set = icside_dma_host_set; return 0;
hwif->dma_setup = icside_dma_setup;
hwif->dma_exec_cmd = icside_dma_exec_cmd;
hwif->dma_start = icside_dma_start;
hwif->ide_dma_end = icside_dma_end;
hwif->ide_dma_test_irq = icside_dma_test_irq;
hwif->dma_timeout = icside_dma_timeout;
hwif->dma_lost_irq = icside_dma_lost_irq;
} }
static const struct ide_dma_ops icside_v6_dma_ops = {
.dma_host_set = icside_dma_host_set,
.dma_setup = icside_dma_setup,
.dma_exec_cmd = icside_dma_exec_cmd,
.dma_start = icside_dma_start,
.dma_end = icside_dma_end,
.dma_test_irq = icside_dma_test_irq,
.dma_timeout = icside_dma_timeout,
.dma_lost_irq = icside_dma_lost_irq,
};
#else #else
#define icside_dma_init(hwif) (0) #define icside_v6_dma_ops NULL
#endif #endif
static int icside_dma_off_init(ide_hwif_t *hwif, const struct ide_port_info *d)
{
return -EOPNOTSUPP;
}
static ide_hwif_t * static ide_hwif_t *
icside_setup(void __iomem *base, struct cardinfo *info, struct expansion_card *ec) icside_setup(void __iomem *base, struct cardinfo *info, struct expansion_card *ec)
{ {
@ -408,7 +425,6 @@ icside_setup(void __iomem *base, struct cardinfo *info, struct expansion_card *e
* Ensure we're using MMIO * Ensure we're using MMIO
*/ */
default_hwif_mmiops(hwif); default_hwif_mmiops(hwif);
hwif->mmio = 1;
for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) { for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
hwif->io_ports[i] = port; hwif->io_ports[i] = port;
@ -416,7 +432,6 @@ icside_setup(void __iomem *base, struct cardinfo *info, struct expansion_card *e
} }
hwif->io_ports[IDE_CONTROL_OFFSET] = (unsigned long)base + info->ctrloffset; hwif->io_ports[IDE_CONTROL_OFFSET] = (unsigned long)base + info->ctrloffset;
hwif->irq = ec->irq; hwif->irq = ec->irq;
hwif->noprobe = 0;
hwif->chipset = ide_acorn; hwif->chipset = ide_acorn;
hwif->gendev.parent = &ec->dev; hwif->gendev.parent = &ec->dev;
hwif->dev = &ec->dev; hwif->dev = &ec->dev;
@ -462,8 +477,10 @@ icside_register_v5(struct icside_state *state, struct expansion_card *ec)
} }
static const struct ide_port_info icside_v6_port_info __initdata = { static const struct ide_port_info icside_v6_port_info __initdata = {
.init_dma = icside_dma_off_init,
.port_ops = &icside_v6_no_dma_port_ops,
.dma_ops = &icside_v6_dma_ops,
.host_flags = IDE_HFLAG_SERIALIZE | .host_flags = IDE_HFLAG_SERIALIZE |
IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
IDE_HFLAG_NO_AUTOTUNE, IDE_HFLAG_NO_AUTOTUNE,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
.swdma_mask = ATA_SWDMA2, .swdma_mask = ATA_SWDMA2,
@ -526,7 +543,6 @@ icside_register_v6(struct icside_state *state, struct expansion_card *ec)
state->hwif[0] = hwif; state->hwif[0] = hwif;
state->hwif[1] = mate; state->hwif[1] = mate;
hwif->maskproc = icside_maskproc;
hwif->hwif_data = state; hwif->hwif_data = state;
hwif->config_data = (unsigned long)ioc_base; hwif->config_data = (unsigned long)ioc_base;
hwif->select_data = sel; hwif->select_data = sel;
@ -537,10 +553,10 @@ icside_register_v6(struct icside_state *state, struct expansion_card *ec)
mate->select_data = sel | 1; mate->select_data = sel | 1;
if (ec->dma != NO_DMA && !request_dma(ec->dma, hwif->name)) { if (ec->dma != NO_DMA && !request_dma(ec->dma, hwif->name)) {
icside_dma_init(hwif); d.init_dma = icside_dma_init;
icside_dma_init(mate); d.port_ops = &icside_v6_dma_port_ops;
} else d.dma_ops = NULL;
d.mwdma_mask = d.swdma_mask = 0; }
idx[0] = hwif->index; idx[0] = hwif->index;
idx[1] = mate->index; idx[1] = mate->index;

18
drivers/ide/arm/ide_arm.c
View file

@ -14,6 +14,8 @@
#include <asm/mach-types.h> #include <asm/mach-types.h>
#include <asm/irq.h> #include <asm/irq.h>
#define DRV_NAME "ide_arm"
#ifdef CONFIG_ARCH_CLPS7500 #ifdef CONFIG_ARCH_CLPS7500
# include <asm/arch/hardware.h> # include <asm/arch/hardware.h>
# #
@ -28,10 +30,24 @@ static int __init ide_arm_init(void)
{ {
ide_hwif_t *hwif; ide_hwif_t *hwif;
hw_regs_t hw; hw_regs_t hw;
unsigned long base = IDE_ARM_IO, ctl = IDE_ARM_IO + 0x206;
u8 idx[4] = { 0xff, 0xff, 0xff, 0xff }; u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
if (!request_region(base, 8, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
DRV_NAME, base, base + 7);
return -EBUSY;
}
if (!request_region(ctl, 1, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
DRV_NAME, ctl);
release_region(base, 8);
return -EBUSY;
}
memset(&hw, 0, sizeof(hw)); memset(&hw, 0, sizeof(hw));
ide_std_init_ports(&hw, IDE_ARM_IO, IDE_ARM_IO + 0x206); ide_std_init_ports(&hw, base, ctl);
hw.irq = IDE_ARM_IRQ; hw.irq = IDE_ARM_IRQ;
hwif = ide_find_port(); hwif = ide_find_port();

28
drivers/ide/arm/palm_bk3710.c
View file

@ -317,17 +317,31 @@ static u8 __devinit palm_bk3710_cable_detect(ide_hwif_t *hwif)
return ATA_CBL_PATA80; return ATA_CBL_PATA80;
} }
static void __devinit palm_bk3710_init_hwif(ide_hwif_t *hwif) static int __devinit palm_bk3710_init_dma(ide_hwif_t *hwif,
const struct ide_port_info *d)
{ {
hwif->set_pio_mode = palm_bk3710_set_pio_mode; unsigned long base =
hwif->set_dma_mode = palm_bk3710_set_dma_mode; hwif->io_ports[IDE_DATA_OFFSET] - IDE_PALM_ATA_PRI_REG_OFFSET;
hwif->cable_detect = palm_bk3710_cable_detect; printk(KERN_INFO " %s: MMIO-DMA\n", hwif->name);
if (ide_allocate_dma_engine(hwif))
return -1;
ide_setup_dma(hwif, base);
return 0;
} }
static const struct ide_port_ops palm_bk3710_ports_ops = {
.set_pio_mode = palm_bk3710_set_pio_mode,
.set_dma_mode = palm_bk3710_set_dma_mode,
.cable_detect = palm_bk3710_cable_detect,
};
static const struct ide_port_info __devinitdata palm_bk3710_port_info = { static const struct ide_port_info __devinitdata palm_bk3710_port_info = {
.init_hwif = palm_bk3710_init_hwif, .init_dma = palm_bk3710_init_dma,
.host_flags = IDE_HFLAG_NO_DMA, /* hack (no PCI) */ .port_ops = &palm_bk3710_ports_ops,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.udma_mask = ATA_UDMA4, /* (input clk 99MHz) */ .udma_mask = ATA_UDMA4, /* (input clk 99MHz) */
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -394,8 +408,6 @@ static int __devinit palm_bk3710_probe(struct platform_device *pdev)
hwif->mmio = 1; hwif->mmio = 1;
default_hwif_mmiops(hwif); default_hwif_mmiops(hwif);
ide_setup_dma(hwif, mem->start);
idx[0] = i; idx[0] = i;
ide_device_add(idx, &palm_bk3710_port_info); ide_device_add(idx, &palm_bk3710_port_info);

1
drivers/ide/arm/rapide.c
View file

@ -53,7 +53,6 @@ rapide_probe(struct expansion_card *ec, const struct ecard_id *id)
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
default_hwif_mmiops(hwif); default_hwif_mmiops(hwif);
idx[0] = hwif->index; idx[0] = hwif->index;

33
drivers/ide/cris/ide-cris.c
View file

@ -673,11 +673,6 @@ cris_ide_inb(unsigned long reg)
return (unsigned char)cris_ide_inw(reg); return (unsigned char)cris_ide_inw(reg);
} }
static int cris_dma_end (ide_drive_t *drive);
static int cris_dma_setup (ide_drive_t *drive);
static void cris_dma_exec_cmd (ide_drive_t *drive, u8 command);
static int cris_dma_test_irq(ide_drive_t *drive);
static void cris_dma_start(ide_drive_t *drive);
static void cris_ide_input_data (ide_drive_t *drive, void *, unsigned int); static void cris_ide_input_data (ide_drive_t *drive, void *, unsigned int);
static void cris_ide_output_data (ide_drive_t *drive, void *, unsigned int); static void cris_ide_output_data (ide_drive_t *drive, void *, unsigned int);
static void cris_atapi_input_bytes(ide_drive_t *drive, void *, unsigned int); static void cris_atapi_input_bytes(ide_drive_t *drive, void *, unsigned int);
@ -782,8 +777,17 @@ static void __init cris_setup_ports(hw_regs_t *hw, unsigned long base)
hw->ack_intr = cris_ide_ack_intr; hw->ack_intr = cris_ide_ack_intr;
} }
static const struct ide_port_ops cris_port_ops = {
.set_pio_mode = cris_set_pio_mode,
.set_dma_mode = cris_set_dma_mode,
};
static const struct ide_dma_ops cris_dma_ops;
static const struct ide_port_info cris_port_info __initdata = { static const struct ide_port_info cris_port_info __initdata = {
.chipset = ide_etrax100, .chipset = ide_etrax100,
.port_ops = &cris_port_ops,
.dma_ops = &cris_dma_ops,
.host_flags = IDE_HFLAG_NO_ATAPI_DMA | .host_flags = IDE_HFLAG_NO_ATAPI_DMA |
IDE_HFLAG_NO_DMA, /* no SFF-style DMA */ IDE_HFLAG_NO_DMA, /* no SFF-style DMA */
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
@ -809,19 +813,11 @@ static int __init init_e100_ide(void)
continue; continue;
ide_init_port_data(hwif, hwif->index); ide_init_port_data(hwif, hwif->index);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
hwif->set_pio_mode = &cris_set_pio_mode;
hwif->set_dma_mode = &cris_set_dma_mode;
hwif->ata_input_data = &cris_ide_input_data; hwif->ata_input_data = &cris_ide_input_data;
hwif->ata_output_data = &cris_ide_output_data; hwif->ata_output_data = &cris_ide_output_data;
hwif->atapi_input_bytes = &cris_atapi_input_bytes; hwif->atapi_input_bytes = &cris_atapi_input_bytes;
hwif->atapi_output_bytes = &cris_atapi_output_bytes; hwif->atapi_output_bytes = &cris_atapi_output_bytes;
hwif->dma_host_set = &cris_dma_host_set;
hwif->ide_dma_end = &cris_dma_end;
hwif->dma_setup = &cris_dma_setup;
hwif->dma_exec_cmd = &cris_dma_exec_cmd;
hwif->ide_dma_test_irq = &cris_dma_test_irq;
hwif->dma_start = &cris_dma_start;
hwif->OUTB = &cris_ide_outb; hwif->OUTB = &cris_ide_outb;
hwif->OUTW = &cris_ide_outw; hwif->OUTW = &cris_ide_outw;
hwif->OUTBSYNC = &cris_ide_outbsync; hwif->OUTBSYNC = &cris_ide_outbsync;
@ -1076,6 +1072,15 @@ static void cris_dma_start(ide_drive_t *drive)
} }
} }
static const struct ide_dma_ops cris_dma_ops = {
.dma_host_set = cris_dma_host_set,
.dma_setup = cris_dma_setup,
.dma_exec_cmd = cris_dma_exec_cmd,
.dma_start = cris_dma_start,
.dma_end = cris_dma_end,
.dma_test_irq = cris_dma_test_irq,
};
module_init(init_e100_ide); module_init(init_e100_ide);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

1
drivers/ide/h8300/ide-h8300.c
View file

@ -74,7 +74,6 @@ static inline void hwif_setup(ide_hwif_t *hwif)
{ {
default_hwif_iops(hwif); default_hwif_iops(hwif);
hwif->mmio = 1;
hwif->OUTW = mm_outw; hwif->OUTW = mm_outw;
hwif->OUTSW = mm_outsw; hwif->OUTSW = mm_outsw;
hwif->INW = mm_inw; hwif->INW = mm_inw;

12
drivers/ide/ide-acpi.c
View file

@ -55,7 +55,7 @@ struct ide_acpi_hwif_link {
/* note: adds function name and KERN_DEBUG */ /* note: adds function name and KERN_DEBUG */
#ifdef DEBUGGING #ifdef DEBUGGING
#define DEBPRINT(fmt, args...) \ #define DEBPRINT(fmt, args...) \
printk(KERN_DEBUG "%s: " fmt, __FUNCTION__, ## args) printk(KERN_DEBUG "%s: " fmt, __func__, ## args)
#else #else
#define DEBPRINT(fmt, args...) do {} while (0) #define DEBPRINT(fmt, args...) do {} while (0)
#endif /* DEBUGGING */ #endif /* DEBUGGING */
@ -309,7 +309,7 @@ static int do_drive_get_GTF(ide_drive_t *drive,
if (ACPI_FAILURE(status)) { if (ACPI_FAILURE(status)) {
printk(KERN_DEBUG printk(KERN_DEBUG
"%s: Run _GTF error: status = 0x%x\n", "%s: Run _GTF error: status = 0x%x\n",
__FUNCTION__, status); __func__, status);
goto out; goto out;
} }
@ -335,7 +335,7 @@ static int do_drive_get_GTF(ide_drive_t *drive,
out_obj->buffer.length % REGS_PER_GTF) { out_obj->buffer.length % REGS_PER_GTF) {
printk(KERN_ERR printk(KERN_ERR
"%s: unexpected GTF length (%d) or addr (0x%p)\n", "%s: unexpected GTF length (%d) or addr (0x%p)\n",
__FUNCTION__, out_obj->buffer.length, __func__, out_obj->buffer.length,
out_obj->buffer.pointer); out_obj->buffer.pointer);
err = -ENOENT; err = -ENOENT;
kfree(output.pointer); kfree(output.pointer);
@ -384,7 +384,7 @@ static int taskfile_load_raw(ide_drive_t *drive,
err = ide_no_data_taskfile(drive, &args); err = ide_no_data_taskfile(drive, &args);
if (err) if (err)
printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n", printk(KERN_ERR "%s: ide_no_data_taskfile failed: %u\n",
__FUNCTION__, err); __func__, err);
return err; return err;
} }
@ -422,7 +422,7 @@ static int do_drive_set_taskfiles(ide_drive_t *drive,
if (gtf_length % REGS_PER_GTF) { if (gtf_length % REGS_PER_GTF) {
printk(KERN_ERR "%s: unexpected GTF length (%d)\n", printk(KERN_ERR "%s: unexpected GTF length (%d)\n",
__FUNCTION__, gtf_length); __func__, gtf_length);
goto out; goto out;
} }
@ -547,7 +547,7 @@ void ide_acpi_get_timing(ide_hwif_t *hwif)
printk(KERN_ERR printk(KERN_ERR
"%s: unexpected _GTM length (0x%x)[should be 0x%zx] or " "%s: unexpected _GTM length (0x%x)[should be 0x%zx] or "
"addr (0x%p)\n", "addr (0x%p)\n",
__FUNCTION__, out_obj->buffer.length, __func__, out_obj->buffer.length,
sizeof(struct GTM_buffer), out_obj->buffer.pointer); sizeof(struct GTM_buffer), out_obj->buffer.pointer);
return; return;
} }

585
drivers/ide/ide-cd.c
View file

File diff suppressed because it is too large Load diff

138
drivers/ide/ide-dma.c
View file

@ -102,7 +102,7 @@ ide_startstop_t ide_dma_intr (ide_drive_t *drive)
{ {
u8 stat = 0, dma_stat = 0; u8 stat = 0, dma_stat = 0;
dma_stat = HWIF(drive)->ide_dma_end(drive); dma_stat = drive->hwif->dma_ops->dma_end(drive);
stat = ide_read_status(drive); stat = ide_read_status(drive);
if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) { if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
@ -394,7 +394,7 @@ void ide_dma_off_quietly(ide_drive_t *drive)
drive->using_dma = 0; drive->using_dma = 0;
ide_toggle_bounce(drive, 0); ide_toggle_bounce(drive, 0);
drive->hwif->dma_host_set(drive, 0); drive->hwif->dma_ops->dma_host_set(drive, 0);
} }
EXPORT_SYMBOL(ide_dma_off_quietly); EXPORT_SYMBOL(ide_dma_off_quietly);
@ -427,7 +427,7 @@ void ide_dma_on(ide_drive_t *drive)
drive->using_dma = 1; drive->using_dma = 1;
ide_toggle_bounce(drive, 1); ide_toggle_bounce(drive, 1);
drive->hwif->dma_host_set(drive, 1); drive->hwif->dma_ops->dma_host_set(drive, 1);
} }
#ifdef CONFIG_BLK_DEV_IDEDMA_SFF #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
@ -482,11 +482,12 @@ int ide_dma_setup(ide_drive_t *drive)
EXPORT_SYMBOL_GPL(ide_dma_setup); EXPORT_SYMBOL_GPL(ide_dma_setup);
static void ide_dma_exec_cmd(ide_drive_t *drive, u8 command) void ide_dma_exec_cmd(ide_drive_t *drive, u8 command)
{ {
/* issue cmd to drive */ /* issue cmd to drive */
ide_execute_command(drive, command, &ide_dma_intr, 2*WAIT_CMD, dma_timer_expiry); ide_execute_command(drive, command, &ide_dma_intr, 2*WAIT_CMD, dma_timer_expiry);
} }
EXPORT_SYMBOL_GPL(ide_dma_exec_cmd);
void ide_dma_start(ide_drive_t *drive) void ide_dma_start(ide_drive_t *drive)
{ {
@ -532,7 +533,7 @@ int __ide_dma_end (ide_drive_t *drive)
EXPORT_SYMBOL(__ide_dma_end); EXPORT_SYMBOL(__ide_dma_end);
/* returns 1 if dma irq issued, 0 otherwise */ /* returns 1 if dma irq issued, 0 otherwise */
static int __ide_dma_test_irq(ide_drive_t *drive) int ide_dma_test_irq(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
u8 dma_stat = hwif->INB(hwif->dma_status); u8 dma_stat = hwif->INB(hwif->dma_status);
@ -542,9 +543,10 @@ static int __ide_dma_test_irq(ide_drive_t *drive)
return 1; return 1;
if (!drive->waiting_for_dma) if (!drive->waiting_for_dma)
printk(KERN_WARNING "%s: (%s) called while not waiting\n", printk(KERN_WARNING "%s: (%s) called while not waiting\n",
drive->name, __FUNCTION__); drive->name, __func__);
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(ide_dma_test_irq);
#else #else
static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; } static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; }
#endif /* CONFIG_BLK_DEV_IDEDMA_SFF */ #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
@ -574,6 +576,7 @@ static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode)
{ {
struct hd_driveid *id = drive->id; struct hd_driveid *id = drive->id;
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
unsigned int mask = 0; unsigned int mask = 0;
switch(base) { switch(base) {
@ -581,8 +584,8 @@ static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode)
if ((id->field_valid & 4) == 0) if ((id->field_valid & 4) == 0)
break; break;
if (hwif->udma_filter) if (port_ops && port_ops->udma_filter)
mask = hwif->udma_filter(drive); mask = port_ops->udma_filter(drive);
else else
mask = hwif->ultra_mask; mask = hwif->ultra_mask;
mask &= id->dma_ultra; mask &= id->dma_ultra;
@ -598,8 +601,8 @@ static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode)
case XFER_MW_DMA_0: case XFER_MW_DMA_0:
if ((id->field_valid & 2) == 0) if ((id->field_valid & 2) == 0)
break; break;
if (hwif->mdma_filter) if (port_ops && port_ops->mdma_filter)
mask = hwif->mdma_filter(drive); mask = port_ops->mdma_filter(drive);
else else
mask = hwif->mwdma_mask; mask = hwif->mwdma_mask;
mask &= id->dma_mword; mask &= id->dma_mword;
@ -801,15 +804,15 @@ void ide_dma_timeout (ide_drive_t *drive)
printk(KERN_ERR "%s: timeout waiting for DMA\n", drive->name); printk(KERN_ERR "%s: timeout waiting for DMA\n", drive->name);
if (hwif->ide_dma_test_irq(drive)) if (hwif->dma_ops->dma_test_irq(drive))
return; return;
hwif->ide_dma_end(drive); hwif->dma_ops->dma_end(drive);
} }
EXPORT_SYMBOL(ide_dma_timeout); EXPORT_SYMBOL(ide_dma_timeout);
static void ide_release_dma_engine(ide_hwif_t *hwif) void ide_release_dma_engine(ide_hwif_t *hwif)
{ {
if (hwif->dmatable_cpu) { if (hwif->dmatable_cpu) {
struct pci_dev *pdev = to_pci_dev(hwif->dev); struct pci_dev *pdev = to_pci_dev(hwif->dev);
@ -820,28 +823,7 @@ static void ide_release_dma_engine(ide_hwif_t *hwif)
} }
} }
static int ide_release_iomio_dma(ide_hwif_t *hwif) int ide_allocate_dma_engine(ide_hwif_t *hwif)
{
release_region(hwif->dma_base, 8);
if (hwif->extra_ports)
release_region(hwif->extra_base, hwif->extra_ports);
return 1;
}
/*
* Needed for allowing full modular support of ide-driver
*/
int ide_release_dma(ide_hwif_t *hwif)
{
ide_release_dma_engine(hwif);
if (hwif->mmio)
return 1;
else
return ide_release_iomio_dma(hwif);
}
static int ide_allocate_dma_engine(ide_hwif_t *hwif)
{ {
struct pci_dev *pdev = to_pci_dev(hwif->dev); struct pci_dev *pdev = to_pci_dev(hwif->dev);
@ -853,65 +835,25 @@ static int ide_allocate_dma_engine(ide_hwif_t *hwif)
return 0; return 0;
printk(KERN_ERR "%s: -- Error, unable to allocate DMA table.\n", printk(KERN_ERR "%s: -- Error, unable to allocate DMA table.\n",
hwif->cds->name); hwif->name);
return 1; return 1;
} }
EXPORT_SYMBOL_GPL(ide_allocate_dma_engine);
static int ide_mapped_mmio_dma(ide_hwif_t *hwif, unsigned long base) static const struct ide_dma_ops sff_dma_ops = {
{ .dma_host_set = ide_dma_host_set,
printk(KERN_INFO " %s: MMIO-DMA ", hwif->name); .dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
return 0; .dma_start = ide_dma_start,
} .dma_end = __ide_dma_end,
.dma_test_irq = ide_dma_test_irq,
static int ide_iomio_dma(ide_hwif_t *hwif, unsigned long base) .dma_timeout = ide_dma_timeout,
{ .dma_lost_irq = ide_dma_lost_irq,
printk(KERN_INFO " %s: BM-DMA at 0x%04lx-0x%04lx", };
hwif->name, base, base + 7);
if (!request_region(base, 8, hwif->name)) {
printk(" -- Error, ports in use.\n");
return 1;
}
if (hwif->cds->extra) {
hwif->extra_base = base + (hwif->channel ? 8 : 16);
if (!hwif->mate || !hwif->mate->extra_ports) {
if (!request_region(hwif->extra_base,
hwif->cds->extra, hwif->cds->name)) {
printk(" -- Error, extra ports in use.\n");
release_region(base, 8);
return 1;
}
hwif->extra_ports = hwif->cds->extra;
}
}
return 0;
}
static int ide_dma_iobase(ide_hwif_t *hwif, unsigned long base)
{
if (hwif->mmio)
return ide_mapped_mmio_dma(hwif, base);
return ide_iomio_dma(hwif, base);
}
void ide_setup_dma(ide_hwif_t *hwif, unsigned long base) void ide_setup_dma(ide_hwif_t *hwif, unsigned long base)
{ {
u8 dma_stat;
if (ide_dma_iobase(hwif, base))
return;
if (ide_allocate_dma_engine(hwif)) {
ide_release_dma(hwif);
return;
}
hwif->dma_base = base; hwif->dma_base = base;
if (!hwif->dma_command) if (!hwif->dma_command)
@ -925,27 +867,7 @@ void ide_setup_dma(ide_hwif_t *hwif, unsigned long base)
if (!hwif->dma_prdtable) if (!hwif->dma_prdtable)
hwif->dma_prdtable = hwif->dma_base + 4; hwif->dma_prdtable = hwif->dma_base + 4;
if (!hwif->dma_host_set) hwif->dma_ops = &sff_dma_ops;
hwif->dma_host_set = &ide_dma_host_set;
if (!hwif->dma_setup)
hwif->dma_setup = &ide_dma_setup;
if (!hwif->dma_exec_cmd)
hwif->dma_exec_cmd = &ide_dma_exec_cmd;
if (!hwif->dma_start)
hwif->dma_start = &ide_dma_start;
if (!hwif->ide_dma_end)
hwif->ide_dma_end = &__ide_dma_end;
if (!hwif->ide_dma_test_irq)
hwif->ide_dma_test_irq = &__ide_dma_test_irq;
if (!hwif->dma_timeout)
hwif->dma_timeout = &ide_dma_timeout;
if (!hwif->dma_lost_irq)
hwif->dma_lost_irq = &ide_dma_lost_irq;
dma_stat = hwif->INB(hwif->dma_status);
printk(KERN_CONT ", BIOS settings: %s:%s, %s:%s\n",
hwif->drives[0].name, (dma_stat & 0x20) ? "DMA" : "PIO",
hwif->drives[1].name, (dma_stat & 0x40) ? "DMA" : "PIO");
} }
EXPORT_SYMBOL_GPL(ide_setup_dma); EXPORT_SYMBOL_GPL(ide_setup_dma);

6
drivers/ide/ide-floppy.c
View file

@ -411,7 +411,7 @@ static ide_startstop_t idefloppy_pc_intr(ide_drive_t *drive)
debug_log("Reached %s interrupt handler\n", __func__); debug_log("Reached %s interrupt handler\n", __func__);
if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
dma_error = hwif->ide_dma_end(drive); dma_error = hwif->dma_ops->dma_end(drive);
if (dma_error) { if (dma_error) {
printk(KERN_ERR "%s: DMA %s error\n", drive->name, printk(KERN_ERR "%s: DMA %s error\n", drive->name,
rq_data_dir(rq) ? "write" : "read"); rq_data_dir(rq) ? "write" : "read");
@ -663,7 +663,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
dma = 0; dma = 0;
if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma) if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma)
dma = !hwif->dma_setup(drive); dma = !hwif->dma_ops->dma_setup(drive);
ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK | ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |
IDE_TFLAG_OUT_DEVICE, bcount, dma); IDE_TFLAG_OUT_DEVICE, bcount, dma);
@ -671,7 +671,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
if (dma) { if (dma) {
/* Begin DMA, if necessary */ /* Begin DMA, if necessary */
pc->flags |= PC_FLAG_DMA_IN_PROGRESS; pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
hwif->dma_start(drive); hwif->dma_ops->dma_start(drive);
} }
/* Can we transfer the packet when we get the interrupt or wait? */ /* Can we transfer the packet when we get the interrupt or wait? */

20
drivers/ide/ide-generic.c
View file

@ -94,7 +94,24 @@ static int __init ide_generic_init(void)
unsigned long io_addr = ide_default_io_base(i); unsigned long io_addr = ide_default_io_base(i);
hw_regs_t hw; hw_regs_t hw;
idx[i] = 0xff;
if (io_addr) { if (io_addr) {
if (!request_region(io_addr, 8, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX "
"not free.\n",
DRV_NAME, io_addr, io_addr + 7);
continue;
}
if (!request_region(io_addr + 0x206, 1, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX "
"not free.\n",
DRV_NAME, io_addr + 0x206);
release_region(io_addr, 8);
continue;
}
/* /*
* Skip probing if the corresponding * Skip probing if the corresponding
* slot is already occupied. * slot is already occupied.
@ -111,8 +128,7 @@ static int __init ide_generic_init(void)
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
idx[i] = i; idx[i] = i;
} else }
idx[i] = 0xff;
} }
ide_device_add_all(idx, NULL); ide_device_add_all(idx, NULL);

13
drivers/ide/ide-io.c
View file

@ -218,7 +218,7 @@ static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *
* we could be smarter and check for current xfer_speed * we could be smarter and check for current xfer_speed
* in struct drive etc... * in struct drive etc...
*/ */
if (drive->hwif->dma_host_set == NULL) if (drive->hwif->dma_ops == NULL)
break; break;
/* /*
* TODO: respect ->using_dma setting * TODO: respect ->using_dma setting
@ -721,6 +721,7 @@ static ide_startstop_t do_special (ide_drive_t *drive)
#endif #endif
if (s->b.set_tune) { if (s->b.set_tune) {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
u8 req_pio = drive->tune_req; u8 req_pio = drive->tune_req;
s->b.set_tune = 0; s->b.set_tune = 0;
@ -733,10 +734,10 @@ static ide_startstop_t do_special (ide_drive_t *drive)
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&ide_lock, flags); spin_lock_irqsave(&ide_lock, flags);
hwif->set_pio_mode(drive, req_pio); port_ops->set_pio_mode(drive, req_pio);
spin_unlock_irqrestore(&ide_lock, flags); spin_unlock_irqrestore(&ide_lock, flags);
} else } else
hwif->set_pio_mode(drive, req_pio); port_ops->set_pio_mode(drive, req_pio);
} else { } else {
int keep_dma = drive->using_dma; int keep_dma = drive->using_dma;
@ -1237,12 +1238,12 @@ static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
if (error < 0) { if (error < 0) {
printk(KERN_WARNING "%s: DMA timeout error\n", drive->name); printk(KERN_WARNING "%s: DMA timeout error\n", drive->name);
(void)HWIF(drive)->ide_dma_end(drive); (void)hwif->dma_ops->dma_end(drive);
ret = ide_error(drive, "dma timeout error", ret = ide_error(drive, "dma timeout error",
ide_read_status(drive)); ide_read_status(drive));
} else { } else {
printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name); printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name);
hwif->dma_timeout(drive); hwif->dma_ops->dma_timeout(drive);
} }
/* /*
@ -1354,7 +1355,7 @@ void ide_timer_expiry (unsigned long data)
startstop = handler(drive); startstop = handler(drive);
} else if (drive_is_ready(drive)) { } else if (drive_is_ready(drive)) {
if (drive->waiting_for_dma) if (drive->waiting_for_dma)
hwgroup->hwif->dma_lost_irq(drive); hwif->dma_ops->dma_lost_irq(drive);
(void)ide_ack_intr(hwif); (void)ide_ack_intr(hwif);
printk(KERN_WARNING "%s: lost interrupt\n", drive->name); printk(KERN_WARNING "%s: lost interrupt\n", drive->name);
startstop = handler(drive); startstop = handler(drive);

38
drivers/ide/ide-iops.c
View file

@ -159,17 +159,20 @@ EXPORT_SYMBOL(default_hwif_mmiops);
void SELECT_DRIVE (ide_drive_t *drive) void SELECT_DRIVE (ide_drive_t *drive)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
if (hwif->selectproc) if (port_ops && port_ops->selectproc)
hwif->selectproc(drive); port_ops->selectproc(drive);
hwif->OUTB(drive->select.all, hwif->io_ports[IDE_SELECT_OFFSET]); hwif->OUTB(drive->select.all, hwif->io_ports[IDE_SELECT_OFFSET]);
} }
void SELECT_MASK (ide_drive_t *drive, int mask) void SELECT_MASK (ide_drive_t *drive, int mask)
{ {
if (HWIF(drive)->maskproc) const struct ide_port_ops *port_ops = drive->hwif->port_ops;
HWIF(drive)->maskproc(drive, mask);
if (port_ops && port_ops->maskproc)
port_ops->maskproc(drive, mask);
} }
/* /*
@ -429,7 +432,7 @@ int drive_is_ready (ide_drive_t *drive)
u8 stat = 0; u8 stat = 0;
if (drive->waiting_for_dma) if (drive->waiting_for_dma)
return hwif->ide_dma_test_irq(drive); return hwif->dma_ops->dma_test_irq(drive);
#if 0 #if 0
/* need to guarantee 400ns since last command was issued */ /* need to guarantee 400ns since last command was issued */
@ -700,8 +703,8 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
// msleep(50); // msleep(50);
#ifdef CONFIG_BLK_DEV_IDEDMA #ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_host_set) /* check if host supports DMA */ if (hwif->dma_ops) /* check if host supports DMA */
hwif->dma_host_set(drive, 0); hwif->dma_ops->dma_host_set(drive, 0);
#endif #endif
/* Skip setting PIO flow-control modes on pre-EIDE drives */ /* Skip setting PIO flow-control modes on pre-EIDE drives */
@ -759,8 +762,8 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
#ifdef CONFIG_BLK_DEV_IDEDMA #ifdef CONFIG_BLK_DEV_IDEDMA
if ((speed >= XFER_SW_DMA_0 || (hwif->host_flags & IDE_HFLAG_VDMA)) && if ((speed >= XFER_SW_DMA_0 || (hwif->host_flags & IDE_HFLAG_VDMA)) &&
drive->using_dma) drive->using_dma)
hwif->dma_host_set(drive, 1); hwif->dma_ops->dma_host_set(drive, 1);
else if (hwif->dma_host_set) /* check if host supports DMA */ else if (hwif->dma_ops) /* check if host supports DMA */
ide_dma_off_quietly(drive); ide_dma_off_quietly(drive);
#endif #endif
@ -905,10 +908,11 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
{ {
ide_hwgroup_t *hwgroup = HWGROUP(drive); ide_hwgroup_t *hwgroup = HWGROUP(drive);
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
const struct ide_port_ops *port_ops = hwif->port_ops;
u8 tmp; u8 tmp;
if (hwif->reset_poll != NULL) { if (port_ops && port_ops->reset_poll) {
if (hwif->reset_poll(drive)) { if (port_ops->reset_poll(drive)) {
printk(KERN_ERR "%s: host reset_poll failure for %s.\n", printk(KERN_ERR "%s: host reset_poll failure for %s.\n",
hwif->name, drive->name); hwif->name, drive->name);
return ide_stopped; return ide_stopped;
@ -974,6 +978,8 @@ static void ide_disk_pre_reset(ide_drive_t *drive)
static void pre_reset(ide_drive_t *drive) static void pre_reset(ide_drive_t *drive)
{ {
const struct ide_port_ops *port_ops = drive->hwif->port_ops;
if (drive->media == ide_disk) if (drive->media == ide_disk)
ide_disk_pre_reset(drive); ide_disk_pre_reset(drive);
else else
@ -994,8 +1000,8 @@ static void pre_reset(ide_drive_t *drive)
return; return;
} }
if (HWIF(drive)->pre_reset != NULL) if (port_ops && port_ops->pre_reset)
HWIF(drive)->pre_reset(drive); port_ops->pre_reset(drive);
if (drive->current_speed != 0xff) if (drive->current_speed != 0xff)
drive->desired_speed = drive->current_speed; drive->desired_speed = drive->current_speed;
@ -1023,6 +1029,7 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
unsigned long flags; unsigned long flags;
ide_hwif_t *hwif; ide_hwif_t *hwif;
ide_hwgroup_t *hwgroup; ide_hwgroup_t *hwgroup;
const struct ide_port_ops *port_ops;
u8 ctl; u8 ctl;
spin_lock_irqsave(&ide_lock, flags); spin_lock_irqsave(&ide_lock, flags);
@ -1089,8 +1096,9 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
* state when the disks are reset this way. At least, the Winbond * state when the disks are reset this way. At least, the Winbond
* 553 documentation says that * 553 documentation says that
*/ */
if (hwif->resetproc) port_ops = hwif->port_ops;
hwif->resetproc(drive); if (port_ops && port_ops->resetproc)
port_ops->resetproc(drive);
spin_unlock_irqrestore(&ide_lock, flags); spin_unlock_irqrestore(&ide_lock, flags);
return ide_started; return ide_started;

26
drivers/ide/ide-lib.c
View file

@ -85,7 +85,7 @@ static u8 ide_rate_filter(ide_drive_t *drive, u8 speed)
mode = XFER_PIO_4; mode = XFER_PIO_4;
} }
// printk("%s: mode 0x%02x, speed 0x%02x\n", __FUNCTION__, mode, speed); /* printk("%s: mode 0x%02x, speed 0x%02x\n", __func__, mode, speed); */
return min(speed, mode); return min(speed, mode);
} }
@ -288,9 +288,10 @@ EXPORT_SYMBOL_GPL(ide_get_best_pio_mode);
void ide_set_pio(ide_drive_t *drive, u8 req_pio) void ide_set_pio(ide_drive_t *drive, u8 req_pio)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
u8 host_pio, pio; u8 host_pio, pio;
if (hwif->set_pio_mode == NULL || if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
(hwif->host_flags & IDE_HFLAG_NO_SET_MODE)) (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
return; return;
@ -343,29 +344,30 @@ void ide_toggle_bounce(ide_drive_t *drive, int on)
int ide_set_pio_mode(ide_drive_t *drive, const u8 mode) int ide_set_pio_mode(ide_drive_t *drive, const u8 mode)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE) if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
return 0; return 0;
if (hwif->set_pio_mode == NULL) if (port_ops == NULL || port_ops->set_pio_mode == NULL)
return -1; return -1;
/* /*
* TODO: temporary hack for some legacy host drivers that didn't * TODO: temporary hack for some legacy host drivers that didn't
* set transfer mode on the device in ->set_pio_mode method... * set transfer mode on the device in ->set_pio_mode method...
*/ */
if (hwif->set_dma_mode == NULL) { if (port_ops->set_dma_mode == NULL) {
hwif->set_pio_mode(drive, mode - XFER_PIO_0); port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
return 0; return 0;
} }
if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) { if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
if (ide_config_drive_speed(drive, mode)) if (ide_config_drive_speed(drive, mode))
return -1; return -1;
hwif->set_pio_mode(drive, mode - XFER_PIO_0); port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
return 0; return 0;
} else { } else {
hwif->set_pio_mode(drive, mode - XFER_PIO_0); port_ops->set_pio_mode(drive, mode - XFER_PIO_0);
return ide_config_drive_speed(drive, mode); return ide_config_drive_speed(drive, mode);
} }
} }
@ -373,20 +375,21 @@ int ide_set_pio_mode(ide_drive_t *drive, const u8 mode)
int ide_set_dma_mode(ide_drive_t *drive, const u8 mode) int ide_set_dma_mode(ide_drive_t *drive, const u8 mode)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE) if (hwif->host_flags & IDE_HFLAG_NO_SET_MODE)
return 0; return 0;
if (hwif->set_dma_mode == NULL) if (port_ops == NULL || port_ops->set_dma_mode == NULL)
return -1; return -1;
if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) { if (hwif->host_flags & IDE_HFLAG_POST_SET_MODE) {
if (ide_config_drive_speed(drive, mode)) if (ide_config_drive_speed(drive, mode))
return -1; return -1;
hwif->set_dma_mode(drive, mode); port_ops->set_dma_mode(drive, mode);
return 0; return 0;
} else { } else {
hwif->set_dma_mode(drive, mode); port_ops->set_dma_mode(drive, mode);
return ide_config_drive_speed(drive, mode); return ide_config_drive_speed(drive, mode);
} }
} }
@ -406,8 +409,9 @@ EXPORT_SYMBOL_GPL(ide_set_dma_mode);
int ide_set_xfer_rate(ide_drive_t *drive, u8 rate) int ide_set_xfer_rate(ide_drive_t *drive, u8 rate)
{ {
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
if (hwif->set_dma_mode == NULL || if (port_ops == NULL || port_ops->set_dma_mode == NULL ||
(hwif->host_flags & IDE_HFLAG_NO_SET_MODE)) (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
return -1; return -1;

28
drivers/ide/ide-pnp.c
View file

@ -18,6 +18,8 @@
#include <linux/pnp.h> #include <linux/pnp.h>
#include <linux/ide.h> #include <linux/ide.h>
#define DRV_NAME "ide-pnp"
/* Add your devices here :)) */ /* Add your devices here :)) */
static struct pnp_device_id idepnp_devices[] = { static struct pnp_device_id idepnp_devices[] = {
/* Generic ESDI/IDE/ATA compatible hard disk controller */ /* Generic ESDI/IDE/ATA compatible hard disk controller */
@ -29,13 +31,29 @@ static int idepnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
{ {
hw_regs_t hw; hw_regs_t hw;
ide_hwif_t *hwif; ide_hwif_t *hwif;
unsigned long base, ctl;
if (!(pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) && pnp_irq_valid(dev, 0))) if (!(pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) && pnp_irq_valid(dev, 0)))
return -1; return -1;
base = pnp_port_start(dev, 0);
ctl = pnp_port_start(dev, 1);
if (!request_region(base, 8, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
DRV_NAME, base, base + 7);
return -EBUSY;
}
if (!request_region(ctl, 1, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
DRV_NAME, ctl);
release_region(base, 8);
return -EBUSY;
}
memset(&hw, 0, sizeof(hw)); memset(&hw, 0, sizeof(hw));
ide_std_init_ports(&hw, pnp_port_start(dev, 0), ide_std_init_ports(&hw, base, ctl);
pnp_port_start(dev, 1));
hw.irq = pnp_irq(dev, 0); hw.irq = pnp_irq(dev, 0);
hwif = ide_find_port(); hwif = ide_find_port();
@ -54,6 +72,9 @@ static int idepnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
return 0; return 0;
} }
release_region(ctl, 1);
release_region(base, 8);
return -1; return -1;
} }
@ -65,6 +86,9 @@ static void idepnp_remove(struct pnp_dev *dev)
ide_unregister(hwif->index); ide_unregister(hwif->index);
else else
printk(KERN_ERR "idepnp: Unable to remove device, please report.\n"); printk(KERN_ERR "idepnp: Unable to remove device, please report.\n");
release_region(pnp_port_start(dev, 1), 1);
release_region(pnp_port_start(dev, 0), 8);
} }
static struct pnp_driver idepnp_driver = { static struct pnp_driver idepnp_driver = {

164
drivers/ide/ide-probe.c
View file

@ -644,7 +644,7 @@ static int ide_register_port(ide_hwif_t *hwif)
ret = device_register(&hwif->gendev); ret = device_register(&hwif->gendev);
if (ret < 0) { if (ret < 0) {
printk(KERN_WARNING "IDE: %s: device_register error: %d\n", printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
__FUNCTION__, ret); __func__, ret);
goto out; goto out;
} }
@ -773,8 +773,7 @@ static int ide_probe_port(ide_hwif_t *hwif)
BUG_ON(hwif->present); BUG_ON(hwif->present);
if (hwif->noprobe || if (hwif->drives[0].noprobe && hwif->drives[1].noprobe)
(hwif->drives[0].noprobe && hwif->drives[1].noprobe))
return -EACCES; return -EACCES;
/* /*
@ -821,13 +820,14 @@ static int ide_probe_port(ide_hwif_t *hwif)
static void ide_port_tune_devices(ide_hwif_t *hwif) static void ide_port_tune_devices(ide_hwif_t *hwif)
{ {
const struct ide_port_ops *port_ops = hwif->port_ops;
int unit; int unit;
for (unit = 0; unit < MAX_DRIVES; unit++) { for (unit = 0; unit < MAX_DRIVES; unit++) {
ide_drive_t *drive = &hwif->drives[unit]; ide_drive_t *drive = &hwif->drives[unit];
if (drive->present && hwif->quirkproc) if (drive->present && port_ops && port_ops->quirkproc)
hwif->quirkproc(drive); port_ops->quirkproc(drive);
} }
for (unit = 0; unit < MAX_DRIVES; ++unit) { for (unit = 0; unit < MAX_DRIVES; ++unit) {
@ -843,7 +843,7 @@ static void ide_port_tune_devices(ide_hwif_t *hwif)
drive->nice1 = 1; drive->nice1 = 1;
if (hwif->dma_host_set) if (hwif->dma_ops)
ide_set_dma(drive); ide_set_dma(drive);
} }
} }
@ -1324,6 +1324,7 @@ static void hwif_register_devices(ide_hwif_t *hwif)
static void ide_port_init_devices(ide_hwif_t *hwif) static void ide_port_init_devices(ide_hwif_t *hwif)
{ {
const struct ide_port_ops *port_ops = hwif->port_ops;
int i; int i;
for (i = 0; i < MAX_DRIVES; i++) { for (i = 0; i < MAX_DRIVES; i++) {
@ -1339,8 +1340,8 @@ static void ide_port_init_devices(ide_hwif_t *hwif)
drive->autotune = 1; drive->autotune = 1;
} }
if (hwif->port_init_devs) if (port_ops && port_ops->port_init_devs)
hwif->port_init_devs(hwif); port_ops->port_init_devs(hwif);
} }
static void ide_init_port(ide_hwif_t *hwif, unsigned int port, static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
@ -1355,9 +1356,6 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
if (d->init_iops) if (d->init_iops)
d->init_iops(hwif); d->init_iops(hwif);
if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0)
ide_hwif_setup_dma(hwif, d);
if ((!hwif->irq && (d->host_flags & IDE_HFLAG_LEGACY_IRQS)) || if ((!hwif->irq && (d->host_flags & IDE_HFLAG_LEGACY_IRQS)) ||
(d->host_flags & IDE_HFLAG_FORCE_LEGACY_IRQS)) (d->host_flags & IDE_HFLAG_FORCE_LEGACY_IRQS))
hwif->irq = port ? 15 : 14; hwif->irq = port ? 15 : 14;
@ -1365,16 +1363,36 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
hwif->host_flags = d->host_flags; hwif->host_flags = d->host_flags;
hwif->pio_mask = d->pio_mask; hwif->pio_mask = d->pio_mask;
if ((d->host_flags & IDE_HFLAG_SERIALIZE) && hwif->mate) /* ->set_pio_mode for DTC2278 is currently limited to port 0 */
hwif->mate->serialized = hwif->serialized = 1; if (hwif->chipset != ide_dtc2278 || hwif->channel == 0)
hwif->port_ops = d->port_ops;
if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base)) {
if (hwif->mate)
hwif->mate->serialized = hwif->serialized = 1;
}
hwif->swdma_mask = d->swdma_mask; hwif->swdma_mask = d->swdma_mask;
hwif->mwdma_mask = d->mwdma_mask; hwif->mwdma_mask = d->mwdma_mask;
hwif->ultra_mask = d->udma_mask; hwif->ultra_mask = d->udma_mask;
/* reset DMA masks only for SFF-style DMA controllers */ if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0 && hwif->dma_base == 0) int rc;
hwif->swdma_mask = hwif->mwdma_mask = hwif->ultra_mask = 0;
if (d->init_dma)
rc = d->init_dma(hwif, d);
else
rc = ide_hwif_setup_dma(hwif, d);
if (rc < 0) {
printk(KERN_INFO "%s: DMA disabled\n", hwif->name);
hwif->swdma_mask = 0;
hwif->mwdma_mask = 0;
hwif->ultra_mask = 0;
} else if (d->dma_ops)
hwif->dma_ops = d->dma_ops;
}
if (d->host_flags & IDE_HFLAG_RQSIZE_256) if (d->host_flags & IDE_HFLAG_RQSIZE_256)
hwif->rqsize = 256; hwif->rqsize = 256;
@ -1386,9 +1404,11 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
static void ide_port_cable_detect(ide_hwif_t *hwif) static void ide_port_cable_detect(ide_hwif_t *hwif)
{ {
if (hwif->cable_detect && (hwif->ultra_mask & 0x78)) { const struct ide_port_ops *port_ops = hwif->port_ops;
if (port_ops && port_ops->cable_detect && (hwif->ultra_mask & 0x78)) {
if (hwif->cbl != ATA_CBL_PATA40_SHORT) if (hwif->cbl != ATA_CBL_PATA40_SHORT)
hwif->cbl = hwif->cable_detect(hwif); hwif->cbl = port_ops->cable_detect(hwif);
} }
} }
@ -1523,25 +1543,15 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
hwif = &ide_hwifs[idx[i]]; hwif = &ide_hwifs[idx[i]];
if ((hwif->chipset != ide_4drives || !hwif->mate || if (ide_probe_port(hwif) == 0)
!hwif->mate->present) && ide_hwif_request_regions(hwif)) { hwif->present = 1;
printk(KERN_ERR "%s: ports already in use, "
"skipping probe\n", hwif->name);
continue;
}
if (ide_probe_port(hwif) < 0) {
ide_hwif_release_regions(hwif);
continue;
}
hwif->present = 1;
if (hwif->chipset != ide_4drives || !hwif->mate || if (hwif->chipset != ide_4drives || !hwif->mate ||
!hwif->mate->present) !hwif->mate->present)
ide_register_port(hwif); ide_register_port(hwif);
ide_port_tune_devices(hwif); if (hwif->present)
ide_port_tune_devices(hwif);
} }
for (i = 0; i < MAX_HWIFS; i++) { for (i = 0; i < MAX_HWIFS; i++) {
@ -1550,9 +1560,6 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
hwif = &ide_hwifs[idx[i]]; hwif = &ide_hwifs[idx[i]];
if (!hwif->present)
continue;
if (hwif_init(hwif) == 0) { if (hwif_init(hwif) == 0) {
printk(KERN_INFO "%s: failed to initialize IDE " printk(KERN_INFO "%s: failed to initialize IDE "
"interface\n", hwif->name); "interface\n", hwif->name);
@ -1561,10 +1568,13 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
continue; continue;
} }
ide_port_setup_devices(hwif); if (hwif->present)
ide_port_setup_devices(hwif);
ide_acpi_init(hwif); ide_acpi_init(hwif);
ide_acpi_port_init_devices(hwif);
if (hwif->present)
ide_acpi_port_init_devices(hwif);
} }
for (i = 0; i < MAX_HWIFS; i++) { for (i = 0; i < MAX_HWIFS; i++) {
@ -1573,11 +1583,11 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
hwif = &ide_hwifs[idx[i]]; hwif = &ide_hwifs[idx[i]];
if (hwif->present) { if (hwif->chipset == ide_unknown)
if (hwif->chipset == ide_unknown) hwif->chipset = ide_generic;
hwif->chipset = ide_generic;
if (hwif->present)
hwif_register_devices(hwif); hwif_register_devices(hwif);
}
} }
for (i = 0; i < MAX_HWIFS; i++) { for (i = 0; i < MAX_HWIFS; i++) {
@ -1586,11 +1596,11 @@ int ide_device_add_all(u8 *idx, const struct ide_port_info *d)
hwif = &ide_hwifs[idx[i]]; hwif = &ide_hwifs[idx[i]];
if (hwif->present) { ide_sysfs_register_port(hwif);
ide_sysfs_register_port(hwif); ide_proc_register_port(hwif);
ide_proc_register_port(hwif);
if (hwif->present)
ide_proc_port_register_devices(hwif); ide_proc_port_register_devices(hwif);
}
} }
return rc; return rc;
@ -1626,3 +1636,67 @@ void ide_port_scan(ide_hwif_t *hwif)
ide_proc_port_register_devices(hwif); ide_proc_port_register_devices(hwif);
} }
EXPORT_SYMBOL_GPL(ide_port_scan); EXPORT_SYMBOL_GPL(ide_port_scan);
static void ide_legacy_init_one(u8 *idx, hw_regs_t *hw, u8 port_no,
const struct ide_port_info *d,
unsigned long config)
{
ide_hwif_t *hwif;
unsigned long base, ctl;
int irq;
if (port_no == 0) {
base = 0x1f0;
ctl = 0x3f6;
irq = 14;
} else {
base = 0x170;
ctl = 0x376;
irq = 15;
}
if (!request_region(base, 8, d->name)) {
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
d->name, base, base + 7);
return;
}
if (!request_region(ctl, 1, d->name)) {
printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
d->name, ctl);
release_region(base, 8);
return;
}
ide_std_init_ports(hw, base, ctl);
hw->irq = irq;
hwif = ide_find_port_slot(d);
if (hwif) {
ide_init_port_hw(hwif, hw);
if (config)
hwif->config_data = config;
idx[port_no] = hwif->index;
}
}
int ide_legacy_device_add(const struct ide_port_info *d, unsigned long config)
{
u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
hw_regs_t hw[2];
memset(&hw, 0, sizeof(hw));
if ((d->host_flags & IDE_HFLAG_QD_2ND_PORT) == 0)
ide_legacy_init_one(idx, &hw[0], 0, d, config);
ide_legacy_init_one(idx, &hw[1], 1, d, config);
if (idx[0] == 0xff && idx[1] == 0xff &&
(d->host_flags & IDE_HFLAG_SINGLE))
return -ENOENT;
ide_device_add(idx, d);
return 0;
}
EXPORT_SYMBOL_GPL(ide_legacy_device_add);

6
drivers/ide/ide-proc.c
View file

@ -599,14 +599,14 @@ static int ide_replace_subdriver(ide_drive_t *drive, const char *driver)
err = device_attach(dev); err = device_attach(dev);
if (err < 0) if (err < 0)
printk(KERN_WARNING "IDE: %s: device_attach error: %d\n", printk(KERN_WARNING "IDE: %s: device_attach error: %d\n",
__FUNCTION__, err); __func__, err);
drive->driver_req[0] = 0; drive->driver_req[0] = 0;
if (dev->driver == NULL) { if (dev->driver == NULL) {
err = device_attach(dev); err = device_attach(dev);
if (err < 0) if (err < 0)
printk(KERN_WARNING printk(KERN_WARNING
"IDE: %s: device_attach(2) error: %d\n", "IDE: %s: device_attach(2) error: %d\n",
__FUNCTION__, err); __func__, err);
} }
if (dev->driver && !strcmp(dev->driver->name, driver)) if (dev->driver && !strcmp(dev->driver->name, driver))
ret = 0; ret = 0;
@ -820,7 +820,7 @@ static int ide_drivers_show(struct seq_file *s, void *p)
err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver); err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver);
if (err < 0) if (err < 0)
printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n", printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n",
__FUNCTION__, err); __func__, err);
return 0; return 0;
} }

2
drivers/ide/ide-scan-pci.c
View file

@ -102,7 +102,7 @@ static int __init ide_scan_pcibus(void)
if (__pci_register_driver(d, d->driver.owner, if (__pci_register_driver(d, d->driver.owner,
d->driver.mod_name)) d->driver.mod_name))
printk(KERN_ERR "%s: failed to register %s driver\n", printk(KERN_ERR "%s: failed to register %s driver\n",
__FUNCTION__, d->driver.mod_name); __func__, d->driver.mod_name);
} }
return 0; return 0;

35
drivers/ide/ide-tape.c
View file

@ -993,7 +993,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive)
stat = ide_read_status(drive); stat = ide_read_status(drive);
if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
if (hwif->ide_dma_end(drive) || (stat & ERR_STAT)) { if (hwif->dma_ops->dma_end(drive) || (stat & ERR_STAT)) {
/* /*
* A DMA error is sometimes expected. For example, * A DMA error is sometimes expected. For example,
* if the tape is crossing a filemark during a * if the tape is crossing a filemark during a
@ -1213,7 +1213,7 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive)
#ifdef CONFIG_BLK_DEV_IDEDMA #ifdef CONFIG_BLK_DEV_IDEDMA
/* Begin DMA, if necessary */ /* Begin DMA, if necessary */
if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) if (pc->flags & PC_FLAG_DMA_IN_PROGRESS)
hwif->dma_start(drive); hwif->dma_ops->dma_start(drive);
#endif #endif
/* Send the actual packet */ /* Send the actual packet */
HWIF(drive)->atapi_output_bytes(drive, pc->c, 12); HWIF(drive)->atapi_output_bytes(drive, pc->c, 12);
@ -1279,7 +1279,7 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive,
ide_dma_off(drive); ide_dma_off(drive);
} }
if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma) if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma)
dma_ok = !hwif->dma_setup(drive); dma_ok = !hwif->dma_ops->dma_setup(drive);
ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK | ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |
IDE_TFLAG_OUT_DEVICE, bcount, dma_ok); IDE_TFLAG_OUT_DEVICE, bcount, dma_ok);
@ -1605,14 +1605,6 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
} }
/* Pipeline related functions */ /* Pipeline related functions */
static inline int idetape_pipeline_active(idetape_tape_t *tape)
{
int rc1, rc2;
rc1 = test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);
rc2 = (tape->active_data_rq != NULL);
return rc1;
}
/* /*
* The function below uses __get_free_page to allocate a pipeline stage, along * The function below uses __get_free_page to allocate a pipeline stage, along
@ -2058,7 +2050,7 @@ static int __idetape_discard_read_pipeline(ide_drive_t *drive)
spin_lock_irqsave(&tape->lock, flags); spin_lock_irqsave(&tape->lock, flags);
tape->next_stage = NULL; tape->next_stage = NULL;
if (idetape_pipeline_active(tape)) if (test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags))
idetape_wait_for_request(drive, tape->active_data_rq); idetape_wait_for_request(drive, tape->active_data_rq);
spin_unlock_irqrestore(&tape->lock, flags); spin_unlock_irqrestore(&tape->lock, flags);
@ -2131,7 +2123,7 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks,
debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd); debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd);
if (idetape_pipeline_active(tape)) { if (test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags)) {
printk(KERN_ERR "ide-tape: bug: the pipeline is active in %s\n", printk(KERN_ERR "ide-tape: bug: the pipeline is active in %s\n",
__func__); __func__);
return (0); return (0);
@ -2162,8 +2154,7 @@ static void idetape_plug_pipeline(ide_drive_t *drive)
if (tape->next_stage == NULL) if (tape->next_stage == NULL)
return; return;
if (!idetape_pipeline_active(tape)) { if (!test_and_set_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags)) {
set_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);
idetape_activate_next_stage(drive); idetape_activate_next_stage(drive);
(void) ide_do_drive_cmd(drive, tape->active_data_rq, ide_end); (void) ide_do_drive_cmd(drive, tape->active_data_rq, ide_end);
} }
@ -2242,13 +2233,14 @@ static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks)
/* Attempt to allocate a new stage. Beware possible race conditions. */ /* Attempt to allocate a new stage. Beware possible race conditions. */
while ((new_stage = idetape_kmalloc_stage(tape)) == NULL) { while ((new_stage = idetape_kmalloc_stage(tape)) == NULL) {
spin_lock_irqsave(&tape->lock, flags); spin_lock_irqsave(&tape->lock, flags);
if (idetape_pipeline_active(tape)) { if (test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags)) {
idetape_wait_for_request(drive, tape->active_data_rq); idetape_wait_for_request(drive, tape->active_data_rq);
spin_unlock_irqrestore(&tape->lock, flags); spin_unlock_irqrestore(&tape->lock, flags);
} else { } else {
spin_unlock_irqrestore(&tape->lock, flags); spin_unlock_irqrestore(&tape->lock, flags);
idetape_plug_pipeline(drive); idetape_plug_pipeline(drive);
if (idetape_pipeline_active(tape)) if (test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE,
&tape->flags))
continue; continue;
/* /*
* The machine is short on memory. Fallback to non- * The machine is short on memory. Fallback to non-
@ -2277,7 +2269,7 @@ static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks)
* starting to service requests, so that we will be able to keep up with * starting to service requests, so that we will be able to keep up with
* the higher speeds of the tape. * the higher speeds of the tape.
*/ */
if (!idetape_pipeline_active(tape)) { if (!test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags)) {
if (tape->nr_stages >= tape->max_stages * 9 / 10 || if (tape->nr_stages >= tape->max_stages * 9 / 10 ||
tape->nr_stages >= tape->max_stages - tape->nr_stages >= tape->max_stages -
tape->uncontrolled_pipeline_head_speed * 3 * 1024 / tape->uncontrolled_pipeline_head_speed * 3 * 1024 /
@ -2304,10 +2296,11 @@ static void idetape_wait_for_pipeline(ide_drive_t *drive)
idetape_tape_t *tape = drive->driver_data; idetape_tape_t *tape = drive->driver_data;
unsigned long flags; unsigned long flags;
while (tape->next_stage || idetape_pipeline_active(tape)) { while (tape->next_stage || test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE,
&tape->flags)) {
idetape_plug_pipeline(drive); idetape_plug_pipeline(drive);
spin_lock_irqsave(&tape->lock, flags); spin_lock_irqsave(&tape->lock, flags);
if (idetape_pipeline_active(tape)) if (test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags))
idetape_wait_for_request(drive, tape->active_data_rq); idetape_wait_for_request(drive, tape->active_data_rq);
spin_unlock_irqrestore(&tape->lock, flags); spin_unlock_irqrestore(&tape->lock, flags);
} }
@ -2464,7 +2457,7 @@ static int idetape_init_read(ide_drive_t *drive, int max_stages)
new_stage = idetape_kmalloc_stage(tape); new_stage = idetape_kmalloc_stage(tape);
} }
} }
if (!idetape_pipeline_active(tape)) { if (!test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags)) {
if (tape->nr_pending_stages >= 3 * max_stages / 4) { if (tape->nr_pending_stages >= 3 * max_stages / 4) {
tape->measure_insert_time = 1; tape->measure_insert_time = 1;
tape->insert_time = jiffies; tape->insert_time = jiffies;

19
drivers/ide/ide-taskfile.c
View file

@ -135,6 +135,7 @@ ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
struct ide_taskfile *tf = &task->tf; struct ide_taskfile *tf = &task->tf;
ide_handler_t *handler = NULL; ide_handler_t *handler = NULL;
const struct ide_dma_ops *dma_ops = hwif->dma_ops;
if (task->data_phase == TASKFILE_MULTI_IN || if (task->data_phase == TASKFILE_MULTI_IN ||
task->data_phase == TASKFILE_MULTI_OUT) { task->data_phase == TASKFILE_MULTI_OUT) {
@ -178,10 +179,10 @@ ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
return ide_started; return ide_started;
default: default:
if (task_dma_ok(task) == 0 || drive->using_dma == 0 || if (task_dma_ok(task) == 0 || drive->using_dma == 0 ||
hwif->dma_setup(drive)) dma_ops->dma_setup(drive))
return ide_stopped; return ide_stopped;
hwif->dma_exec_cmd(drive, tf->command); dma_ops->dma_exec_cmd(drive, tf->command);
hwif->dma_start(drive); dma_ops->dma_start(drive);
return ide_started; return ide_started;
} }
} }
@ -455,7 +456,7 @@ static ide_startstop_t task_in_intr(ide_drive_t *drive)
/* Error? */ /* Error? */
if (stat & ERR_STAT) if (stat & ERR_STAT)
return task_error(drive, rq, __FUNCTION__, stat); return task_error(drive, rq, __func__, stat);
/* Didn't want any data? Odd. */ /* Didn't want any data? Odd. */
if (!(stat & DRQ_STAT)) if (!(stat & DRQ_STAT))
@ -467,7 +468,7 @@ static ide_startstop_t task_in_intr(ide_drive_t *drive)
if (!hwif->nleft) { if (!hwif->nleft) {
stat = wait_drive_not_busy(drive); stat = wait_drive_not_busy(drive);
if (!OK_STAT(stat, 0, BAD_STAT)) if (!OK_STAT(stat, 0, BAD_STAT))
return task_error(drive, rq, __FUNCTION__, stat); return task_error(drive, rq, __func__, stat);
task_end_request(drive, rq, stat); task_end_request(drive, rq, stat);
return ide_stopped; return ide_stopped;
} }
@ -488,11 +489,11 @@ static ide_startstop_t task_out_intr (ide_drive_t *drive)
u8 stat = ide_read_status(drive); u8 stat = ide_read_status(drive);
if (!OK_STAT(stat, DRIVE_READY, drive->bad_wstat)) if (!OK_STAT(stat, DRIVE_READY, drive->bad_wstat))
return task_error(drive, rq, __FUNCTION__, stat); return task_error(drive, rq, __func__, stat);
/* Deal with unexpected ATA data phase. */ /* Deal with unexpected ATA data phase. */
if (((stat & DRQ_STAT) == 0) ^ !hwif->nleft) if (((stat & DRQ_STAT) == 0) ^ !hwif->nleft)
return task_error(drive, rq, __FUNCTION__, stat); return task_error(drive, rq, __func__, stat);
if (!hwif->nleft) { if (!hwif->nleft) {
task_end_request(drive, rq, stat); task_end_request(drive, rq, stat);
@ -675,7 +676,7 @@ int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
/* (hs): give up if multcount is not set */ /* (hs): give up if multcount is not set */
printk(KERN_ERR "%s: %s Multimode Write " \ printk(KERN_ERR "%s: %s Multimode Write " \
"multcount is not set\n", "multcount is not set\n",
drive->name, __FUNCTION__); drive->name, __func__);
err = -EPERM; err = -EPERM;
goto abort; goto abort;
} }
@ -692,7 +693,7 @@ int ide_taskfile_ioctl (ide_drive_t *drive, unsigned int cmd, unsigned long arg)
/* (hs): give up if multcount is not set */ /* (hs): give up if multcount is not set */
printk(KERN_ERR "%s: %s Multimode Read failure " \ printk(KERN_ERR "%s: %s Multimode Read failure " \
"multcount is not set\n", "multcount is not set\n",
drive->name, __FUNCTION__); drive->name, __func__);
err = -EPERM; err = -EPERM;
goto abort; goto abort;
} }

86
drivers/ide/ide.c
View file

@ -227,79 +227,6 @@ static int ide_system_bus_speed(void)
return pci_dev_present(pci_default) ? 33 : 50; return pci_dev_present(pci_default) ? 33 : 50;
} }
static struct resource* hwif_request_region(ide_hwif_t *hwif,
unsigned long addr, int num)
{
struct resource *res = request_region(addr, num, hwif->name);
if (!res)
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
hwif->name, addr, addr+num-1);
return res;
}
/**
* ide_hwif_request_regions - request resources for IDE
* @hwif: interface to use
*
* Requests all the needed resources for an interface.
* Right now core IDE code does this work which is deeply wrong.
* MMIO leaves it to the controller driver,
* PIO will migrate this way over time.
*/
int ide_hwif_request_regions(ide_hwif_t *hwif)
{
unsigned long addr;
if (hwif->mmio)
return 0;
addr = hwif->io_ports[IDE_CONTROL_OFFSET];
if (addr && !hwif_request_region(hwif, addr, 1))
goto control_region_busy;
addr = hwif->io_ports[IDE_DATA_OFFSET];
BUG_ON((addr | 7) != hwif->io_ports[IDE_STATUS_OFFSET]);
if (!hwif_request_region(hwif, addr, 8))
goto data_region_busy;
return 0;
data_region_busy:
addr = hwif->io_ports[IDE_CONTROL_OFFSET];
if (addr)
release_region(addr, 1);
control_region_busy:
/* If any errors are return, we drop the hwif interface. */
return -EBUSY;
}
/**
* ide_hwif_release_regions - free IDE resources
*
* Note that we only release the standard ports,
* and do not even try to handle any extra ports
* allocated for weird IDE interface chipsets.
*
* Note also that we don't yet handle mmio resources here. More
* importantly our caller should be doing this so we need to
* restructure this as a helper function for drivers.
*/
void ide_hwif_release_regions(ide_hwif_t *hwif)
{
if (hwif->mmio)
return;
if (hwif->io_ports[IDE_CONTROL_OFFSET])
release_region(hwif->io_ports[IDE_CONTROL_OFFSET], 1);
release_region(hwif->io_ports[IDE_DATA_OFFSET], 8);
}
void ide_remove_port_from_hwgroup(ide_hwif_t *hwif) void ide_remove_port_from_hwgroup(ide_hwif_t *hwif)
{ {
ide_hwgroup_t *hwgroup = hwif->hwgroup; ide_hwgroup_t *hwgroup = hwif->hwgroup;
@ -436,9 +363,7 @@ void ide_unregister(unsigned int index)
spin_lock_irq(&ide_lock); spin_lock_irq(&ide_lock);
if (hwif->dma_base) if (hwif->dma_base)
(void)ide_release_dma(hwif); ide_release_dma_engine(hwif);
ide_hwif_release_regions(hwif);
/* restore hwif data to pristine status */ /* restore hwif data to pristine status */
ide_init_port_data(hwif, index); ide_init_port_data(hwif, index);
@ -454,7 +379,6 @@ void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw)
{ {
memcpy(hwif->io_ports, hw->io_ports, sizeof(hwif->io_ports)); memcpy(hwif->io_ports, hw->io_ports, sizeof(hwif->io_ports));
hwif->irq = hw->irq; hwif->irq = hw->irq;
hwif->noprobe = 0;
hwif->chipset = hw->chipset; hwif->chipset = hw->chipset;
hwif->gendev.parent = hw->dev; hwif->gendev.parent = hw->dev;
hwif->ack_intr = hw->ack_intr; hwif->ack_intr = hw->ack_intr;
@ -545,7 +469,7 @@ int set_using_dma(ide_drive_t *drive, int arg)
if (!drive->id || !(drive->id->capability & 1)) if (!drive->id || !(drive->id->capability & 1))
goto out; goto out;
if (hwif->dma_host_set == NULL) if (hwif->dma_ops == NULL)
goto out; goto out;
err = -EBUSY; err = -EBUSY;
@ -585,11 +509,12 @@ int set_pio_mode(ide_drive_t *drive, int arg)
{ {
struct request rq; struct request rq;
ide_hwif_t *hwif = drive->hwif; ide_hwif_t *hwif = drive->hwif;
const struct ide_port_ops *port_ops = hwif->port_ops;
if (arg < 0 || arg > 255) if (arg < 0 || arg > 255)
return -EINVAL; return -EINVAL;
if (hwif->set_pio_mode == NULL || if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
(hwif->host_flags & IDE_HFLAG_NO_SET_MODE)) (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
return -ENOSYS; return -ENOSYS;
@ -1005,14 +930,12 @@ static int __init ide_setup(char *s)
goto done; goto done;
case -3: /* "nowerr" */ case -3: /* "nowerr" */
drive->bad_wstat = BAD_R_STAT; drive->bad_wstat = BAD_R_STAT;
hwif->noprobe = 0;
goto done; goto done;
case -4: /* "cdrom" */ case -4: /* "cdrom" */
drive->present = 1; drive->present = 1;
drive->media = ide_cdrom; drive->media = ide_cdrom;
/* an ATAPI device ignores DRDY */ /* an ATAPI device ignores DRDY */
drive->ready_stat = 0; drive->ready_stat = 0;
hwif->noprobe = 0;
goto done; goto done;
case -5: /* nodma */ case -5: /* nodma */
drive->nodma = 1; drive->nodma = 1;
@ -1043,7 +966,6 @@ static int __init ide_setup(char *s)
drive->sect = drive->bios_sect = vals[2]; drive->sect = drive->bios_sect = vals[2];
drive->present = 1; drive->present = 1;
drive->forced_geom = 1; drive->forced_geom = 1;
hwif->noprobe = 0;
goto done; goto done;
default: default:
goto bad_option; goto bad_option;

38
drivers/ide/legacy/ali14xx.c
View file

@ -49,6 +49,8 @@
#include <asm/io.h> #include <asm/io.h>
#define DRV_NAME "ali14xx"
/* port addresses for auto-detection */ /* port addresses for auto-detection */
#define ALI_NUM_PORTS 4 #define ALI_NUM_PORTS 4
static const int ports[ALI_NUM_PORTS] __initdata = static const int ports[ALI_NUM_PORTS] __initdata =
@ -192,18 +194,20 @@ static int __init initRegisters(void)
return t; return t;
} }
static const struct ide_port_ops ali14xx_port_ops = {
.set_pio_mode = ali14xx_set_pio_mode,
};
static const struct ide_port_info ali14xx_port_info = { static const struct ide_port_info ali14xx_port_info = {
.name = DRV_NAME,
.chipset = ide_ali14xx, .chipset = ide_ali14xx,
.port_ops = &ali14xx_port_ops,
.host_flags = IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_AUTOTUNE, .host_flags = IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_AUTOTUNE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
}; };
static int __init ali14xx_probe(void) static int __init ali14xx_probe(void)
{ {
ide_hwif_t *hwif, *mate;
static u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
hw_regs_t hw[2];
printk(KERN_DEBUG "ali14xx: base=0x%03x, regOn=0x%02x.\n", printk(KERN_DEBUG "ali14xx: base=0x%03x, regOn=0x%02x.\n",
basePort, regOn); basePort, regOn);
@ -213,31 +217,7 @@ static int __init ali14xx_probe(void)
return 1; return 1;
} }
memset(&hw, 0, sizeof(hw)); return ide_legacy_device_add(&ali14xx_port_info, 0);
ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
hw[0].irq = 14;
ide_std_init_ports(&hw[1], 0x170, 0x376);
hw[1].irq = 15;
hwif = ide_find_port();
if (hwif) {
ide_init_port_hw(hwif, &hw[0]);
hwif->set_pio_mode = &ali14xx_set_pio_mode;
idx[0] = hwif->index;
}
mate = ide_find_port();
if (mate) {
ide_init_port_hw(mate, &hw[1]);
mate->set_pio_mode = &ali14xx_set_pio_mode;
idx[1] = mate->index;
}
ide_device_add(idx, &ali14xx_port_info);
return 0;
} }
int probe_ali14xx; int probe_ali14xx;

2
drivers/ide/legacy/buddha.c
View file

@ -228,8 +228,6 @@ static int __init buddha_init(void)
ide_init_port_data(hwif, index); ide_init_port_data(hwif, index);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
idx[i] = index; idx[i] = index;
} }
} }

36
drivers/ide/legacy/dtc2278.c
View file

@ -16,6 +16,8 @@
#include <asm/io.h> #include <asm/io.h>
#define DRV_NAME "dtc2278"
/* /*
* Changing this #undef to #define may solve start up problems in some systems. * Changing this #undef to #define may solve start up problems in some systems.
*/ */
@ -86,8 +88,14 @@ static void dtc2278_set_pio_mode(ide_drive_t *drive, const u8 pio)
} }
} }
static const struct ide_port_ops dtc2278_port_ops = {
.set_pio_mode = dtc2278_set_pio_mode,
};
static const struct ide_port_info dtc2278_port_info __initdata = { static const struct ide_port_info dtc2278_port_info __initdata = {
.name = DRV_NAME,
.chipset = ide_dtc2278, .chipset = ide_dtc2278,
.port_ops = &dtc2278_port_ops,
.host_flags = IDE_HFLAG_SERIALIZE | .host_flags = IDE_HFLAG_SERIALIZE |
IDE_HFLAG_NO_UNMASK_IRQS | IDE_HFLAG_NO_UNMASK_IRQS |
IDE_HFLAG_IO_32BIT | IDE_HFLAG_IO_32BIT |
@ -101,9 +109,6 @@ static const struct ide_port_info dtc2278_port_info __initdata = {
static int __init dtc2278_probe(void) static int __init dtc2278_probe(void)
{ {
unsigned long flags; unsigned long flags;
ide_hwif_t *hwif, *mate;
static u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
hw_regs_t hw[2];
local_irq_save(flags); local_irq_save(flags);
/* /*
@ -123,30 +128,7 @@ static int __init dtc2278_probe(void)
#endif #endif
local_irq_restore(flags); local_irq_restore(flags);
memset(&hw, 0, sizeof(hw)); return ide_legacy_device_add(&dtc2278_port_info, 0);
ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
hw[0].irq = 14;
ide_std_init_ports(&hw[1], 0x170, 0x376);
hw[1].irq = 15;
hwif = ide_find_port();
if (hwif) {
ide_init_port_hw(hwif, &hw[0]);
hwif->set_pio_mode = dtc2278_set_pio_mode;
idx[0] = hwif->index;
}
mate = ide_find_port();
if (mate) {
ide_init_port_hw(mate, &hw[1]);
idx[1] = mate->index;
}
ide_device_add(idx, &dtc2278_port_info);
return 0;
} }
int probe_dtc2278 = 0; int probe_dtc2278 = 0;

1
drivers/ide/legacy/falconide.c
View file

@ -89,7 +89,6 @@ static int __init falconide_init(void)
ide_init_port_data(hwif, index); ide_init_port_data(hwif, index);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
ide_get_lock(NULL, NULL); ide_get_lock(NULL, NULL);
ide_device_add(idx, NULL); ide_device_add(idx, NULL);

2
drivers/ide/legacy/gayle.c
View file

@ -182,8 +182,6 @@ static int __init gayle_init(void)
ide_init_port_data(hwif, index); ide_init_port_data(hwif, index);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
idx[i] = index; idx[i] = index;
} else } else
release_mem_region(res_start, res_n); release_mem_region(res_start, res_n);

46
drivers/ide/legacy/ht6560b.c
View file

@ -328,8 +328,16 @@ int probe_ht6560b = 0;
module_param_named(probe, probe_ht6560b, bool, 0); module_param_named(probe, probe_ht6560b, bool, 0);
MODULE_PARM_DESC(probe, "probe for HT6560B chipset"); MODULE_PARM_DESC(probe, "probe for HT6560B chipset");
static const struct ide_port_ops ht6560b_port_ops = {
.port_init_devs = ht6560b_port_init_devs,
.set_pio_mode = ht6560b_set_pio_mode,
.selectproc = ht6560b_selectproc,
};
static const struct ide_port_info ht6560b_port_info __initdata = { static const struct ide_port_info ht6560b_port_info __initdata = {
.name = DRV_NAME,
.chipset = ide_ht6560b, .chipset = ide_ht6560b,
.port_ops = &ht6560b_port_ops,
.host_flags = IDE_HFLAG_SERIALIZE | /* is this needed? */ .host_flags = IDE_HFLAG_SERIALIZE | /* is this needed? */
IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_DMA |
IDE_HFLAG_NO_AUTOTUNE | IDE_HFLAG_NO_AUTOTUNE |
@ -339,53 +347,21 @@ static const struct ide_port_info ht6560b_port_info __initdata = {
static int __init ht6560b_init(void) static int __init ht6560b_init(void)
{ {
ide_hwif_t *hwif, *mate;
static u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
hw_regs_t hw[2];
if (probe_ht6560b == 0) if (probe_ht6560b == 0)
return -ENODEV; return -ENODEV;
if (!request_region(HT_CONFIG_PORT, 1, DRV_NAME)) { if (!request_region(HT_CONFIG_PORT, 1, DRV_NAME)) {
printk(KERN_NOTICE "%s: HT_CONFIG_PORT not found\n", printk(KERN_NOTICE "%s: HT_CONFIG_PORT not found\n",
__FUNCTION__); __func__);
return -ENODEV; return -ENODEV;
} }
if (!try_to_init_ht6560b()) { if (!try_to_init_ht6560b()) {
printk(KERN_NOTICE "%s: HBA not found\n", __FUNCTION__); printk(KERN_NOTICE "%s: HBA not found\n", __func__);
goto release_region; goto release_region;
} }
memset(&hw, 0, sizeof(hw)); return ide_legacy_device_add(&ht6560b_port_info, 0);
ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
hw[0].irq = 14;
ide_std_init_ports(&hw[1], 0x170, 0x376);
hw[1].irq = 15;
hwif = ide_find_port();
if (hwif) {
ide_init_port_hw(hwif, &hw[0]);
hwif->selectproc = ht6560b_selectproc;
hwif->set_pio_mode = ht6560b_set_pio_mode;
hwif->port_init_devs = ht6560b_port_init_devs;
idx[0] = hwif->index;
}
mate = ide_find_port();
if (mate) {
ide_init_port_hw(mate, &hw[1]);
mate->selectproc = ht6560b_selectproc;
mate->set_pio_mode = ht6560b_set_pio_mode;
mate->port_init_devs = ht6560b_port_init_devs;
idx[1] = mate->index;
}
ide_device_add(idx, &ht6560b_port_info);
return 0;
release_region: release_region:
release_region(HT_CONFIG_PORT, 1); release_region(HT_CONFIG_PORT, 1);

18
drivers/ide/legacy/ide-4drives.c
View file

@ -4,6 +4,8 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/ide.h> #include <linux/ide.h>
#define DRV_NAME "ide-4drives"
int probe_4drives; int probe_4drives;
module_param_named(probe, probe_4drives, bool, 0); module_param_named(probe, probe_4drives, bool, 0);
@ -12,15 +14,29 @@ MODULE_PARM_DESC(probe, "probe for generic IDE chipset with 4 drives/port");
static int __init ide_4drives_init(void) static int __init ide_4drives_init(void)
{ {
ide_hwif_t *hwif, *mate; ide_hwif_t *hwif, *mate;
unsigned long base = 0x1f0, ctl = 0x3f6;
u8 idx[4] = { 0xff, 0xff, 0xff, 0xff }; u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
hw_regs_t hw; hw_regs_t hw;
if (probe_4drives == 0) if (probe_4drives == 0)
return -ENODEV; return -ENODEV;
if (!request_region(base, 8, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
DRV_NAME, base, base + 7);
return -EBUSY;
}
if (!request_region(ctl, 1, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
DRV_NAME, ctl);
release_region(base, 8);
return -EBUSY;
}
memset(&hw, 0, sizeof(hw)); memset(&hw, 0, sizeof(hw));
ide_std_init_ports(&hw, 0x1f0, 0x3f6); ide_std_init_ports(&hw, base, ctl);
hw.irq = 14; hw.irq = 14;
hw.chipset = ide_4drives; hw.chipset = ide_4drives;

76
drivers/ide/legacy/ide-cs.c
View file

@ -51,6 +51,8 @@
#include <pcmcia/cisreg.h> #include <pcmcia/cisreg.h>
#include <pcmcia/ciscode.h> #include <pcmcia/ciscode.h>
#define DRV_NAME "ide-cs"
/*====================================================================*/ /*====================================================================*/
/* Module parameters */ /* Module parameters */
@ -72,16 +74,11 @@ static char *version =
/*====================================================================*/ /*====================================================================*/
static const char ide_major[] = {
IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR,
IDE4_MAJOR, IDE5_MAJOR
};
typedef struct ide_info_t { typedef struct ide_info_t {
struct pcmcia_device *p_dev; struct pcmcia_device *p_dev;
ide_hwif_t *hwif;
int ndev; int ndev;
dev_node_t node; dev_node_t node;
int hd;
} ide_info_t; } ide_info_t;
static void ide_release(struct pcmcia_device *); static void ide_release(struct pcmcia_device *);
@ -136,20 +133,44 @@ static int ide_probe(struct pcmcia_device *link)
static void ide_detach(struct pcmcia_device *link) static void ide_detach(struct pcmcia_device *link)
{ {
ide_info_t *info = link->priv;
ide_hwif_t *hwif = info->hwif;
DEBUG(0, "ide_detach(0x%p)\n", link); DEBUG(0, "ide_detach(0x%p)\n", link);
ide_release(link); ide_release(link);
kfree(link->priv); release_region(hwif->io_ports[IDE_CONTROL_OFFSET], 1);
release_region(hwif->io_ports[IDE_DATA_OFFSET], 8);
kfree(info);
} /* ide_detach */ } /* ide_detach */
static int idecs_register(unsigned long io, unsigned long ctl, unsigned long irq, struct pcmcia_device *handle) static const struct ide_port_ops idecs_port_ops = {
.quirkproc = ide_undecoded_slave,
};
static ide_hwif_t *idecs_register(unsigned long io, unsigned long ctl,
unsigned long irq, struct pcmcia_device *handle)
{ {
ide_hwif_t *hwif; ide_hwif_t *hwif;
hw_regs_t hw; hw_regs_t hw;
int i; int i;
u8 idx[4] = { 0xff, 0xff, 0xff, 0xff }; u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
if (!request_region(io, 8, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
DRV_NAME, io, io + 7);
return NULL;
}
if (!request_region(ctl, 1, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
DRV_NAME, ctl);
release_region(io, 8);
return NULL;
}
memset(&hw, 0, sizeof(hw)); memset(&hw, 0, sizeof(hw));
ide_std_init_ports(&hw, io, ctl); ide_std_init_ports(&hw, io, ctl);
hw.irq = irq; hw.irq = irq;
@ -158,7 +179,7 @@ static int idecs_register(unsigned long io, unsigned long ctl, unsigned long irq
hwif = ide_find_port(); hwif = ide_find_port();
if (hwif == NULL) if (hwif == NULL)
return -1; goto out_release;
i = hwif->index; i = hwif->index;
@ -168,13 +189,19 @@ static int idecs_register(unsigned long io, unsigned long ctl, unsigned long irq
ide_init_port_data(hwif, i); ide_init_port_data(hwif, i);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->quirkproc = &ide_undecoded_slave; hwif->port_ops = &idecs_port_ops;
idx[0] = i; idx[0] = i;
ide_device_add(idx, NULL); ide_device_add(idx, NULL);
return hwif->present ? i : -1; if (hwif->present)
return hwif;
out_release:
release_region(ctl, 1);
release_region(io, 8);
return NULL;
} }
/*====================================================================== /*======================================================================
@ -199,8 +226,9 @@ static int ide_config(struct pcmcia_device *link)
cistpl_cftable_entry_t dflt; cistpl_cftable_entry_t dflt;
} *stk = NULL; } *stk = NULL;
cistpl_cftable_entry_t *cfg; cistpl_cftable_entry_t *cfg;
int i, pass, last_ret = 0, last_fn = 0, hd, is_kme = 0; int i, pass, last_ret = 0, last_fn = 0, is_kme = 0;
unsigned long io_base, ctl_base; unsigned long io_base, ctl_base;
ide_hwif_t *hwif;
DEBUG(0, "ide_config(0x%p)\n", link); DEBUG(0, "ide_config(0x%p)\n", link);
@ -296,14 +324,15 @@ static int ide_config(struct pcmcia_device *link)
outb(0x81, ctl_base+1); outb(0x81, ctl_base+1);
/* retry registration in case device is still spinning up */ /* retry registration in case device is still spinning up */
for (hd = -1, i = 0; i < 10; i++) { for (i = 0; i < 10; i++) {
hd = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link); hwif = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
if (hd >= 0) break; if (hwif)
break;
if (link->io.NumPorts1 == 0x20) { if (link->io.NumPorts1 == 0x20) {
outb(0x02, ctl_base + 0x10); outb(0x02, ctl_base + 0x10);
hd = idecs_register(io_base + 0x10, ctl_base + 0x10, hwif = idecs_register(io_base + 0x10, ctl_base + 0x10,
link->irq.AssignedIRQ, link); link->irq.AssignedIRQ, link);
if (hd >= 0) { if (hwif) {
io_base += 0x10; io_base += 0x10;
ctl_base += 0x10; ctl_base += 0x10;
break; break;
@ -312,7 +341,7 @@ static int ide_config(struct pcmcia_device *link)
msleep(100); msleep(100);
} }
if (hd < 0) { if (hwif == NULL) {
printk(KERN_NOTICE "ide-cs: ide_register() at 0x%3lx & 0x%3lx" printk(KERN_NOTICE "ide-cs: ide_register() at 0x%3lx & 0x%3lx"
", irq %u failed\n", io_base, ctl_base, ", irq %u failed\n", io_base, ctl_base,
link->irq.AssignedIRQ); link->irq.AssignedIRQ);
@ -320,10 +349,10 @@ static int ide_config(struct pcmcia_device *link)
} }
info->ndev = 1; info->ndev = 1;
sprintf(info->node.dev_name, "hd%c", 'a' + (hd * 2)); sprintf(info->node.dev_name, "hd%c", 'a' + hwif->index * 2);
info->node.major = ide_major[hd]; info->node.major = hwif->major;
info->node.minor = 0; info->node.minor = 0;
info->hd = hd; info->hwif = hwif;
link->dev_node = &info->node; link->dev_node = &info->node;
printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n", printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10); info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
@ -354,13 +383,14 @@ static int ide_config(struct pcmcia_device *link)
void ide_release(struct pcmcia_device *link) void ide_release(struct pcmcia_device *link)
{ {
ide_info_t *info = link->priv; ide_info_t *info = link->priv;
ide_hwif_t *hwif = info->hwif;
DEBUG(0, "ide_release(0x%p)\n", link); DEBUG(0, "ide_release(0x%p)\n", link);
if (info->ndev) { if (info->ndev) {
/* FIXME: if this fails we need to queue the cleanup somehow /* FIXME: if this fails we need to queue the cleanup somehow
-- need to investigate the required PCMCIA magic */ -- need to investigate the required PCMCIA magic */
ide_unregister(info->hd); ide_unregister(hwif->index);
} }
info->ndev = 0; info->ndev = 0;

1
drivers/ide/legacy/ide_platform.c
View file

@ -100,7 +100,6 @@ static int __devinit plat_ide_probe(struct platform_device *pdev)
hw.dev = &pdev->dev; hw.dev = &pdev->dev;
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
if (mmio) if (mmio)
default_hwif_mmiops(hwif); default_hwif_mmiops(hwif);

2
drivers/ide/legacy/macide.c
View file

@ -128,8 +128,6 @@ static int __init macide_init(void)
ide_init_port_data(hwif, index); ide_init_port_data(hwif, index);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
ide_device_add(idx, NULL); ide_device_add(idx, NULL);
} }

1
drivers/ide/legacy/q40ide.c
View file

@ -141,7 +141,6 @@ static int __init q40ide_init(void)
if (hwif) { if (hwif) {
ide_init_port_data(hwif, hwif->index); ide_init_port_data(hwif, hwif->index);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
idx[i] = hwif->index; idx[i] = hwif->index;
} }

134
drivers/ide/legacy/qd65xx.c
View file

@ -37,6 +37,8 @@
#include <asm/system.h> #include <asm/system.h>
#include <asm/io.h> #include <asm/io.h>
#define DRV_NAME "qd65xx"
#include "qd65xx.h" #include "qd65xx.h"
/* /*
@ -304,7 +306,20 @@ static void __init qd6580_port_init_devs(ide_hwif_t *hwif)
hwif->drives[1].drive_data = t2; hwif->drives[1].drive_data = t2;
} }
static const struct ide_port_ops qd6500_port_ops = {
.port_init_devs = qd6500_port_init_devs,
.set_pio_mode = qd6500_set_pio_mode,
.selectproc = qd65xx_select,
};
static const struct ide_port_ops qd6580_port_ops = {
.port_init_devs = qd6580_port_init_devs,
.set_pio_mode = qd6580_set_pio_mode,
.selectproc = qd65xx_select,
};
static const struct ide_port_info qd65xx_port_info __initdata = { static const struct ide_port_info qd65xx_port_info __initdata = {
.name = DRV_NAME,
.chipset = ide_qd65xx, .chipset = ide_qd65xx,
.host_flags = IDE_HFLAG_IO_32BIT | .host_flags = IDE_HFLAG_IO_32BIT |
IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_DMA |
@ -321,10 +336,8 @@ static const struct ide_port_info qd65xx_port_info __initdata = {
static int __init qd_probe(int base) static int __init qd_probe(int base)
{ {
ide_hwif_t *hwif; int rc;
u8 config, unit; u8 config, unit, control;
u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
hw_regs_t hw[2];
struct ide_port_info d = qd65xx_port_info; struct ide_port_info d = qd65xx_port_info;
config = inb(QD_CONFIG_PORT); config = inb(QD_CONFIG_PORT);
@ -337,21 +350,11 @@ static int __init qd_probe(int base)
if (unit) if (unit)
d.host_flags |= IDE_HFLAG_QD_2ND_PORT; d.host_flags |= IDE_HFLAG_QD_2ND_PORT;
memset(&hw, 0, sizeof(hw)); switch (config & 0xf0) {
case QD_CONFIG_QD6500:
ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
hw[0].irq = 14;
ide_std_init_ports(&hw[1], 0x170, 0x376);
hw[1].irq = 15;
if ((config & 0xf0) == QD_CONFIG_QD6500) {
if (qd_testreg(base)) if (qd_testreg(base))
return -ENODEV; /* bad register */ return -ENODEV; /* bad register */
/* qd6500 found */
if (config & QD_CONFIG_DISABLED) { if (config & QD_CONFIG_DISABLED) {
printk(KERN_WARNING "qd6500 is disabled !\n"); printk(KERN_WARNING "qd6500 is disabled !\n");
return -ENODEV; return -ENODEV;
@ -361,37 +364,14 @@ static int __init qd_probe(int base)
printk(KERN_DEBUG "qd6500: config=%#x, ID3=%u\n", printk(KERN_DEBUG "qd6500: config=%#x, ID3=%u\n",
config, QD_ID3); config, QD_ID3);
d.port_ops = &qd6500_port_ops;
d.host_flags |= IDE_HFLAG_SINGLE; d.host_flags |= IDE_HFLAG_SINGLE;
break;
hwif = ide_find_port_slot(&d); case QD_CONFIG_QD6580_A:
if (hwif == NULL) case QD_CONFIG_QD6580_B:
return -ENOENT;
ide_init_port_hw(hwif, &hw[unit]);
hwif->config_data = (base << 8) | config;
hwif->port_init_devs = qd6500_port_init_devs;
hwif->set_pio_mode = qd6500_set_pio_mode;
hwif->selectproc = qd65xx_select;
idx[unit] = hwif->index;
ide_device_add(idx, &d);
return 1;
}
if (((config & 0xf0) == QD_CONFIG_QD6580_A) ||
((config & 0xf0) == QD_CONFIG_QD6580_B)) {
u8 control;
if (qd_testreg(base) || qd_testreg(base + 0x02)) if (qd_testreg(base) || qd_testreg(base + 0x02))
return -ENODEV; /* bad registers */ return -ENODEV; /* bad registers */
/* qd6580 found */
control = inb(QD_CONTROL_PORT); control = inb(QD_CONTROL_PORT);
printk(KERN_NOTICE "qd6580 at %#x\n", base); printk(KERN_NOTICE "qd6580 at %#x\n", base);
@ -400,63 +380,23 @@ static int __init qd_probe(int base)
outb(QD_DEF_CONTR, QD_CONTROL_PORT); outb(QD_DEF_CONTR, QD_CONTROL_PORT);
if (control & QD_CONTR_SEC_DISABLED) { d.port_ops = &qd6580_port_ops;
/* secondary disabled */ if (control & QD_CONTR_SEC_DISABLED)
printk(KERN_INFO "qd6580: single IDE board\n");
d.host_flags |= IDE_HFLAG_SINGLE; d.host_flags |= IDE_HFLAG_SINGLE;
hwif = ide_find_port_slot(&d); printk(KERN_INFO "qd6580: %s IDE board\n",
if (hwif == NULL) (control & QD_CONTR_SEC_DISABLED) ? "single" : "dual");
return -ENOENT; break;
default:
ide_init_port_hw(hwif, &hw[unit]); return -ENODEV;
hwif->config_data = (base << 8) | config;
hwif->port_init_devs = qd6580_port_init_devs;
hwif->set_pio_mode = qd6580_set_pio_mode;
hwif->selectproc = qd65xx_select;
idx[unit] = hwif->index;
ide_device_add(idx, &d);
return 1;
} else {
ide_hwif_t *mate;
/* secondary enabled */
printk(KERN_INFO "qd6580: dual IDE board\n");
hwif = ide_find_port();
if (hwif) {
ide_init_port_hw(hwif, &hw[0]);
hwif->config_data = (base << 8) | config;
hwif->port_init_devs = qd6580_port_init_devs;
hwif->set_pio_mode = qd6580_set_pio_mode;
hwif->selectproc = qd65xx_select;
idx[0] = hwif->index;
}
mate = ide_find_port();
if (mate) {
ide_init_port_hw(mate, &hw[1]);
mate->config_data = (base << 8) | config;
mate->port_init_devs = qd6580_port_init_devs;
mate->set_pio_mode = qd6580_set_pio_mode;
mate->selectproc = qd65xx_select;
idx[1] = mate->index;
}
ide_device_add(idx, &qd65xx_port_info);
return 0; /* no other qd65xx possible */
}
} }
/* no qd65xx found */
return -ENODEV; rc = ide_legacy_device_add(&d, (base << 8) | config);
if (d.host_flags & IDE_HFLAG_SINGLE)
return (rc == 0) ? 1 : rc;
return rc;
} }
int probe_qd65xx = 0; int probe_qd65xx = 0;

37
drivers/ide/legacy/umc8672.c
View file

@ -51,6 +51,8 @@
#include <asm/io.h> #include <asm/io.h>
#define DRV_NAME "umc8672"
/* /*
* Default speeds. These can be changed with "auto-tune" and/or hdparm. * Default speeds. These can be changed with "auto-tune" and/or hdparm.
*/ */
@ -120,18 +122,21 @@ static void umc_set_pio_mode(ide_drive_t *drive, const u8 pio)
spin_unlock_irqrestore(&ide_lock, flags); spin_unlock_irqrestore(&ide_lock, flags);
} }
static const struct ide_port_ops umc8672_port_ops = {
.set_pio_mode = umc_set_pio_mode,
};
static const struct ide_port_info umc8672_port_info __initdata = { static const struct ide_port_info umc8672_port_info __initdata = {
.name = DRV_NAME,
.chipset = ide_umc8672, .chipset = ide_umc8672,
.port_ops = &umc8672_port_ops,
.host_flags = IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_AUTOTUNE, .host_flags = IDE_HFLAG_NO_DMA | IDE_HFLAG_NO_AUTOTUNE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
}; };
static int __init umc8672_probe(void) static int __init umc8672_probe(void)
{ {
ide_hwif_t *hwif, *mate;
unsigned long flags; unsigned long flags;
static u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
hw_regs_t hw[2];
if (!request_region(0x108, 2, "umc8672")) { if (!request_region(0x108, 2, "umc8672")) {
printk(KERN_ERR "umc8672: ports 0x108-0x109 already in use.\n"); printk(KERN_ERR "umc8672: ports 0x108-0x109 already in use.\n");
@ -150,31 +155,7 @@ static int __init umc8672_probe(void)
umc_set_speeds(current_speeds); umc_set_speeds(current_speeds);
local_irq_restore(flags); local_irq_restore(flags);
memset(&hw, 0, sizeof(hw)); return ide_legacy_device_add(&umc8672_port_info, 0);
ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
hw[0].irq = 14;
ide_std_init_ports(&hw[1], 0x170, 0x376);
hw[1].irq = 15;
hwif = ide_find_port();
if (hwif) {
ide_init_port_hw(hwif, &hw[0]);
hwif->set_pio_mode = umc_set_pio_mode;
idx[0] = hwif->index;
}
mate = ide_find_port();
if (mate) {
ide_init_port_hw(mate, &hw[1]);
mate->set_pio_mode = umc_set_pio_mode;
idx[1] = mate->index;
}
ide_device_add(idx, &umc8672_port_info);
return 0;
} }
int probe_umc8672; int probe_umc8672;

115
drivers/ide/mips/au1xxx-ide.c
View file

@ -47,7 +47,6 @@
#define IDE_AU1XXX_BURSTMODE 1 #define IDE_AU1XXX_BURSTMODE 1
static _auide_hwif auide_hwif; static _auide_hwif auide_hwif;
static int dbdma_init_done;
static int auide_ddma_init(_auide_hwif *auide); static int auide_ddma_init(_auide_hwif *auide);
@ -61,7 +60,7 @@ void auide_insw(unsigned long port, void *addr, u32 count)
if(!put_dest_flags(ahwif->rx_chan, (void*)addr, count << 1, if(!put_dest_flags(ahwif->rx_chan, (void*)addr, count << 1,
DDMA_FLAGS_NOIE)) { DDMA_FLAGS_NOIE)) {
printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__); printk(KERN_ERR "%s failed %d\n", __func__, __LINE__);
return; return;
} }
ctp = *((chan_tab_t **)ahwif->rx_chan); ctp = *((chan_tab_t **)ahwif->rx_chan);
@ -79,7 +78,7 @@ void auide_outsw(unsigned long port, void *addr, u32 count)
if(!put_source_flags(ahwif->tx_chan, (void*)addr, if(!put_source_flags(ahwif->tx_chan, (void*)addr,
count << 1, DDMA_FLAGS_NOIE)) { count << 1, DDMA_FLAGS_NOIE)) {
printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__); printk(KERN_ERR "%s failed %d\n", __func__, __LINE__);
return; return;
} }
ctp = *((chan_tab_t **)ahwif->tx_chan); ctp = *((chan_tab_t **)ahwif->tx_chan);
@ -250,7 +249,7 @@ static int auide_build_dmatable(ide_drive_t *drive)
(void*) sg_virt(sg), (void*) sg_virt(sg),
tc, flags)) { tc, flags)) {
printk(KERN_ERR "%s failed %d\n", printk(KERN_ERR "%s failed %d\n",
__FUNCTION__, __LINE__); __func__, __LINE__);
} }
} else } else
{ {
@ -258,7 +257,7 @@ static int auide_build_dmatable(ide_drive_t *drive)
(void*) sg_virt(sg), (void*) sg_virt(sg),
tc, flags)) { tc, flags)) {
printk(KERN_ERR "%s failed %d\n", printk(KERN_ERR "%s failed %d\n",
__FUNCTION__, __LINE__); __func__, __LINE__);
} }
} }
@ -315,35 +314,6 @@ static int auide_dma_setup(ide_drive_t *drive)
return 0; return 0;
} }
static u8 auide_mdma_filter(ide_drive_t *drive)
{
/*
* FIXME: ->white_list and ->black_list are based on completely bogus
* ->ide_dma_check implementation which didn't set neither the host
* controller timings nor the device for the desired transfer mode.
*
* They should be either removed or 0x00 MWDMA mask should be
* returned for devices on the ->black_list.
*/
if (dbdma_init_done == 0) {
auide_hwif.white_list = ide_in_drive_list(drive->id,
dma_white_list);
auide_hwif.black_list = ide_in_drive_list(drive->id,
dma_black_list);
auide_hwif.drive = drive;
auide_ddma_init(&auide_hwif);
dbdma_init_done = 1;
}
/* Is the drive in our DMA black list? */
if (auide_hwif.black_list)
printk(KERN_WARNING "%s: Disabling DMA for %s (blacklisted)\n",
drive->name, drive->id->model);
return drive->hwif->mwdma_mask;
}
static int auide_dma_test_irq(ide_drive_t *drive) static int auide_dma_test_irq(ide_drive_t *drive)
{ {
if (drive->waiting_for_dma == 0) if (drive->waiting_for_dma == 0)
@ -396,41 +366,41 @@ static void auide_init_dbdma_dev(dbdev_tab_t *dev, u32 dev_id, u32 tsize, u32 de
dev->dev_devwidth = devwidth; dev->dev_devwidth = devwidth;
dev->dev_flags = flags; dev->dev_flags = flags;
} }
#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
static void auide_dma_timeout(ide_drive_t *drive) static void auide_dma_timeout(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
printk(KERN_ERR "%s: DMA timeout occurred: ", drive->name); printk(KERN_ERR "%s: DMA timeout occurred: ", drive->name);
if (hwif->ide_dma_test_irq(drive)) if (auide_dma_test_irq(drive))
return; return;
hwif->ide_dma_end(drive); auide_dma_end(drive);
} }
static int auide_ddma_init(_auide_hwif *auide) { static const struct ide_dma_ops au1xxx_dma_ops = {
.dma_host_set = auide_dma_host_set,
.dma_setup = auide_dma_setup,
.dma_exec_cmd = auide_dma_exec_cmd,
.dma_start = auide_dma_start,
.dma_end = auide_dma_end,
.dma_test_irq = auide_dma_test_irq,
.dma_lost_irq = auide_dma_lost_irq,
.dma_timeout = auide_dma_timeout,
};
static int auide_ddma_init(ide_hwif_t *hwif, const struct ide_port_info *d)
{
_auide_hwif *auide = (_auide_hwif *)hwif->hwif_data;
dbdev_tab_t source_dev_tab, target_dev_tab; dbdev_tab_t source_dev_tab, target_dev_tab;
u32 dev_id, tsize, devwidth, flags; u32 dev_id, tsize, devwidth, flags;
ide_hwif_t *hwif = auide->hwif;
dev_id = AU1XXX_ATA_DDMA_REQ; dev_id = AU1XXX_ATA_DDMA_REQ;
if (auide->white_list || auide->black_list) { tsize = 8; /* 1 */
tsize = 8; devwidth = 32; /* 16 */
devwidth = 32;
}
else {
tsize = 1;
devwidth = 16;
printk(KERN_ERR "au1xxx-ide: %s is not on ide driver whitelist.\n",auide_hwif.drive->id->model);
printk(KERN_ERR " please read 'Documentation/mips/AU1xxx_IDE.README'");
}
#ifdef IDE_AU1XXX_BURSTMODE #ifdef IDE_AU1XXX_BURSTMODE
flags = DEV_FLAGS_SYNC | DEV_FLAGS_BURSTABLE; flags = DEV_FLAGS_SYNC | DEV_FLAGS_BURSTABLE;
@ -482,9 +452,9 @@ static int auide_ddma_init(_auide_hwif *auide) {
return 0; return 0;
} }
#else #else
static int auide_ddma_init(ide_hwif_t *hwif, const struct ide_port_info *d)
static int auide_ddma_init( _auide_hwif *auide )
{ {
_auide_hwif *auide = (_auide_hwif *)hwif->hwif_data;
dbdev_tab_t source_dev_tab; dbdev_tab_t source_dev_tab;
int flags; int flags;
@ -543,9 +513,18 @@ static void auide_setup_ports(hw_regs_t *hw, _auide_hwif *ahwif)
*ata_regs = ahwif->regbase + (14 << AU1XXX_ATA_REG_OFFSET); *ata_regs = ahwif->regbase + (14 << AU1XXX_ATA_REG_OFFSET);
} }
static const struct ide_port_ops au1xxx_port_ops = {
.set_pio_mode = au1xxx_set_pio_mode,
.set_dma_mode = auide_set_dma_mode,
};
static const struct ide_port_info au1xxx_port_info = { static const struct ide_port_info au1xxx_port_info = {
.init_dma = auide_ddma_init,
.port_ops = &au1xxx_port_ops,
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
.dma_ops = &au1xxx_dma_ops,
#endif
.host_flags = IDE_HFLAG_POST_SET_MODE | .host_flags = IDE_HFLAG_POST_SET_MODE |
IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
IDE_HFLAG_NO_IO_32BIT | IDE_HFLAG_NO_IO_32BIT |
IDE_HFLAG_UNMASK_IRQS, IDE_HFLAG_UNMASK_IRQS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
@ -615,8 +594,6 @@ static int au_ide_probe(struct device *dev)
hwif->dev = dev; hwif->dev = dev;
hwif->mmio = 1;
/* If the user has selected DDMA assisted copies, /* If the user has selected DDMA assisted copies,
then set up a few local I/O function entry points then set up a few local I/O function entry points
*/ */
@ -625,34 +602,12 @@ static int au_ide_probe(struct device *dev)
hwif->INSW = auide_insw; hwif->INSW = auide_insw;
hwif->OUTSW = auide_outsw; hwif->OUTSW = auide_outsw;
#endif #endif
hwif->set_pio_mode = &au1xxx_set_pio_mode;
hwif->set_dma_mode = &auide_set_dma_mode;
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
hwif->dma_timeout = &auide_dma_timeout;
hwif->mdma_filter = &auide_mdma_filter;
hwif->dma_host_set = &auide_dma_host_set;
hwif->dma_exec_cmd = &auide_dma_exec_cmd;
hwif->dma_start = &auide_dma_start;
hwif->ide_dma_end = &auide_dma_end;
hwif->dma_setup = &auide_dma_setup;
hwif->ide_dma_test_irq = &auide_dma_test_irq;
hwif->dma_lost_irq = &auide_dma_lost_irq;
#endif
hwif->select_data = 0; /* no chipset-specific code */ hwif->select_data = 0; /* no chipset-specific code */
hwif->config_data = 0; /* no chipset-specific code */ hwif->config_data = 0; /* no chipset-specific code */
auide_hwif.hwif = hwif; auide_hwif.hwif = hwif;
hwif->hwif_data = &auide_hwif; hwif->hwif_data = &auide_hwif;
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA
auide_ddma_init(&auide_hwif);
dbdma_init_done = 1;
#endif
idx[0] = hwif->index; idx[0] = hwif->index;
ide_device_add(idx, &au1xxx_port_info); ide_device_add(idx, &au1xxx_port_info);

4
drivers/ide/mips/swarm.c
View file

@ -110,10 +110,8 @@ static int __devinit swarm_ide_probe(struct device *dev)
/* Setup MMIO ops. */ /* Setup MMIO ops. */
default_hwif_mmiops(hwif); default_hwif_mmiops(hwif);
/* Prevent resource map manipulation. */
hwif->mmio = 1;
hwif->chipset = ide_generic; hwif->chipset = ide_generic;
hwif->noprobe = 0;
for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
hwif->io_ports[i] = hwif->io_ports[i] =

34
drivers/ide/pci/aec62xx.c
View file

@ -135,7 +135,7 @@ static void aec6260_set_mode(ide_drive_t *drive, const u8 speed)
static void aec_set_pio_mode(ide_drive_t *drive, const u8 pio) static void aec_set_pio_mode(ide_drive_t *drive, const u8 pio)
{ {
drive->hwif->set_dma_mode(drive, pio + XFER_PIO_0); drive->hwif->port_ops->set_dma_mode(drive, pio + XFER_PIO_0);
} }
static unsigned int __devinit init_chipset_aec62xx(struct pci_dev *dev, const char *name) static unsigned int __devinit init_chipset_aec62xx(struct pci_dev *dev, const char *name)
@ -175,27 +175,23 @@ static u8 __devinit atp86x_cable_detect(ide_hwif_t *hwif)
return (ata66 & mask) ? ATA_CBL_PATA40 : ATA_CBL_PATA80; return (ata66 & mask) ? ATA_CBL_PATA40 : ATA_CBL_PATA80;
} }
static void __devinit init_hwif_aec62xx(ide_hwif_t *hwif) static const struct ide_port_ops atp850_port_ops = {
{ .set_pio_mode = aec_set_pio_mode,
struct pci_dev *dev = to_pci_dev(hwif->dev); .set_dma_mode = aec6210_set_mode,
};
hwif->set_pio_mode = &aec_set_pio_mode; static const struct ide_port_ops atp86x_port_ops = {
.set_pio_mode = aec_set_pio_mode,
if (dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF) .set_dma_mode = aec6260_set_mode,
hwif->set_dma_mode = &aec6210_set_mode; .cable_detect = atp86x_cable_detect,
else { };
hwif->set_dma_mode = &aec6260_set_mode;
hwif->cable_detect = atp86x_cable_detect;
}
}
static const struct ide_port_info aec62xx_chipsets[] __devinitdata = { static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "AEC6210", .name = "AEC6210",
.init_chipset = init_chipset_aec62xx, .init_chipset = init_chipset_aec62xx,
.init_hwif = init_hwif_aec62xx,
.enablebits = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}}, .enablebits = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
.port_ops = &atp850_port_ops,
.host_flags = IDE_HFLAG_SERIALIZE | .host_flags = IDE_HFLAG_SERIALIZE |
IDE_HFLAG_NO_ATAPI_DMA | IDE_HFLAG_NO_ATAPI_DMA |
IDE_HFLAG_NO_DSC | IDE_HFLAG_NO_DSC |
@ -207,7 +203,7 @@ static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
},{ /* 1 */ },{ /* 1 */
.name = "AEC6260", .name = "AEC6260",
.init_chipset = init_chipset_aec62xx, .init_chipset = init_chipset_aec62xx,
.init_hwif = init_hwif_aec62xx, .port_ops = &atp86x_port_ops,
.host_flags = IDE_HFLAG_NO_ATAPI_DMA | IDE_HFLAG_NO_AUTODMA | .host_flags = IDE_HFLAG_NO_ATAPI_DMA | IDE_HFLAG_NO_AUTODMA |
IDE_HFLAG_ABUSE_SET_DMA_MODE | IDE_HFLAG_ABUSE_SET_DMA_MODE |
IDE_HFLAG_OFF_BOARD, IDE_HFLAG_OFF_BOARD,
@ -217,8 +213,8 @@ static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
},{ /* 2 */ },{ /* 2 */
.name = "AEC6260R", .name = "AEC6260R",
.init_chipset = init_chipset_aec62xx, .init_chipset = init_chipset_aec62xx,
.init_hwif = init_hwif_aec62xx,
.enablebits = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}}, .enablebits = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
.port_ops = &atp86x_port_ops,
.host_flags = IDE_HFLAG_NO_ATAPI_DMA | .host_flags = IDE_HFLAG_NO_ATAPI_DMA |
IDE_HFLAG_ABUSE_SET_DMA_MODE | IDE_HFLAG_ABUSE_SET_DMA_MODE |
IDE_HFLAG_NON_BOOTABLE, IDE_HFLAG_NON_BOOTABLE,
@ -228,7 +224,7 @@ static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
},{ /* 3 */ },{ /* 3 */
.name = "AEC6280", .name = "AEC6280",
.init_chipset = init_chipset_aec62xx, .init_chipset = init_chipset_aec62xx,
.init_hwif = init_hwif_aec62xx, .port_ops = &atp86x_port_ops,
.host_flags = IDE_HFLAG_NO_ATAPI_DMA | .host_flags = IDE_HFLAG_NO_ATAPI_DMA |
IDE_HFLAG_ABUSE_SET_DMA_MODE | IDE_HFLAG_ABUSE_SET_DMA_MODE |
IDE_HFLAG_OFF_BOARD, IDE_HFLAG_OFF_BOARD,
@ -238,8 +234,8 @@ static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
},{ /* 4 */ },{ /* 4 */
.name = "AEC6280R", .name = "AEC6280R",
.init_chipset = init_chipset_aec62xx, .init_chipset = init_chipset_aec62xx,
.init_hwif = init_hwif_aec62xx,
.enablebits = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}}, .enablebits = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
.port_ops = &atp86x_port_ops,
.host_flags = IDE_HFLAG_NO_ATAPI_DMA | .host_flags = IDE_HFLAG_NO_ATAPI_DMA |
IDE_HFLAG_ABUSE_SET_DMA_MODE | IDE_HFLAG_ABUSE_SET_DMA_MODE |
IDE_HFLAG_OFF_BOARD, IDE_HFLAG_OFF_BOARD,

89
drivers/ide/pci/alim15x3.c
View file

@ -610,7 +610,7 @@ static int ali_cable_override(struct pci_dev *pdev)
} }
/** /**
* ata66_ali15x3 - check for UDMA 66 support * ali_cable_detect - cable detection
* @hwif: IDE interface * @hwif: IDE interface
* *
* This checks if the controller and the cable are capable * This checks if the controller and the cable are capable
@ -620,7 +620,7 @@ static int ali_cable_override(struct pci_dev *pdev)
* FIXME: frobs bits that are not defined on newer ALi devicea * FIXME: frobs bits that are not defined on newer ALi devicea
*/ */
static u8 __devinit ata66_ali15x3(ide_hwif_t *hwif) static u8 __devinit ali_cable_detect(ide_hwif_t *hwif)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
unsigned long flags; unsigned long flags;
@ -652,27 +652,7 @@ static u8 __devinit ata66_ali15x3(ide_hwif_t *hwif)
return cbl; return cbl;
} }
/** #ifndef CONFIG_SPARC64
* init_hwif_common_ali15x3 - Set up ALI IDE hardware
* @hwif: IDE interface
*
* Initialize the IDE structure side of the ALi 15x3 driver.
*/
static void __devinit init_hwif_common_ali15x3 (ide_hwif_t *hwif)
{
hwif->set_pio_mode = &ali_set_pio_mode;
hwif->set_dma_mode = &ali_set_dma_mode;
hwif->udma_filter = &ali_udma_filter;
hwif->cable_detect = ata66_ali15x3;
if (hwif->dma_base == 0)
return;
hwif->dma_setup = &ali15x3_dma_setup;
}
/** /**
* init_hwif_ali15x3 - Initialize the ALI IDE x86 stuff * init_hwif_ali15x3 - Initialize the ALI IDE x86 stuff
* @hwif: interface to configure * @hwif: interface to configure
@ -722,34 +702,66 @@ static void __devinit init_hwif_ali15x3 (ide_hwif_t *hwif)
if(irq >= 0) if(irq >= 0)
hwif->irq = irq; hwif->irq = irq;
} }
init_hwif_common_ali15x3(hwif);
} }
#endif
/** /**
* init_dma_ali15x3 - set up DMA on ALi15x3 * init_dma_ali15x3 - set up DMA on ALi15x3
* @hwif: IDE interface * @hwif: IDE interface
* @dmabase: DMA interface base PCI address * @d: IDE port info
* *
* Set up the DMA functionality on the ALi 15x3. For the ALi * Set up the DMA functionality on the ALi 15x3.
* controllers this is generic so we can let the generic code do
* the actual work.
*/ */
static void __devinit init_dma_ali15x3 (ide_hwif_t *hwif, unsigned long dmabase) static int __devinit init_dma_ali15x3(ide_hwif_t *hwif,
const struct ide_port_info *d)
{ {
if (m5229_revision < 0x20) struct pci_dev *dev = to_pci_dev(hwif->dev);
return; unsigned long base = ide_pci_dma_base(hwif, d);
if (base == 0 || ide_pci_set_master(dev, d->name) < 0)
return -1;
if (!hwif->channel) if (!hwif->channel)
outb(inb(dmabase + 2) & 0x60, dmabase + 2); outb(inb(base + 2) & 0x60, base + 2);
ide_setup_dma(hwif, dmabase);
printk(KERN_INFO " %s: BM-DMA at 0x%04lx-0x%04lx\n",
hwif->name, base, base + 7);
if (ide_allocate_dma_engine(hwif))
return -1;
ide_setup_dma(hwif, base);
return 0;
} }
static const struct ide_port_ops ali_port_ops = {
.set_pio_mode = ali_set_pio_mode,
.set_dma_mode = ali_set_dma_mode,
.udma_filter = ali_udma_filter,
.cable_detect = ali_cable_detect,
};
static const struct ide_dma_ops ali_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ali15x3_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = __ide_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
static const struct ide_port_info ali15x3_chipset __devinitdata = { static const struct ide_port_info ali15x3_chipset __devinitdata = {
.name = "ALI15X3", .name = "ALI15X3",
.init_chipset = init_chipset_ali15x3, .init_chipset = init_chipset_ali15x3,
#ifndef CONFIG_SPARC64
.init_hwif = init_hwif_ali15x3, .init_hwif = init_hwif_ali15x3,
#endif
.init_dma = init_dma_ali15x3, .init_dma = init_dma_ali15x3,
.port_ops = &ali_port_ops,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
.swdma_mask = ATA_SWDMA2, .swdma_mask = ATA_SWDMA2,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -792,14 +804,17 @@ static int __devinit alim15x3_init_one(struct pci_dev *dev, const struct pci_dev
d.udma_mask = ATA_UDMA5; d.udma_mask = ATA_UDMA5;
else else
d.udma_mask = ATA_UDMA6; d.udma_mask = ATA_UDMA6;
d.dma_ops = &ali_dma_ops;
} else {
d.host_flags |= IDE_HFLAG_NO_DMA;
d.mwdma_mask = d.swdma_mask = 0;
} }
if (idx == 0) if (idx == 0)
d.host_flags |= IDE_HFLAG_CLEAR_SIMPLEX; d.host_flags |= IDE_HFLAG_CLEAR_SIMPLEX;
#if defined(CONFIG_SPARC64)
d.init_hwif = init_hwif_common_ali15x3;
#endif /* CONFIG_SPARC64 */
return ide_setup_pci_device(dev, &d); return ide_setup_pci_device(dev, &d);
} }

13
drivers/ide/pci/amd74xx.c
View file

@ -210,13 +210,14 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
if (hwif->irq == 0) /* 0 is bogus but will do for now */ if (hwif->irq == 0) /* 0 is bogus but will do for now */
hwif->irq = pci_get_legacy_ide_irq(dev, hwif->channel); hwif->irq = pci_get_legacy_ide_irq(dev, hwif->channel);
hwif->set_pio_mode = &amd_set_pio_mode;
hwif->set_dma_mode = &amd_set_drive;
hwif->cable_detect = amd_cable_detect;
} }
static const struct ide_port_ops amd_port_ops = {
.set_pio_mode = amd_set_pio_mode,
.set_dma_mode = amd_set_drive,
.cable_detect = amd_cable_detect,
};
#define IDE_HFLAGS_AMD \ #define IDE_HFLAGS_AMD \
(IDE_HFLAG_PIO_NO_BLACKLIST | \ (IDE_HFLAG_PIO_NO_BLACKLIST | \
IDE_HFLAG_ABUSE_SET_DMA_MODE | \ IDE_HFLAG_ABUSE_SET_DMA_MODE | \
@ -230,6 +231,7 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
.init_chipset = init_chipset_amd74xx, \ .init_chipset = init_chipset_amd74xx, \
.init_hwif = init_hwif_amd74xx, \ .init_hwif = init_hwif_amd74xx, \
.enablebits = {{0x40,0x02,0x02}, {0x40,0x01,0x01}}, \ .enablebits = {{0x40,0x02,0x02}, {0x40,0x01,0x01}}, \
.port_ops = &amd_port_ops, \
.host_flags = IDE_HFLAGS_AMD, \ .host_flags = IDE_HFLAGS_AMD, \
.pio_mask = ATA_PIO5, \ .pio_mask = ATA_PIO5, \
.swdma_mask = swdma, \ .swdma_mask = swdma, \
@ -243,6 +245,7 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
.init_chipset = init_chipset_amd74xx, \ .init_chipset = init_chipset_amd74xx, \
.init_hwif = init_hwif_amd74xx, \ .init_hwif = init_hwif_amd74xx, \
.enablebits = {{0x50,0x02,0x02}, {0x50,0x01,0x01}}, \ .enablebits = {{0x50,0x02,0x02}, {0x50,0x01,0x01}}, \
.port_ops = &amd_port_ops, \
.host_flags = IDE_HFLAGS_AMD, \ .host_flags = IDE_HFLAGS_AMD, \
.pio_mask = ATA_PIO5, \ .pio_mask = ATA_PIO5, \
.swdma_mask = ATA_SWDMA2, \ .swdma_mask = ATA_SWDMA2, \

24
drivers/ide/pci/atiixp.c
View file

@ -130,35 +130,25 @@ static u8 __devinit atiixp_cable_detect(ide_hwif_t *hwif)
return ATA_CBL_PATA40; return ATA_CBL_PATA40;
} }
/** static const struct ide_port_ops atiixp_port_ops = {
* init_hwif_atiixp - fill in the hwif for the ATIIXP .set_pio_mode = atiixp_set_pio_mode,
* @hwif: IDE interface .set_dma_mode = atiixp_set_dma_mode,
* .cable_detect = atiixp_cable_detect,
* Set up the ide_hwif_t for the ATIIXP interface according to the };
* capabilities of the hardware.
*/
static void __devinit init_hwif_atiixp(ide_hwif_t *hwif)
{
hwif->set_pio_mode = &atiixp_set_pio_mode;
hwif->set_dma_mode = &atiixp_set_dma_mode;
hwif->cable_detect = atiixp_cable_detect;
}
static const struct ide_port_info atiixp_pci_info[] __devinitdata = { static const struct ide_port_info atiixp_pci_info[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "ATIIXP", .name = "ATIIXP",
.init_hwif = init_hwif_atiixp,
.enablebits = {{0x48,0x01,0x00}, {0x48,0x08,0x00}}, .enablebits = {{0x48,0x01,0x00}, {0x48,0x08,0x00}},
.port_ops = &atiixp_port_ops,
.host_flags = IDE_HFLAG_LEGACY_IRQS, .host_flags = IDE_HFLAG_LEGACY_IRQS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
.udma_mask = ATA_UDMA5, .udma_mask = ATA_UDMA5,
},{ /* 1 */ },{ /* 1 */
.name = "SB600_PATA", .name = "SB600_PATA",
.init_hwif = init_hwif_atiixp,
.enablebits = {{0x48,0x01,0x00}, {0x00,0x00,0x00}}, .enablebits = {{0x48,0x01,0x00}, {0x00,0x00,0x00}},
.port_ops = &atiixp_port_ops,
.host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_LEGACY_IRQS, .host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_LEGACY_IRQS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,

45
drivers/ide/pci/cmd640.c
View file

@ -109,6 +109,8 @@
#include <asm/io.h> #include <asm/io.h>
#define DRV_NAME "cmd640"
/* /*
* This flag is set in ide.c by the parameter: ide0=cmd640_vlb * This flag is set in ide.c by the parameter: ide0=cmd640_vlb
*/ */
@ -633,6 +635,9 @@ static void cmd640_set_pio_mode(ide_drive_t *drive, const u8 pio)
display_clocks(index); display_clocks(index);
} }
static const struct ide_port_ops cmd640_port_ops = {
.set_pio_mode = cmd640_set_pio_mode,
};
#endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */ #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
static int pci_conf1(void) static int pci_conf1(void)
@ -678,10 +683,29 @@ static const struct ide_port_info cmd640_port_info __initdata = {
IDE_HFLAG_ABUSE_PREFETCH | IDE_HFLAG_ABUSE_PREFETCH |
IDE_HFLAG_ABUSE_FAST_DEVSEL, IDE_HFLAG_ABUSE_FAST_DEVSEL,
#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
.port_ops = &cmd640_port_ops,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
#endif #endif
}; };
static int cmd640x_init_one(unsigned long base, unsigned long ctl)
{
if (!request_region(base, 8, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
DRV_NAME, base, base + 7);
return -EBUSY;
}
if (!request_region(ctl, 1, DRV_NAME)) {
printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
DRV_NAME, ctl);
release_region(base, 8);
return -EBUSY;
}
return 0;
}
/* /*
* Probe for a cmd640 chipset, and initialize it if found. * Probe for a cmd640 chipset, and initialize it if found.
*/ */
@ -690,7 +714,7 @@ static int __init cmd640x_init(void)
#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
int second_port_toggled = 0; int second_port_toggled = 0;
#endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */ #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
int second_port_cmd640 = 0; int second_port_cmd640 = 0, rc;
const char *bus_type, *port2; const char *bus_type, *port2;
unsigned int index; unsigned int index;
u8 b, cfr; u8 b, cfr;
@ -734,6 +758,17 @@ static int __init cmd640x_init(void)
return 0; return 0;
} }
rc = cmd640x_init_one(0x1f0, 0x3f6);
if (rc)
return rc;
rc = cmd640x_init_one(0x170, 0x376);
if (rc) {
release_region(0x3f6, 1);
release_region(0x1f0, 8);
return rc;
}
memset(&hw, 0, sizeof(hw)); memset(&hw, 0, sizeof(hw));
ide_std_init_ports(&hw[0], 0x1f0, 0x3f6); ide_std_init_ports(&hw[0], 0x1f0, 0x3f6);
@ -752,10 +787,6 @@ static int __init cmd640x_init(void)
*/ */
if (cmd_hwif0) { if (cmd_hwif0) {
ide_init_port_hw(cmd_hwif0, &hw[0]); ide_init_port_hw(cmd_hwif0, &hw[0]);
#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
cmd_hwif0->set_pio_mode = &cmd640_set_pio_mode;
#endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
idx[0] = cmd_hwif0->index; idx[0] = cmd_hwif0->index;
} }
@ -808,10 +839,6 @@ static int __init cmd640x_init(void)
*/ */
if (second_port_cmd640 && cmd_hwif1) { if (second_port_cmd640 && cmd_hwif1) {
ide_init_port_hw(cmd_hwif1, &hw[1]); ide_init_port_hw(cmd_hwif1, &hw[1]);
#ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
cmd_hwif1->set_pio_mode = &cmd640_set_pio_mode;
#endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
idx[1] = cmd_hwif1->index; idx[1] = cmd_hwif1->index;
} }
printk(KERN_INFO "cmd640: %sserialized, secondary interface %s\n", printk(KERN_INFO "cmd640: %sserialized, secondary interface %s\n",

138
drivers/ide/pci/cmd64x.c
View file

@ -223,7 +223,7 @@ static void cmd64x_set_dma_mode(ide_drive_t *drive, const u8 speed)
(void) pci_write_config_byte(dev, pciU, regU); (void) pci_write_config_byte(dev, pciU, regU);
} }
static int cmd648_ide_dma_end (ide_drive_t *drive) static int cmd648_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
unsigned long base = hwif->dma_base - (hwif->channel * 8); unsigned long base = hwif->dma_base - (hwif->channel * 8);
@ -239,7 +239,7 @@ static int cmd648_ide_dma_end (ide_drive_t *drive)
return err; return err;
} }
static int cmd64x_ide_dma_end (ide_drive_t *drive) static int cmd64x_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
@ -256,7 +256,7 @@ static int cmd64x_ide_dma_end (ide_drive_t *drive)
return err; return err;
} }
static int cmd648_ide_dma_test_irq (ide_drive_t *drive) static int cmd648_dma_test_irq(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
unsigned long base = hwif->dma_base - (hwif->channel * 8); unsigned long base = hwif->dma_base - (hwif->channel * 8);
@ -279,7 +279,7 @@ static int cmd648_ide_dma_test_irq (ide_drive_t *drive)
return 0; return 0;
} }
static int cmd64x_ide_dma_test_irq (ide_drive_t *drive) static int cmd64x_dma_test_irq(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
@ -310,7 +310,7 @@ static int cmd64x_ide_dma_test_irq (ide_drive_t *drive)
* event order for DMA transfers. * event order for DMA transfers.
*/ */
static int cmd646_1_ide_dma_end (ide_drive_t *drive) static int cmd646_1_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
u8 dma_stat = 0, dma_cmd = 0; u8 dma_stat = 0, dma_cmd = 0;
@ -370,7 +370,7 @@ static unsigned int __devinit init_chipset_cmd64x(struct pci_dev *dev, const cha
return 0; return 0;
} }
static u8 __devinit ata66_cmd64x(ide_hwif_t *hwif) static u8 __devinit cmd64x_cable_detect(ide_hwif_t *hwif)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
u8 bmidecsr = 0, mask = hwif->channel ? 0x02 : 0x01; u8 bmidecsr = 0, mask = hwif->channel ? 0x02 : 0x01;
@ -385,60 +385,52 @@ static u8 __devinit ata66_cmd64x(ide_hwif_t *hwif)
} }
} }
static void __devinit init_hwif_cmd64x(ide_hwif_t *hwif) static const struct ide_port_ops cmd64x_port_ops = {
{ .set_pio_mode = cmd64x_set_pio_mode,
struct pci_dev *dev = to_pci_dev(hwif->dev); .set_dma_mode = cmd64x_set_dma_mode,
.cable_detect = cmd64x_cable_detect,
};
hwif->set_pio_mode = &cmd64x_set_pio_mode; static const struct ide_dma_ops cmd64x_dma_ops = {
hwif->set_dma_mode = &cmd64x_set_dma_mode; .dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = cmd64x_dma_end,
.dma_test_irq = cmd64x_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
hwif->cable_detect = ata66_cmd64x; static const struct ide_dma_ops cmd646_rev1_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = cmd646_1_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
if (!hwif->dma_base) static const struct ide_dma_ops cmd648_dma_ops = {
return; .dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
/* .dma_exec_cmd = ide_dma_exec_cmd,
* UltraDMA only supported on PCI646U and PCI646U2, which .dma_start = ide_dma_start,
* correspond to revisions 0x03, 0x05 and 0x07 respectively. .dma_end = cmd648_dma_end,
* Actually, although the CMD tech support people won't .dma_test_irq = cmd648_dma_test_irq,
* tell me the details, the 0x03 revision cannot support .dma_lost_irq = ide_dma_lost_irq,
* UDMA correctly without hardware modifications, and even .dma_timeout = ide_dma_timeout,
* then it only works with Quantum disks due to some };
* hold time assumptions in the 646U part which are fixed
* in the 646U2.
*
* So we only do UltraDMA on revision 0x05 and 0x07 chipsets.
*/
if (dev->device == PCI_DEVICE_ID_CMD_646 && dev->revision < 5)
hwif->ultra_mask = 0x00;
switch (dev->device) {
case PCI_DEVICE_ID_CMD_648:
case PCI_DEVICE_ID_CMD_649:
alt_irq_bits:
hwif->ide_dma_end = &cmd648_ide_dma_end;
hwif->ide_dma_test_irq = &cmd648_ide_dma_test_irq;
break;
case PCI_DEVICE_ID_CMD_646:
if (dev->revision == 0x01) {
hwif->ide_dma_end = &cmd646_1_ide_dma_end;
break;
} else if (dev->revision >= 0x03)
goto alt_irq_bits;
/* fall thru */
default:
hwif->ide_dma_end = &cmd64x_ide_dma_end;
hwif->ide_dma_test_irq = &cmd64x_ide_dma_test_irq;
break;
}
}
static const struct ide_port_info cmd64x_chipsets[] __devinitdata = { static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "CMD643", .name = "CMD643",
.init_chipset = init_chipset_cmd64x, .init_chipset = init_chipset_cmd64x,
.init_hwif = init_hwif_cmd64x,
.enablebits = {{0x00,0x00,0x00}, {0x51,0x08,0x08}}, .enablebits = {{0x00,0x00,0x00}, {0x51,0x08,0x08}},
.port_ops = &cmd64x_port_ops,
.dma_ops = &cmd64x_dma_ops,
.host_flags = IDE_HFLAG_CLEAR_SIMPLEX | .host_flags = IDE_HFLAG_CLEAR_SIMPLEX |
IDE_HFLAG_ABUSE_PREFETCH, IDE_HFLAG_ABUSE_PREFETCH,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
@ -447,9 +439,10 @@ static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
},{ /* 1 */ },{ /* 1 */
.name = "CMD646", .name = "CMD646",
.init_chipset = init_chipset_cmd64x, .init_chipset = init_chipset_cmd64x,
.init_hwif = init_hwif_cmd64x,
.enablebits = {{0x51,0x04,0x04}, {0x51,0x08,0x08}}, .enablebits = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
.chipset = ide_cmd646, .chipset = ide_cmd646,
.port_ops = &cmd64x_port_ops,
.dma_ops = &cmd648_dma_ops,
.host_flags = IDE_HFLAG_ABUSE_PREFETCH, .host_flags = IDE_HFLAG_ABUSE_PREFETCH,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -457,8 +450,9 @@ static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
},{ /* 2 */ },{ /* 2 */
.name = "CMD648", .name = "CMD648",
.init_chipset = init_chipset_cmd64x, .init_chipset = init_chipset_cmd64x,
.init_hwif = init_hwif_cmd64x,
.enablebits = {{0x51,0x04,0x04}, {0x51,0x08,0x08}}, .enablebits = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
.port_ops = &cmd64x_port_ops,
.dma_ops = &cmd648_dma_ops,
.host_flags = IDE_HFLAG_ABUSE_PREFETCH, .host_flags = IDE_HFLAG_ABUSE_PREFETCH,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -466,8 +460,9 @@ static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
},{ /* 3 */ },{ /* 3 */
.name = "CMD649", .name = "CMD649",
.init_chipset = init_chipset_cmd64x, .init_chipset = init_chipset_cmd64x,
.init_hwif = init_hwif_cmd64x,
.enablebits = {{0x51,0x04,0x04}, {0x51,0x08,0x08}}, .enablebits = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
.port_ops = &cmd64x_port_ops,
.dma_ops = &cmd648_dma_ops,
.host_flags = IDE_HFLAG_ABUSE_PREFETCH, .host_flags = IDE_HFLAG_ABUSE_PREFETCH,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -482,12 +477,35 @@ static int __devinit cmd64x_init_one(struct pci_dev *dev, const struct pci_devic
d = cmd64x_chipsets[idx]; d = cmd64x_chipsets[idx];
/* if (idx == 1) {
* The original PCI0646 didn't have the primary channel enable bit, /*
* it appeared starting with PCI0646U (i.e. revision ID 3). * UltraDMA only supported on PCI646U and PCI646U2, which
*/ * correspond to revisions 0x03, 0x05 and 0x07 respectively.
if (idx == 1 && dev->revision < 3) * Actually, although the CMD tech support people won't
d.enablebits[0].reg = 0; * tell me the details, the 0x03 revision cannot support
* UDMA correctly without hardware modifications, and even
* then it only works with Quantum disks due to some
* hold time assumptions in the 646U part which are fixed
* in the 646U2.
*
* So we only do UltraDMA on revision 0x05 and 0x07 chipsets.
*/
if (dev->revision < 5) {
d.udma_mask = 0x00;
/*
* The original PCI0646 didn't have the primary
* channel enable bit, it appeared starting with
* PCI0646U (i.e. revision ID 3).
*/
if (dev->revision < 3) {
d.enablebits[0].reg = 0;
if (dev->revision == 1)
d.dma_ops = &cmd646_rev1_dma_ops;
else
d.dma_ops = &cmd64x_dma_ops;
}
}
}
return ide_setup_pci_device(dev, &d); return ide_setup_pci_device(dev, &d);
} }

26
drivers/ide/pci/cs5520.c
View file

@ -103,21 +103,27 @@ static void cs5520_dma_host_set(ide_drive_t *drive, int on)
ide_dma_host_set(drive, on); ide_dma_host_set(drive, on);
} }
static void __devinit init_hwif_cs5520(ide_hwif_t *hwif) static const struct ide_port_ops cs5520_port_ops = {
{ .set_pio_mode = cs5520_set_pio_mode,
hwif->set_pio_mode = &cs5520_set_pio_mode; .set_dma_mode = cs5520_set_dma_mode,
hwif->set_dma_mode = &cs5520_set_dma_mode; };
if (hwif->dma_base == 0) static const struct ide_dma_ops cs5520_dma_ops = {
return; .dma_host_set = cs5520_dma_host_set,
.dma_setup = ide_dma_setup,
hwif->dma_host_set = &cs5520_dma_host_set; .dma_exec_cmd = ide_dma_exec_cmd,
} .dma_start = ide_dma_start,
.dma_end = __ide_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
#define DECLARE_CS_DEV(name_str) \ #define DECLARE_CS_DEV(name_str) \
{ \ { \
.name = name_str, \ .name = name_str, \
.init_hwif = init_hwif_cs5520, \ .port_ops = &cs5520_port_ops, \
.dma_ops = &cs5520_dma_ops, \
.host_flags = IDE_HFLAG_ISA_PORTS | \ .host_flags = IDE_HFLAG_ISA_PORTS | \
IDE_HFLAG_CS5520 | \ IDE_HFLAG_CS5520 | \
IDE_HFLAG_VDMA | \ IDE_HFLAG_VDMA | \

15
drivers/ide/pci/cs5530.c
View file

@ -228,26 +228,25 @@ static void __devinit init_hwif_cs5530 (ide_hwif_t *hwif)
unsigned long basereg; unsigned long basereg;
u32 d0_timings; u32 d0_timings;
hwif->set_pio_mode = &cs5530_set_pio_mode;
hwif->set_dma_mode = &cs5530_set_dma_mode;
basereg = CS5530_BASEREG(hwif); basereg = CS5530_BASEREG(hwif);
d0_timings = inl(basereg + 0); d0_timings = inl(basereg + 0);
if (CS5530_BAD_PIO(d0_timings)) if (CS5530_BAD_PIO(d0_timings))
outl(cs5530_pio_timings[(d0_timings >> 31) & 1][0], basereg + 0); outl(cs5530_pio_timings[(d0_timings >> 31) & 1][0], basereg + 0);
if (CS5530_BAD_PIO(inl(basereg + 8))) if (CS5530_BAD_PIO(inl(basereg + 8)))
outl(cs5530_pio_timings[(d0_timings >> 31) & 1][0], basereg + 8); outl(cs5530_pio_timings[(d0_timings >> 31) & 1][0], basereg + 8);
if (hwif->dma_base == 0)
return;
hwif->udma_filter = cs5530_udma_filter;
} }
static const struct ide_port_ops cs5530_port_ops = {
.set_pio_mode = cs5530_set_pio_mode,
.set_dma_mode = cs5530_set_dma_mode,
.udma_filter = cs5530_udma_filter,
};
static const struct ide_port_info cs5530_chipset __devinitdata = { static const struct ide_port_info cs5530_chipset __devinitdata = {
.name = "CS5530", .name = "CS5530",
.init_chipset = init_chipset_cs5530, .init_chipset = init_chipset_cs5530,
.init_hwif = init_hwif_cs5530, .init_hwif = init_hwif_cs5530,
.port_ops = &cs5530_port_ops,
.host_flags = IDE_HFLAG_SERIALIZE | .host_flags = IDE_HFLAG_SERIALIZE |
IDE_HFLAG_POST_SET_MODE, IDE_HFLAG_POST_SET_MODE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,

22
drivers/ide/pci/cs5535.c
View file

@ -166,25 +166,15 @@ static u8 __devinit cs5535_cable_detect(ide_hwif_t *hwif)
return (bit & 1) ? ATA_CBL_PATA80 : ATA_CBL_PATA40; return (bit & 1) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
} }
/**** static const struct ide_port_ops cs5535_port_ops = {
* init_hwif_cs5535 - Initialize one ide cannel .set_pio_mode = cs5535_set_pio_mode,
* @hwif: Channel descriptor .set_dma_mode = cs5535_set_dma_mode,
* .cable_detect = cs5535_cable_detect,
* This gets invoked by the IDE driver once for each channel. It };
* performs channel-specific pre-initialization before drive probing.
*
*/
static void __devinit init_hwif_cs5535(ide_hwif_t *hwif)
{
hwif->set_pio_mode = &cs5535_set_pio_mode;
hwif->set_dma_mode = &cs5535_set_dma_mode;
hwif->cable_detect = cs5535_cable_detect;
}
static const struct ide_port_info cs5535_chipset __devinitdata = { static const struct ide_port_info cs5535_chipset __devinitdata = {
.name = "CS5535", .name = "CS5535",
.init_hwif = init_hwif_cs5535, .port_ops = &cs5535_port_ops,
.host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_POST_SET_MODE | .host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_POST_SET_MODE |
IDE_HFLAG_ABUSE_SET_DMA_MODE, IDE_HFLAG_ABUSE_SET_DMA_MODE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,

16
drivers/ide/pci/cy82c693.c
View file

@ -382,15 +382,6 @@ static unsigned int __devinit init_chipset_cy82c693(struct pci_dev *dev, const c
return 0; return 0;
} }
/*
* the init function - called for each ide channel once
*/
static void __devinit init_hwif_cy82c693(ide_hwif_t *hwif)
{
hwif->set_pio_mode = &cy82c693_set_pio_mode;
hwif->set_dma_mode = &cy82c693_set_dma_mode;
}
static void __devinit init_iops_cy82c693(ide_hwif_t *hwif) static void __devinit init_iops_cy82c693(ide_hwif_t *hwif)
{ {
static ide_hwif_t *primary; static ide_hwif_t *primary;
@ -404,11 +395,16 @@ static void __devinit init_iops_cy82c693(ide_hwif_t *hwif)
} }
} }
static const struct ide_port_ops cy82c693_port_ops = {
.set_pio_mode = cy82c693_set_pio_mode,
.set_dma_mode = cy82c693_set_dma_mode,
};
static const struct ide_port_info cy82c693_chipset __devinitdata = { static const struct ide_port_info cy82c693_chipset __devinitdata = {
.name = "CY82C693", .name = "CY82C693",
.init_chipset = init_chipset_cy82c693, .init_chipset = init_chipset_cy82c693,
.init_iops = init_iops_cy82c693, .init_iops = init_iops_cy82c693,
.init_hwif = init_hwif_cy82c693, .port_ops = &cy82c693_port_ops,
.chipset = ide_cy82c693, .chipset = ide_cy82c693,
.host_flags = IDE_HFLAG_SINGLE, .host_flags = IDE_HFLAG_SINGLE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,

7
drivers/ide/pci/delkin_cb.c
View file

@ -43,6 +43,10 @@ static const u8 setup[] = {
0x00, 0x00, 0x00, 0x00, 0xa4, 0x83, 0x02, 0x13, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x83, 0x02, 0x13,
}; };
static const struct ide_port_ops delkin_cb_port_ops = {
.quirkproc = ide_undecoded_slave,
};
static int __devinit static int __devinit
delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id) delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
{ {
@ -89,8 +93,7 @@ delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
ide_init_port_data(hwif, i); ide_init_port_data(hwif, i);
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1; hwif->port_ops = &delkin_cb_port_ops;
hwif->quirkproc = &ide_undecoded_slave;
idx[0] = i; idx[0] = i;

15
drivers/ide/pci/hpt34x.c
View file

@ -115,11 +115,10 @@ static unsigned int __devinit init_chipset_hpt34x(struct pci_dev *dev, const cha
return dev->irq; return dev->irq;
} }
static void __devinit init_hwif_hpt34x(ide_hwif_t *hwif) static const struct ide_port_ops hpt34x_port_ops = {
{ .set_pio_mode = hpt34x_set_pio_mode,
hwif->set_pio_mode = &hpt34x_set_pio_mode; .set_dma_mode = hpt34x_set_mode,
hwif->set_dma_mode = &hpt34x_set_mode; };
}
#define IDE_HFLAGS_HPT34X \ #define IDE_HFLAGS_HPT34X \
(IDE_HFLAG_NO_ATAPI_DMA | \ (IDE_HFLAG_NO_ATAPI_DMA | \
@ -131,16 +130,14 @@ static const struct ide_port_info hpt34x_chipsets[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "HPT343", .name = "HPT343",
.init_chipset = init_chipset_hpt34x, .init_chipset = init_chipset_hpt34x,
.init_hwif = init_hwif_hpt34x, .port_ops = &hpt34x_port_ops,
.extra = 16,
.host_flags = IDE_HFLAGS_HPT34X | IDE_HFLAG_NON_BOOTABLE, .host_flags = IDE_HFLAGS_HPT34X | IDE_HFLAG_NON_BOOTABLE,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
}, },
{ /* 1 */ { /* 1 */
.name = "HPT345", .name = "HPT345",
.init_chipset = init_chipset_hpt34x, .init_chipset = init_chipset_hpt34x,
.init_hwif = init_hwif_hpt34x, .port_ops = &hpt34x_port_ops,
.extra = 16,
.host_flags = IDE_HFLAGS_HPT34X | IDE_HFLAG_OFF_BOARD, .host_flags = IDE_HFLAGS_HPT34X | IDE_HFLAG_OFF_BOARD,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
#ifdef CONFIG_HPT34X_AUTODMA #ifdef CONFIG_HPT34X_AUTODMA

128
drivers/ide/pci/hpt366.c
View file

@ -776,7 +776,7 @@ static void hpt366_dma_lost_irq(ide_drive_t *drive)
pci_read_config_byte(dev, 0x52, &mcr3); pci_read_config_byte(dev, 0x52, &mcr3);
pci_read_config_byte(dev, 0x5a, &scr1); pci_read_config_byte(dev, 0x5a, &scr1);
printk("%s: (%s) mcr1=0x%02x, mcr3=0x%02x, scr1=0x%02x\n", printk("%s: (%s) mcr1=0x%02x, mcr3=0x%02x, scr1=0x%02x\n",
drive->name, __FUNCTION__, mcr1, mcr3, scr1); drive->name, __func__, mcr1, mcr3, scr1);
if (scr1 & 0x10) if (scr1 & 0x10)
pci_write_config_byte(dev, 0x5a, scr1 & ~0x10); pci_write_config_byte(dev, 0x5a, scr1 & ~0x10);
ide_dma_lost_irq(drive); ide_dma_lost_irq(drive);
@ -808,7 +808,7 @@ static void hpt370_irq_timeout(ide_drive_t *drive)
hpt370_clear_engine(drive); hpt370_clear_engine(drive);
} }
static void hpt370_ide_dma_start(ide_drive_t *drive) static void hpt370_dma_start(ide_drive_t *drive)
{ {
#ifdef HPT_RESET_STATE_ENGINE #ifdef HPT_RESET_STATE_ENGINE
hpt370_clear_engine(drive); hpt370_clear_engine(drive);
@ -816,7 +816,7 @@ static void hpt370_ide_dma_start(ide_drive_t *drive)
ide_dma_start(drive); ide_dma_start(drive);
} }
static int hpt370_ide_dma_end(ide_drive_t *drive) static int hpt370_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
u8 dma_stat = inb(hwif->dma_status); u8 dma_stat = inb(hwif->dma_status);
@ -838,7 +838,7 @@ static void hpt370_dma_timeout(ide_drive_t *drive)
} }
/* returns 1 if DMA IRQ issued, 0 otherwise */ /* returns 1 if DMA IRQ issued, 0 otherwise */
static int hpt374_ide_dma_test_irq(ide_drive_t *drive) static int hpt374_dma_test_irq(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
@ -858,11 +858,11 @@ static int hpt374_ide_dma_test_irq(ide_drive_t *drive)
if (!drive->waiting_for_dma) if (!drive->waiting_for_dma)
printk(KERN_WARNING "%s: (%s) called while not waiting\n", printk(KERN_WARNING "%s: (%s) called while not waiting\n",
drive->name, __FUNCTION__); drive->name, __func__);
return 0; return 0;
} }
static int hpt374_ide_dma_end(ide_drive_t *drive) static int hpt374_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
@ -1271,17 +1271,6 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
/* Cache the channel's MISC. control registers' offset */ /* Cache the channel's MISC. control registers' offset */
hwif->select_data = hwif->channel ? 0x54 : 0x50; hwif->select_data = hwif->channel ? 0x54 : 0x50;
hwif->set_pio_mode = &hpt3xx_set_pio_mode;
hwif->set_dma_mode = &hpt3xx_set_mode;
hwif->quirkproc = &hpt3xx_quirkproc;
hwif->maskproc = &hpt3xx_maskproc;
hwif->udma_filter = &hpt3xx_udma_filter;
hwif->mdma_filter = &hpt3xx_mdma_filter;
hwif->cable_detect = hpt3xx_cable_detect;
/* /*
* HPT3xxN chips have some complications: * HPT3xxN chips have some complications:
* *
@ -1323,29 +1312,19 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
if (new_mcr != old_mcr) if (new_mcr != old_mcr)
pci_write_config_byte(dev, hwif->select_data + 1, new_mcr); pci_write_config_byte(dev, hwif->select_data + 1, new_mcr);
if (hwif->dma_base == 0)
return;
if (chip_type >= HPT374) {
hwif->ide_dma_test_irq = &hpt374_ide_dma_test_irq;
hwif->ide_dma_end = &hpt374_ide_dma_end;
} else if (chip_type >= HPT370) {
hwif->dma_start = &hpt370_ide_dma_start;
hwif->ide_dma_end = &hpt370_ide_dma_end;
hwif->dma_timeout = &hpt370_dma_timeout;
} else
hwif->dma_lost_irq = &hpt366_dma_lost_irq;
} }
static void __devinit init_dma_hpt366(ide_hwif_t *hwif, unsigned long dmabase) static int __devinit init_dma_hpt366(ide_hwif_t *hwif,
const struct ide_port_info *d)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
u8 masterdma = 0, slavedma = 0; unsigned long flags, base = ide_pci_dma_base(hwif, d);
u8 dma_new = 0, dma_old = 0; u8 dma_old, dma_new, masterdma = 0, slavedma = 0;
unsigned long flags;
dma_old = inb(dmabase + 2); if (base == 0 || ide_pci_set_master(dev, d->name) < 0)
return -1;
dma_old = inb(base + 2);
local_irq_save(flags); local_irq_save(flags);
@ -1356,11 +1335,21 @@ static void __devinit init_dma_hpt366(ide_hwif_t *hwif, unsigned long dmabase)
if (masterdma & 0x30) dma_new |= 0x20; if (masterdma & 0x30) dma_new |= 0x20;
if ( slavedma & 0x30) dma_new |= 0x40; if ( slavedma & 0x30) dma_new |= 0x40;
if (dma_new != dma_old) if (dma_new != dma_old)
outb(dma_new, dmabase + 2); outb(dma_new, base + 2);
local_irq_restore(flags); local_irq_restore(flags);
ide_setup_dma(hwif, dmabase); printk(KERN_INFO " %s: BM-DMA at 0x%04lx-0x%04lx\n",
hwif->name, base, base + 7);
hwif->extra_base = base + (hwif->channel ? 8 : 16);
if (ide_allocate_dma_engine(hwif))
return -1;
ide_setup_dma(hwif, base);
return 0;
} }
static void __devinit hpt374_init(struct pci_dev *dev, struct pci_dev *dev2) static void __devinit hpt374_init(struct pci_dev *dev, struct pci_dev *dev2)
@ -1416,6 +1405,49 @@ static int __devinit hpt36x_init(struct pci_dev *dev, struct pci_dev *dev2)
IDE_HFLAG_ABUSE_SET_DMA_MODE | \ IDE_HFLAG_ABUSE_SET_DMA_MODE | \
IDE_HFLAG_OFF_BOARD) IDE_HFLAG_OFF_BOARD)
static const struct ide_port_ops hpt3xx_port_ops = {
.set_pio_mode = hpt3xx_set_pio_mode,
.set_dma_mode = hpt3xx_set_mode,
.quirkproc = hpt3xx_quirkproc,
.maskproc = hpt3xx_maskproc,
.mdma_filter = hpt3xx_mdma_filter,
.udma_filter = hpt3xx_udma_filter,
.cable_detect = hpt3xx_cable_detect,
};
static const struct ide_dma_ops hpt37x_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = hpt374_dma_end,
.dma_test_irq = hpt374_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
static const struct ide_dma_ops hpt370_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = hpt370_dma_start,
.dma_end = hpt370_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = hpt370_dma_timeout,
};
static const struct ide_dma_ops hpt36x_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = __ide_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = hpt366_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
static const struct ide_port_info hpt366_chipsets[] __devinitdata = { static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "HPT36x", .name = "HPT36x",
@ -1429,7 +1461,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
* Bit 4 is for the primary channel, bit 5 for the secondary. * Bit 4 is for the primary channel, bit 5 for the secondary.
*/ */
.enablebits = {{0x50,0x10,0x10}, {0x54,0x04,0x04}}, .enablebits = {{0x50,0x10,0x10}, {0x54,0x04,0x04}},
.extra = 240, .port_ops = &hpt3xx_port_ops,
.dma_ops = &hpt36x_dma_ops,
.host_flags = IDE_HFLAGS_HPT3XX | IDE_HFLAG_SINGLE, .host_flags = IDE_HFLAGS_HPT3XX | IDE_HFLAG_SINGLE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -1439,7 +1472,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
.init_hwif = init_hwif_hpt366, .init_hwif = init_hwif_hpt366,
.init_dma = init_dma_hpt366, .init_dma = init_dma_hpt366,
.enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}}, .enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
.extra = 240, .port_ops = &hpt3xx_port_ops,
.dma_ops = &hpt37x_dma_ops,
.host_flags = IDE_HFLAGS_HPT3XX, .host_flags = IDE_HFLAGS_HPT3XX,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -1449,7 +1483,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
.init_hwif = init_hwif_hpt366, .init_hwif = init_hwif_hpt366,
.init_dma = init_dma_hpt366, .init_dma = init_dma_hpt366,
.enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}}, .enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
.extra = 240, .port_ops = &hpt3xx_port_ops,
.dma_ops = &hpt37x_dma_ops,
.host_flags = IDE_HFLAGS_HPT3XX, .host_flags = IDE_HFLAGS_HPT3XX,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -1459,7 +1494,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
.init_hwif = init_hwif_hpt366, .init_hwif = init_hwif_hpt366,
.init_dma = init_dma_hpt366, .init_dma = init_dma_hpt366,
.enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}}, .enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
.extra = 240, .port_ops = &hpt3xx_port_ops,
.dma_ops = &hpt37x_dma_ops,
.host_flags = IDE_HFLAGS_HPT3XX, .host_flags = IDE_HFLAGS_HPT3XX,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -1470,7 +1506,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
.init_dma = init_dma_hpt366, .init_dma = init_dma_hpt366,
.enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}}, .enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
.udma_mask = ATA_UDMA5, .udma_mask = ATA_UDMA5,
.extra = 240, .port_ops = &hpt3xx_port_ops,
.dma_ops = &hpt37x_dma_ops,
.host_flags = IDE_HFLAGS_HPT3XX, .host_flags = IDE_HFLAGS_HPT3XX,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -1480,7 +1517,8 @@ static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
.init_hwif = init_hwif_hpt366, .init_hwif = init_hwif_hpt366,
.init_dma = init_dma_hpt366, .init_dma = init_dma_hpt366,
.enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}}, .enablebits = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
.extra = 240, .port_ops = &hpt3xx_port_ops,
.dma_ops = &hpt37x_dma_ops,
.host_flags = IDE_HFLAGS_HPT3XX, .host_flags = IDE_HFLAGS_HPT3XX,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -1543,6 +1581,10 @@ static int __devinit hpt366_init_one(struct pci_dev *dev, const struct pci_devic
d.name = info->chip_name; d.name = info->chip_name;
d.udma_mask = info->udma_mask; d.udma_mask = info->udma_mask;
/* fixup ->dma_ops for HPT370/HPT370A */
if (info == &hpt370 || info == &hpt370a)
d.dma_ops = &hpt370_dma_ops;
pci_set_drvdata(dev, (void *)info); pci_set_drvdata(dev, (void *)info);
if (info == &hpt36x || info == &hpt374) if (info == &hpt36x || info == &hpt374)

22
drivers/ide/pci/it8213.c
View file

@ -149,27 +149,17 @@ static u8 __devinit it8213_cable_detect(ide_hwif_t *hwif)
return (reg42h & 0x02) ? ATA_CBL_PATA40 : ATA_CBL_PATA80; return (reg42h & 0x02) ? ATA_CBL_PATA40 : ATA_CBL_PATA80;
} }
/** static const struct ide_port_ops it8213_port_ops = {
* init_hwif_it8213 - set up hwif structs .set_pio_mode = it8213_set_pio_mode,
* @hwif: interface to set up .set_dma_mode = it8213_set_dma_mode,
* .cable_detect = it8213_cable_detect,
* We do the basic set up of the interface structure. };
*/
static void __devinit init_hwif_it8213(ide_hwif_t *hwif)
{
hwif->set_dma_mode = &it8213_set_dma_mode;
hwif->set_pio_mode = &it8213_set_pio_mode;
hwif->cable_detect = it8213_cable_detect;
}
#define DECLARE_ITE_DEV(name_str) \ #define DECLARE_ITE_DEV(name_str) \
{ \ { \
.name = name_str, \ .name = name_str, \
.init_hwif = init_hwif_it8213, \
.enablebits = { {0x41, 0x80, 0x80} }, \ .enablebits = { {0x41, 0x80, 0x80} }, \
.port_ops = &it8213_port_ops, \
.host_flags = IDE_HFLAG_SINGLE, \ .host_flags = IDE_HFLAG_SINGLE, \
.pio_mask = ATA_PIO4, \ .pio_mask = ATA_PIO4, \
.swdma_mask = ATA_SWDMA2_ONLY, \ .swdma_mask = ATA_SWDMA2_ONLY, \

27
drivers/ide/pci/it821x.c
View file

@ -418,7 +418,7 @@ static void it821x_set_dma_mode(ide_drive_t *drive, const u8 speed)
} }
/** /**
* ata66_it821x - check for 80 pin cable * it821x_cable_detect - cable detection
* @hwif: interface to check * @hwif: interface to check
* *
* Check for the presence of an ATA66 capable cable on the * Check for the presence of an ATA66 capable cable on the
@ -426,7 +426,7 @@ static void it821x_set_dma_mode(ide_drive_t *drive, const u8 speed)
* the needed logic onboard. * the needed logic onboard.
*/ */
static u8 __devinit ata66_it821x(ide_hwif_t *hwif) static u8 __devinit it821x_cable_detect(ide_hwif_t *hwif)
{ {
/* The reference driver also only does disk side */ /* The reference driver also only does disk side */
return ATA_CBL_PATA80; return ATA_CBL_PATA80;
@ -511,6 +511,11 @@ static void __devinit it821x_quirkproc(ide_drive_t *drive)
} }
static struct ide_dma_ops it821x_pass_through_dma_ops = {
.dma_start = it821x_dma_start,
.dma_end = it821x_dma_end,
};
/** /**
* init_hwif_it821x - set up hwif structs * init_hwif_it821x - set up hwif structs
* @hwif: interface to set up * @hwif: interface to set up
@ -527,8 +532,6 @@ static void __devinit init_hwif_it821x(ide_hwif_t *hwif)
struct it821x_dev *idev = itdevs[hwif->channel]; struct it821x_dev *idev = itdevs[hwif->channel];
u8 conf; u8 conf;
hwif->quirkproc = &it821x_quirkproc;
ide_set_hwifdata(hwif, idev); ide_set_hwifdata(hwif, idev);
pci_read_config_byte(dev, 0x50, &conf); pci_read_config_byte(dev, 0x50, &conf);
@ -563,17 +566,11 @@ static void __devinit init_hwif_it821x(ide_hwif_t *hwif)
} }
if (idev->smart == 0) { if (idev->smart == 0) {
hwif->set_pio_mode = &it821x_set_pio_mode;
hwif->set_dma_mode = &it821x_set_dma_mode;
/* MWDMA/PIO clock switching for pass through mode */ /* MWDMA/PIO clock switching for pass through mode */
hwif->dma_start = &it821x_dma_start; hwif->dma_ops = &it821x_pass_through_dma_ops;
hwif->ide_dma_end = &it821x_dma_end;
} else } else
hwif->host_flags |= IDE_HFLAG_NO_SET_MODE; hwif->host_flags |= IDE_HFLAG_NO_SET_MODE;
hwif->cable_detect = ata66_it821x;
if (hwif->dma_base == 0) if (hwif->dma_base == 0)
return; return;
@ -613,12 +610,20 @@ static unsigned int __devinit init_chipset_it821x(struct pci_dev *dev, const cha
return 0; return 0;
} }
static const struct ide_port_ops it821x_port_ops = {
/* it821x_set_{pio,dma}_mode() are only used in pass-through mode */
.set_pio_mode = it821x_set_pio_mode,
.set_dma_mode = it821x_set_dma_mode,
.quirkproc = it821x_quirkproc,
.cable_detect = it821x_cable_detect,
};
#define DECLARE_ITE_DEV(name_str) \ #define DECLARE_ITE_DEV(name_str) \
{ \ { \
.name = name_str, \ .name = name_str, \
.init_chipset = init_chipset_it821x, \ .init_chipset = init_chipset_it821x, \
.init_hwif = init_hwif_it821x, \ .init_hwif = init_hwif_it821x, \
.port_ops = &it821x_port_ops, \
.pio_mask = ATA_PIO4, \ .pio_mask = ATA_PIO4, \
} }

25
drivers/ide/pci/jmicron.c
View file

@ -19,13 +19,13 @@ typedef enum {
} port_type; } port_type;
/** /**
* ata66_jmicron - Cable check * jmicron_cable_detect - cable detection
* @hwif: IDE port * @hwif: IDE port
* *
* Returns the cable type. * Returns the cable type.
*/ */
static u8 __devinit ata66_jmicron(ide_hwif_t *hwif) static u8 __devinit jmicron_cable_detect(ide_hwif_t *hwif)
{ {
struct pci_dev *pdev = to_pci_dev(hwif->dev); struct pci_dev *pdev = to_pci_dev(hwif->dev);
@ -95,25 +95,16 @@ static void jmicron_set_dma_mode(ide_drive_t *drive, const u8 mode)
{ {
} }
/** static const struct ide_port_ops jmicron_port_ops = {
* init_hwif_jmicron - set up hwif structs .set_pio_mode = jmicron_set_pio_mode,
* @hwif: interface to set up .set_dma_mode = jmicron_set_dma_mode,
* .cable_detect = jmicron_cable_detect,
* Minimal set up is required for the Jmicron hardware. };
*/
static void __devinit init_hwif_jmicron(ide_hwif_t *hwif)
{
hwif->set_pio_mode = &jmicron_set_pio_mode;
hwif->set_dma_mode = &jmicron_set_dma_mode;
hwif->cable_detect = ata66_jmicron;
}
static const struct ide_port_info jmicron_chipset __devinitdata = { static const struct ide_port_info jmicron_chipset __devinitdata = {
.name = "JMB", .name = "JMB",
.init_hwif = init_hwif_jmicron,
.enablebits = { { 0x40, 0x01, 0x01 }, { 0x40, 0x10, 0x10 } }, .enablebits = { { 0x40, 0x01, 0x01 }, { 0x40, 0x10, 0x10 } },
.port_ops = &jmicron_port_ops,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
.udma_mask = ATA_UDMA6, .udma_mask = ATA_UDMA6,

25
drivers/ide/pci/ns87415.c
View file

@ -150,7 +150,7 @@ static void ns87415_selectproc (ide_drive_t *drive)
ns87415_prepare_drive (drive, drive->using_dma); ns87415_prepare_drive (drive, drive->using_dma);
} }
static int ns87415_ide_dma_end (ide_drive_t *drive) static int ns87415_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
u8 dma_stat = 0, dma_cmd = 0; u8 dma_stat = 0, dma_cmd = 0;
@ -170,7 +170,7 @@ static int ns87415_ide_dma_end (ide_drive_t *drive)
return (dma_stat & 7) != 4; return (dma_stat & 7) != 4;
} }
static int ns87415_ide_dma_setup(ide_drive_t *drive) static int ns87415_dma_setup(ide_drive_t *drive)
{ {
/* select DMA xfer */ /* select DMA xfer */
ns87415_prepare_drive(drive, 1); ns87415_prepare_drive(drive, 1);
@ -195,8 +195,6 @@ static void __devinit init_hwif_ns87415 (ide_hwif_t *hwif)
u8 stat; u8 stat;
#endif #endif
hwif->selectproc = &ns87415_selectproc;
/* /*
* We cannot probe for IRQ: both ports share common IRQ on INTA. * We cannot probe for IRQ: both ports share common IRQ on INTA.
* Also, leave IRQ masked during drive probing, to prevent infinite * Also, leave IRQ masked during drive probing, to prevent infinite
@ -254,16 +252,31 @@ static void __devinit init_hwif_ns87415 (ide_hwif_t *hwif)
return; return;
outb(0x60, hwif->dma_status); outb(0x60, hwif->dma_status);
hwif->dma_setup = &ns87415_ide_dma_setup;
hwif->ide_dma_end = &ns87415_ide_dma_end;
} }
static const struct ide_port_ops ns87415_port_ops = {
.selectproc = ns87415_selectproc,
};
static const struct ide_dma_ops ns87415_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ns87415_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = ns87415_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
static const struct ide_port_info ns87415_chipset __devinitdata = { static const struct ide_port_info ns87415_chipset __devinitdata = {
.name = "NS87415", .name = "NS87415",
#ifdef CONFIG_SUPERIO #ifdef CONFIG_SUPERIO
.init_iops = init_iops_ns87415, .init_iops = init_iops_ns87415,
#endif #endif
.init_hwif = init_hwif_ns87415, .init_hwif = init_hwif_ns87415,
.port_ops = &ns87415_port_ops,
.dma_ops = &ns87415_dma_ops,
.host_flags = IDE_HFLAG_TRUST_BIOS_FOR_DMA | .host_flags = IDE_HFLAG_TRUST_BIOS_FOR_DMA |
IDE_HFLAG_NO_ATAPI_DMA, IDE_HFLAG_NO_ATAPI_DMA,
}; };

16
drivers/ide/pci/opti621.c
View file

@ -326,28 +326,24 @@ static void __devinit opti621_port_init_devs(ide_hwif_t *hwif)
hwif->drives[1].drive_data = PIO_DONT_KNOW; hwif->drives[1].drive_data = PIO_DONT_KNOW;
} }
/* static const struct ide_port_ops opti621_port_ops = {
* init_hwif_opti621() is called once for each hwif found at boot. .port_init_devs = opti621_port_init_devs,
*/ .set_pio_mode = opti621_set_pio_mode,
static void __devinit init_hwif_opti621(ide_hwif_t *hwif) };
{
hwif->port_init_devs = opti621_port_init_devs;
hwif->set_pio_mode = &opti621_set_pio_mode;
}
static const struct ide_port_info opti621_chipsets[] __devinitdata = { static const struct ide_port_info opti621_chipsets[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "OPTI621", .name = "OPTI621",
.init_hwif = init_hwif_opti621,
.enablebits = { {0x45, 0x80, 0x00}, {0x40, 0x08, 0x00} }, .enablebits = { {0x45, 0x80, 0x00}, {0x40, 0x08, 0x00} },
.port_ops = &opti621_port_ops,
.host_flags = IDE_HFLAG_TRUST_BIOS_FOR_DMA, .host_flags = IDE_HFLAG_TRUST_BIOS_FOR_DMA,
.pio_mask = ATA_PIO3, .pio_mask = ATA_PIO3,
.swdma_mask = ATA_SWDMA2, .swdma_mask = ATA_SWDMA2,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
}, { /* 1 */ }, { /* 1 */
.name = "OPTI621X", .name = "OPTI621X",
.init_hwif = init_hwif_opti621,
.enablebits = { {0x45, 0x80, 0x00}, {0x40, 0x08, 0x00} }, .enablebits = { {0x45, 0x80, 0x00}, {0x40, 0x08, 0x00} },
.port_ops = &opti621_port_ops,
.host_flags = IDE_HFLAG_TRUST_BIOS_FOR_DMA, .host_flags = IDE_HFLAG_TRUST_BIOS_FOR_DMA,
.pio_mask = ATA_PIO3, .pio_mask = ATA_PIO3,
.swdma_mask = ATA_SWDMA2, .swdma_mask = ATA_SWDMA2,

23
drivers/ide/pci/pdc202xx_new.c
View file

@ -34,7 +34,7 @@
#undef DEBUG #undef DEBUG
#ifdef DEBUG #ifdef DEBUG
#define DBG(fmt, args...) printk("%s: " fmt, __FUNCTION__, ## args) #define DBG(fmt, args...) printk("%s: " fmt, __func__, ## args)
#else #else
#define DBG(fmt, args...) #define DBG(fmt, args...)
#endif #endif
@ -442,17 +442,6 @@ static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const cha
return dev->irq; return dev->irq;
} }
static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
{
hwif->set_pio_mode = &pdcnew_set_pio_mode;
hwif->set_dma_mode = &pdcnew_set_dma_mode;
hwif->quirkproc = &pdcnew_quirkproc;
hwif->resetproc = &pdcnew_reset;
hwif->cable_detect = pdcnew_cable_detect;
}
static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev) static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev)
{ {
struct pci_dev *dev2; struct pci_dev *dev2;
@ -476,11 +465,19 @@ static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev)
return NULL; return NULL;
} }
static const struct ide_port_ops pdcnew_port_ops = {
.set_pio_mode = pdcnew_set_pio_mode,
.set_dma_mode = pdcnew_set_dma_mode,
.quirkproc = pdcnew_quirkproc,
.resetproc = pdcnew_reset,
.cable_detect = pdcnew_cable_detect,
};
#define DECLARE_PDCNEW_DEV(name_str, udma) \ #define DECLARE_PDCNEW_DEV(name_str, udma) \
{ \ { \
.name = name_str, \ .name = name_str, \
.init_chipset = init_chipset_pdcnew, \ .init_chipset = init_chipset_pdcnew, \
.init_hwif = init_hwif_pdc202new, \ .port_ops = &pdcnew_port_ops, \
.host_flags = IDE_HFLAG_POST_SET_MODE | \ .host_flags = IDE_HFLAG_POST_SET_MODE | \
IDE_HFLAG_ERROR_STOPS_FIFO | \ IDE_HFLAG_ERROR_STOPS_FIFO | \
IDE_HFLAG_OFF_BOARD, \ IDE_HFLAG_OFF_BOARD, \

136
drivers/ide/pci/pdc202xx_old.c
View file

@ -115,7 +115,7 @@ static void pdc202xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
pdc202xx_set_mode(drive, XFER_PIO_0 + pio); pdc202xx_set_mode(drive, XFER_PIO_0 + pio);
} }
static u8 __devinit pdc2026x_old_cable_detect(ide_hwif_t *hwif) static u8 __devinit pdc2026x_cable_detect(ide_hwif_t *hwif)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
u16 CIS, mask = hwif->channel ? (1 << 11) : (1 << 10); u16 CIS, mask = hwif->channel ? (1 << 11) : (1 << 10);
@ -163,7 +163,7 @@ static void pdc202xx_quirkproc(ide_drive_t *drive)
drive->quirk_list = 0; drive->quirk_list = 0;
} }
static void pdc202xx_old_ide_dma_start(ide_drive_t *drive) static void pdc202xx_dma_start(ide_drive_t *drive)
{ {
if (drive->current_speed > XFER_UDMA_2) if (drive->current_speed > XFER_UDMA_2)
pdc_old_enable_66MHz_clock(drive->hwif); pdc_old_enable_66MHz_clock(drive->hwif);
@ -185,7 +185,7 @@ static void pdc202xx_old_ide_dma_start(ide_drive_t *drive)
ide_dma_start(drive); ide_dma_start(drive);
} }
static int pdc202xx_old_ide_dma_end(ide_drive_t *drive) static int pdc202xx_dma_end(ide_drive_t *drive)
{ {
if (drive->media != ide_disk || drive->addressing == 1) { if (drive->media != ide_disk || drive->addressing == 1) {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
@ -202,7 +202,7 @@ static int pdc202xx_old_ide_dma_end(ide_drive_t *drive)
return __ide_dma_end(drive); return __ide_dma_end(drive);
} }
static int pdc202xx_old_ide_dma_test_irq(ide_drive_t *drive) static int pdc202xx_dma_test_irq(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
unsigned long high_16 = hwif->extra_base - 16; unsigned long high_16 = hwif->extra_base - 16;
@ -226,26 +226,6 @@ static int pdc202xx_old_ide_dma_test_irq(ide_drive_t *drive)
return (dma_stat & 4) == 4; /* return 1 if INTR asserted */ return (dma_stat & 4) == 4; /* return 1 if INTR asserted */
} }
static void pdc202xx_dma_lost_irq(ide_drive_t *drive)
{
ide_hwif_t *hwif = HWIF(drive);
if (hwif->resetproc != NULL)
hwif->resetproc(drive);
ide_dma_lost_irq(drive);
}
static void pdc202xx_dma_timeout(ide_drive_t *drive)
{
ide_hwif_t *hwif = HWIF(drive);
if (hwif->resetproc != NULL)
hwif->resetproc(drive);
ide_dma_timeout(drive);
}
static void pdc202xx_reset_host (ide_hwif_t *hwif) static void pdc202xx_reset_host (ide_hwif_t *hwif)
{ {
unsigned long high_16 = hwif->extra_base - 16; unsigned long high_16 = hwif->extra_base - 16;
@ -271,68 +251,46 @@ static void pdc202xx_reset (ide_drive_t *drive)
ide_set_max_pio(drive); ide_set_max_pio(drive);
} }
static void pdc202xx_dma_lost_irq(ide_drive_t *drive)
{
pdc202xx_reset(drive);
ide_dma_lost_irq(drive);
}
static void pdc202xx_dma_timeout(ide_drive_t *drive)
{
pdc202xx_reset(drive);
ide_dma_timeout(drive);
}
static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev, static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev,
const char *name) const char *name)
{
return dev->irq;
}
static void __devinit init_hwif_pdc202xx(ide_hwif_t *hwif)
{
struct pci_dev *dev = to_pci_dev(hwif->dev);
hwif->set_pio_mode = &pdc202xx_set_pio_mode;
hwif->set_dma_mode = &pdc202xx_set_mode;
hwif->quirkproc = &pdc202xx_quirkproc;
if (dev->device != PCI_DEVICE_ID_PROMISE_20246) {
hwif->resetproc = &pdc202xx_reset;
hwif->cable_detect = pdc2026x_old_cable_detect;
}
if (hwif->dma_base == 0)
return;
hwif->dma_lost_irq = &pdc202xx_dma_lost_irq;
hwif->dma_timeout = &pdc202xx_dma_timeout;
if (dev->device != PCI_DEVICE_ID_PROMISE_20246) {
hwif->dma_start = &pdc202xx_old_ide_dma_start;
hwif->ide_dma_end = &pdc202xx_old_ide_dma_end;
}
hwif->ide_dma_test_irq = &pdc202xx_old_ide_dma_test_irq;
}
static void __devinit init_dma_pdc202xx(ide_hwif_t *hwif, unsigned long dmabase)
{ {
unsigned long dmabase = pci_resource_start(dev, 4);
u8 udma_speed_flag = 0, primary_mode = 0, secondary_mode = 0; u8 udma_speed_flag = 0, primary_mode = 0, secondary_mode = 0;
if (hwif->channel) { if (dmabase == 0)
ide_setup_dma(hwif, dmabase); goto out;
return;
}
udma_speed_flag = inb(dmabase | 0x1f); udma_speed_flag = inb(dmabase | 0x1f);
primary_mode = inb(dmabase | 0x1a); primary_mode = inb(dmabase | 0x1a);
secondary_mode = inb(dmabase | 0x1b); secondary_mode = inb(dmabase | 0x1b);
printk(KERN_INFO "%s: (U)DMA Burst Bit %sABLED " \ printk(KERN_INFO "%s: (U)DMA Burst Bit %sABLED " \
"Primary %s Mode " \ "Primary %s Mode " \
"Secondary %s Mode.\n", hwif->cds->name, "Secondary %s Mode.\n", pci_name(dev),
(udma_speed_flag & 1) ? "EN" : "DIS", (udma_speed_flag & 1) ? "EN" : "DIS",
(primary_mode & 1) ? "MASTER" : "PCI", (primary_mode & 1) ? "MASTER" : "PCI",
(secondary_mode & 1) ? "MASTER" : "PCI" ); (secondary_mode & 1) ? "MASTER" : "PCI" );
if (!(udma_speed_flag & 1)) { if (!(udma_speed_flag & 1)) {
printk(KERN_INFO "%s: FORCING BURST BIT 0x%02x->0x%02x ", printk(KERN_INFO "%s: FORCING BURST BIT 0x%02x->0x%02x ",
hwif->cds->name, udma_speed_flag, pci_name(dev), udma_speed_flag,
(udma_speed_flag|1)); (udma_speed_flag|1));
outb(udma_speed_flag | 1, dmabase | 0x1f); outb(udma_speed_flag | 1, dmabase | 0x1f);
printk("%sACTIVE\n", (inb(dmabase | 0x1f) & 1) ? "" : "IN"); printk("%sACTIVE\n", (inb(dmabase | 0x1f) & 1) ? "" : "IN");
} }
out:
ide_setup_dma(hwif, dmabase); return dev->irq;
} }
static void __devinit pdc202ata4_fixup_irq(struct pci_dev *dev, static void __devinit pdc202ata4_fixup_irq(struct pci_dev *dev,
@ -357,13 +315,48 @@ static void __devinit pdc202ata4_fixup_irq(struct pci_dev *dev,
IDE_HFLAG_ABUSE_SET_DMA_MODE | \ IDE_HFLAG_ABUSE_SET_DMA_MODE | \
IDE_HFLAG_OFF_BOARD) IDE_HFLAG_OFF_BOARD)
static const struct ide_port_ops pdc20246_port_ops = {
.set_pio_mode = pdc202xx_set_pio_mode,
.set_dma_mode = pdc202xx_set_mode,
.quirkproc = pdc202xx_quirkproc,
};
static const struct ide_port_ops pdc2026x_port_ops = {
.set_pio_mode = pdc202xx_set_pio_mode,
.set_dma_mode = pdc202xx_set_mode,
.quirkproc = pdc202xx_quirkproc,
.resetproc = pdc202xx_reset,
.cable_detect = pdc2026x_cable_detect,
};
static const struct ide_dma_ops pdc20246_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = __ide_dma_end,
.dma_test_irq = pdc202xx_dma_test_irq,
.dma_lost_irq = pdc202xx_dma_lost_irq,
.dma_timeout = pdc202xx_dma_timeout,
};
static const struct ide_dma_ops pdc2026x_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = pdc202xx_dma_start,
.dma_end = pdc202xx_dma_end,
.dma_test_irq = pdc202xx_dma_test_irq,
.dma_lost_irq = pdc202xx_dma_lost_irq,
.dma_timeout = pdc202xx_dma_timeout,
};
#define DECLARE_PDC2026X_DEV(name_str, udma, extra_flags) \ #define DECLARE_PDC2026X_DEV(name_str, udma, extra_flags) \
{ \ { \
.name = name_str, \ .name = name_str, \
.init_chipset = init_chipset_pdc202xx, \ .init_chipset = init_chipset_pdc202xx, \
.init_hwif = init_hwif_pdc202xx, \ .port_ops = &pdc2026x_port_ops, \
.init_dma = init_dma_pdc202xx, \ .dma_ops = &pdc2026x_dma_ops, \
.extra = 48, \
.host_flags = IDE_HFLAGS_PDC202XX | extra_flags, \ .host_flags = IDE_HFLAGS_PDC202XX | extra_flags, \
.pio_mask = ATA_PIO4, \ .pio_mask = ATA_PIO4, \
.mwdma_mask = ATA_MWDMA2, \ .mwdma_mask = ATA_MWDMA2, \
@ -374,9 +367,8 @@ static const struct ide_port_info pdc202xx_chipsets[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "PDC20246", .name = "PDC20246",
.init_chipset = init_chipset_pdc202xx, .init_chipset = init_chipset_pdc202xx,
.init_hwif = init_hwif_pdc202xx, .port_ops = &pdc20246_port_ops,
.init_dma = init_dma_pdc202xx, .dma_ops = &pdc20246_dma_ops,
.extra = 16,
.host_flags = IDE_HFLAGS_PDC202XX, .host_flags = IDE_HFLAGS_PDC202XX,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,

13
drivers/ide/pci/piix.c
View file

@ -285,11 +285,6 @@ static u8 __devinit piix_cable_detect(ide_hwif_t *hwif)
static void __devinit init_hwif_piix(ide_hwif_t *hwif) static void __devinit init_hwif_piix(ide_hwif_t *hwif)
{ {
hwif->set_pio_mode = &piix_set_pio_mode;
hwif->set_dma_mode = &piix_set_dma_mode;
hwif->cable_detect = piix_cable_detect;
if (!hwif->dma_base) if (!hwif->dma_base)
return; return;
@ -306,6 +301,12 @@ static void __devinit init_hwif_ich(ide_hwif_t *hwif)
hwif->ide_dma_clear_irq = &piix_dma_clear_irq; hwif->ide_dma_clear_irq = &piix_dma_clear_irq;
} }
static const struct ide_port_ops piix_port_ops = {
.set_pio_mode = piix_set_pio_mode,
.set_dma_mode = piix_set_dma_mode,
.cable_detect = piix_cable_detect,
};
#ifndef CONFIG_IA64 #ifndef CONFIG_IA64
#define IDE_HFLAGS_PIIX IDE_HFLAG_LEGACY_IRQS #define IDE_HFLAGS_PIIX IDE_HFLAG_LEGACY_IRQS
#else #else
@ -317,6 +318,7 @@ static void __devinit init_hwif_ich(ide_hwif_t *hwif)
.name = name_str, \ .name = name_str, \
.init_hwif = init_hwif_piix, \ .init_hwif = init_hwif_piix, \
.enablebits = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \ .enablebits = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \
.port_ops = &piix_port_ops, \
.host_flags = IDE_HFLAGS_PIIX, \ .host_flags = IDE_HFLAGS_PIIX, \
.pio_mask = ATA_PIO4, \ .pio_mask = ATA_PIO4, \
.swdma_mask = ATA_SWDMA2_ONLY, \ .swdma_mask = ATA_SWDMA2_ONLY, \
@ -330,6 +332,7 @@ static void __devinit init_hwif_ich(ide_hwif_t *hwif)
.init_chipset = init_chipset_ich, \ .init_chipset = init_chipset_ich, \
.init_hwif = init_hwif_ich, \ .init_hwif = init_hwif_ich, \
.enablebits = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \ .enablebits = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \
.port_ops = &piix_port_ops, \
.host_flags = IDE_HFLAGS_PIIX, \ .host_flags = IDE_HFLAGS_PIIX, \
.pio_mask = ATA_PIO4, \ .pio_mask = ATA_PIO4, \
.swdma_mask = ATA_SWDMA2_ONLY, \ .swdma_mask = ATA_SWDMA2_ONLY, \

36
drivers/ide/pci/sc1200.c
View file

@ -165,7 +165,7 @@ static void sc1200_set_dma_mode(ide_drive_t *drive, const u8 mode)
* *
* returns 1 on error, 0 otherwise * returns 1 on error, 0 otherwise
*/ */
static int sc1200_ide_dma_end (ide_drive_t *drive) static int sc1200_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
unsigned long dma_base = hwif->dma_base; unsigned long dma_base = hwif->dma_base;
@ -214,7 +214,7 @@ static void sc1200_set_pio_mode(ide_drive_t *drive, const u8 pio)
printk("SC1200: %s: changing (U)DMA mode\n", drive->name); printk("SC1200: %s: changing (U)DMA mode\n", drive->name);
ide_dma_off_quietly(drive); ide_dma_off_quietly(drive);
if (ide_set_dma_mode(drive, mode) == 0 && drive->using_dma) if (ide_set_dma_mode(drive, mode) == 0 && drive->using_dma)
hwif->dma_host_set(drive, 1); hwif->dma_ops->dma_host_set(drive, 1);
return; return;
} }
@ -286,25 +286,27 @@ static int sc1200_resume (struct pci_dev *dev)
} }
#endif #endif
/* static const struct ide_port_ops sc1200_port_ops = {
* This gets invoked by the IDE driver once for each channel, .set_pio_mode = sc1200_set_pio_mode,
* and performs channel-specific pre-initialization before drive probing. .set_dma_mode = sc1200_set_dma_mode,
*/ .udma_filter = sc1200_udma_filter,
static void __devinit init_hwif_sc1200 (ide_hwif_t *hwif) };
{
hwif->set_pio_mode = &sc1200_set_pio_mode;
hwif->set_dma_mode = &sc1200_set_dma_mode;
if (hwif->dma_base == 0) static const struct ide_dma_ops sc1200_dma_ops = {
return; .dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
hwif->udma_filter = sc1200_udma_filter; .dma_exec_cmd = ide_dma_exec_cmd,
hwif->ide_dma_end = &sc1200_ide_dma_end; .dma_start = ide_dma_start,
} .dma_end = sc1200_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
static const struct ide_port_info sc1200_chipset __devinitdata = { static const struct ide_port_info sc1200_chipset __devinitdata = {
.name = "SC1200", .name = "SC1200",
.init_hwif = init_hwif_sc1200, .port_ops = &sc1200_port_ops,
.dma_ops = &sc1200_dma_ops,
.host_flags = IDE_HFLAG_SERIALIZE | .host_flags = IDE_HFLAG_SERIALIZE |
IDE_HFLAG_POST_SET_MODE | IDE_HFLAG_POST_SET_MODE |
IDE_HFLAG_ABUSE_DMA_MODES, IDE_HFLAG_ABUSE_DMA_MODES,

67
drivers/ide/pci/scc_pata.c
View file

@ -317,14 +317,14 @@ static int scc_dma_setup(ide_drive_t *drive)
/** /**
* scc_ide_dma_end - Stop DMA * scc_dma_end - Stop DMA
* @drive: IDE drive * @drive: IDE drive
* *
* Check and clear INT Status register. * Check and clear INT Status register.
* Then call __ide_dma_end(). * Then call __ide_dma_end().
*/ */
static int scc_ide_dma_end(ide_drive_t * drive) static int scc_dma_end(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
unsigned long intsts_port = hwif->dma_base + 0x014; unsigned long intsts_port = hwif->dma_base + 0x014;
@ -449,7 +449,7 @@ static int scc_dma_test_irq(ide_drive_t *drive)
if (!drive->waiting_for_dma) if (!drive->waiting_for_dma)
printk(KERN_WARNING "%s: (%s) called while not waiting\n", printk(KERN_WARNING "%s: (%s) called while not waiting\n",
drive->name, __FUNCTION__); drive->name, __func__);
return 0; return 0;
} }
@ -483,7 +483,7 @@ static int setup_mmio_scc (struct pci_dev *dev, const char *name)
unsigned long dma_size = pci_resource_len(dev, 1); unsigned long dma_size = pci_resource_len(dev, 1);
void __iomem *ctl_addr; void __iomem *ctl_addr;
void __iomem *dma_addr; void __iomem *dma_addr;
int i; int i, ret;
for (i = 0; i < MAX_HWIFS; i++) { for (i = 0; i < MAX_HWIFS; i++) {
if (scc_ports[i].ctl == 0) if (scc_ports[i].ctl == 0)
@ -492,21 +492,17 @@ static int setup_mmio_scc (struct pci_dev *dev, const char *name)
if (i >= MAX_HWIFS) if (i >= MAX_HWIFS)
return -ENOMEM; return -ENOMEM;
if (!request_mem_region(ctl_base, ctl_size, name)) { ret = pci_request_selected_regions(dev, (1 << 2) - 1, name);
printk(KERN_WARNING "%s: IDE controller MMIO ports not available.\n", SCC_PATA_NAME); if (ret < 0) {
goto fail_0; printk(KERN_ERR "%s: can't reserve resources\n", name);
} return ret;
if (!request_mem_region(dma_base, dma_size, name)) {
printk(KERN_WARNING "%s: IDE controller MMIO ports not available.\n", SCC_PATA_NAME);
goto fail_1;
} }
if ((ctl_addr = ioremap(ctl_base, ctl_size)) == NULL) if ((ctl_addr = ioremap(ctl_base, ctl_size)) == NULL)
goto fail_2; goto fail_0;
if ((dma_addr = ioremap(dma_base, dma_size)) == NULL) if ((dma_addr = ioremap(dma_base, dma_size)) == NULL)
goto fail_3; goto fail_1;
pci_set_master(dev); pci_set_master(dev);
scc_ports[i].ctl = (unsigned long)ctl_addr; scc_ports[i].ctl = (unsigned long)ctl_addr;
@ -515,12 +511,8 @@ static int setup_mmio_scc (struct pci_dev *dev, const char *name)
return 1; return 1;
fail_3:
iounmap(ctl_addr);
fail_2:
release_mem_region(dma_base, dma_size);
fail_1: fail_1:
release_mem_region(ctl_base, ctl_size); iounmap(ctl_addr);
fail_0: fail_0:
return -ENOMEM; return -ENOMEM;
} }
@ -549,7 +541,6 @@ static int scc_ide_setup_pci_device(struct pci_dev *dev,
hw.chipset = ide_pci; hw.chipset = ide_pci;
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->dev = &dev->dev; hwif->dev = &dev->dev;
hwif->cds = d;
idx[0] = hwif->index; idx[0] = hwif->index;
@ -701,26 +692,37 @@ static void __devinit init_hwif_scc(ide_hwif_t *hwif)
/* PTERADD */ /* PTERADD */
out_be32((void __iomem *)(hwif->dma_base + 0x018), hwif->dmatable_dma); out_be32((void __iomem *)(hwif->dma_base + 0x018), hwif->dmatable_dma);
hwif->dma_setup = scc_dma_setup;
hwif->ide_dma_end = scc_ide_dma_end;
hwif->set_pio_mode = scc_set_pio_mode;
hwif->set_dma_mode = scc_set_dma_mode;
hwif->ide_dma_test_irq = scc_dma_test_irq;
hwif->udma_filter = scc_udma_filter;
if (in_be32((void __iomem *)(hwif->config_data + 0xff0)) & CCKCTRL_ATACLKOEN) if (in_be32((void __iomem *)(hwif->config_data + 0xff0)) & CCKCTRL_ATACLKOEN)
hwif->ultra_mask = ATA_UDMA6; /* 133MHz */ hwif->ultra_mask = ATA_UDMA6; /* 133MHz */
else else
hwif->ultra_mask = ATA_UDMA5; /* 100MHz */ hwif->ultra_mask = ATA_UDMA5; /* 100MHz */
hwif->cable_detect = scc_cable_detect;
} }
static const struct ide_port_ops scc_port_ops = {
.set_pio_mode = scc_set_pio_mode,
.set_dma_mode = scc_set_dma_mode,
.udma_filter = scc_udma_filter,
.cable_detect = scc_cable_detect,
};
static const struct ide_dma_ops scc_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = scc_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = ide_dma_start,
.dma_end = scc_dma_end,
.dma_test_irq = scc_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
#define DECLARE_SCC_DEV(name_str) \ #define DECLARE_SCC_DEV(name_str) \
{ \ { \
.name = name_str, \ .name = name_str, \
.init_iops = init_iops_scc, \ .init_iops = init_iops_scc, \
.init_hwif = init_hwif_scc, \ .init_hwif = init_hwif_scc, \
.port_ops = &scc_port_ops, \
.dma_ops = &scc_dma_ops, \
.host_flags = IDE_HFLAG_SINGLE, \ .host_flags = IDE_HFLAG_SINGLE, \
.pio_mask = ATA_PIO4, \ .pio_mask = ATA_PIO4, \
} }
@ -754,10 +756,6 @@ static void __devexit scc_remove(struct pci_dev *dev)
{ {
struct scc_ports *ports = pci_get_drvdata(dev); struct scc_ports *ports = pci_get_drvdata(dev);
ide_hwif_t *hwif = ports->hwif; ide_hwif_t *hwif = ports->hwif;
unsigned long ctl_base = pci_resource_start(dev, 0);
unsigned long dma_base = pci_resource_start(dev, 1);
unsigned long ctl_size = pci_resource_len(dev, 0);
unsigned long dma_size = pci_resource_len(dev, 1);
if (hwif->dmatable_cpu) { if (hwif->dmatable_cpu) {
pci_free_consistent(dev, PRD_ENTRIES * PRD_BYTES, pci_free_consistent(dev, PRD_ENTRIES * PRD_BYTES,
@ -770,8 +768,7 @@ static void __devexit scc_remove(struct pci_dev *dev)
hwif->chipset = ide_unknown; hwif->chipset = ide_unknown;
iounmap((void*)ports->dma); iounmap((void*)ports->dma);
iounmap((void*)ports->ctl); iounmap((void*)ports->ctl);
release_mem_region(dma_base, dma_size); pci_release_selected_regions(dev, (1 << 2) - 1);
release_mem_region(ctl_base, ctl_size);
memset(ports, 0, sizeof(*ports)); memset(ports, 0, sizeof(*ports));
} }

33
drivers/ide/pci/serverworks.c
View file

@ -312,7 +312,7 @@ static u8 __devinit ata66_svwks_cobalt(ide_hwif_t *hwif)
return ATA_CBL_PATA40; return ATA_CBL_PATA40;
} }
static u8 __devinit ata66_svwks(ide_hwif_t *hwif) static u8 __devinit svwks_cable_detect(ide_hwif_t *hwif)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
@ -336,17 +336,18 @@ static u8 __devinit ata66_svwks(ide_hwif_t *hwif)
return ATA_CBL_PATA40; return ATA_CBL_PATA40;
} }
static void __devinit init_hwif_svwks (ide_hwif_t *hwif) static const struct ide_port_ops osb4_port_ops = {
{ .set_pio_mode = svwks_set_pio_mode,
struct pci_dev *dev = to_pci_dev(hwif->dev); .set_dma_mode = svwks_set_dma_mode,
.udma_filter = svwks_udma_filter,
};
hwif->set_pio_mode = &svwks_set_pio_mode; static const struct ide_port_ops svwks_port_ops = {
hwif->set_dma_mode = &svwks_set_dma_mode; .set_pio_mode = svwks_set_pio_mode,
hwif->udma_filter = &svwks_udma_filter; .set_dma_mode = svwks_set_dma_mode,
.udma_filter = svwks_udma_filter,
if (dev->device != PCI_DEVICE_ID_SERVERWORKS_OSB4IDE) .cable_detect = svwks_cable_detect,
hwif->cable_detect = ata66_svwks; };
}
#define IDE_HFLAGS_SVWKS \ #define IDE_HFLAGS_SVWKS \
(IDE_HFLAG_LEGACY_IRQS | \ (IDE_HFLAG_LEGACY_IRQS | \
@ -356,7 +357,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
{ /* 0 */ { /* 0 */
.name = "SvrWks OSB4", .name = "SvrWks OSB4",
.init_chipset = init_chipset_svwks, .init_chipset = init_chipset_svwks,
.init_hwif = init_hwif_svwks, .port_ops = &osb4_port_ops,
.host_flags = IDE_HFLAGS_SVWKS, .host_flags = IDE_HFLAGS_SVWKS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -364,7 +365,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
},{ /* 1 */ },{ /* 1 */
.name = "SvrWks CSB5", .name = "SvrWks CSB5",
.init_chipset = init_chipset_svwks, .init_chipset = init_chipset_svwks,
.init_hwif = init_hwif_svwks, .port_ops = &svwks_port_ops,
.host_flags = IDE_HFLAGS_SVWKS, .host_flags = IDE_HFLAGS_SVWKS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -372,7 +373,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
},{ /* 2 */ },{ /* 2 */
.name = "SvrWks CSB6", .name = "SvrWks CSB6",
.init_chipset = init_chipset_svwks, .init_chipset = init_chipset_svwks,
.init_hwif = init_hwif_svwks, .port_ops = &svwks_port_ops,
.host_flags = IDE_HFLAGS_SVWKS, .host_flags = IDE_HFLAGS_SVWKS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -380,7 +381,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
},{ /* 3 */ },{ /* 3 */
.name = "SvrWks CSB6", .name = "SvrWks CSB6",
.init_chipset = init_chipset_svwks, .init_chipset = init_chipset_svwks,
.init_hwif = init_hwif_svwks, .port_ops = &svwks_port_ops,
.host_flags = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE, .host_flags = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -388,7 +389,7 @@ static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
},{ /* 4 */ },{ /* 4 */
.name = "SvrWks HT1000", .name = "SvrWks HT1000",
.init_chipset = init_chipset_svwks, .init_chipset = init_chipset_svwks,
.init_hwif = init_hwif_svwks, .port_ops = &svwks_port_ops,
.host_flags = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE, .host_flags = IDE_HFLAGS_SVWKS | IDE_HFLAG_SINGLE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,

103
drivers/ide/pci/sgiioc4.c
View file

@ -170,10 +170,10 @@ sgiioc4_clearirq(ide_drive_t * drive)
printk(KERN_ERR printk(KERN_ERR
"%s(%s) : PCI Bus Error when doing DMA:" "%s(%s) : PCI Bus Error when doing DMA:"
" status-cmd reg is 0x%x\n", " status-cmd reg is 0x%x\n",
__FUNCTION__, drive->name, pci_stat_cmd_reg); __func__, drive->name, pci_stat_cmd_reg);
printk(KERN_ERR printk(KERN_ERR
"%s(%s) : PCI Error Address is 0x%x%x\n", "%s(%s) : PCI Error Address is 0x%x%x\n",
__FUNCTION__, drive->name, __func__, drive->name,
pci_err_addr_high, pci_err_addr_low); pci_err_addr_high, pci_err_addr_low);
/* Clear the PCI Error indicator */ /* Clear the PCI Error indicator */
pci_write_config_dword(dev, PCI_COMMAND, 0x00000146); pci_write_config_dword(dev, PCI_COMMAND, 0x00000146);
@ -188,7 +188,7 @@ sgiioc4_clearirq(ide_drive_t * drive)
return intr_reg & 3; return intr_reg & 3;
} }
static void sgiioc4_ide_dma_start(ide_drive_t * drive) static void sgiioc4_dma_start(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
unsigned long ioc4_dma_addr = hwif->dma_base + IOC4_DMA_CTRL * 4; unsigned long ioc4_dma_addr = hwif->dma_base + IOC4_DMA_CTRL * 4;
@ -215,8 +215,7 @@ sgiioc4_ide_dma_stop(ide_hwif_t *hwif, u64 dma_base)
} }
/* Stops the IOC4 DMA Engine */ /* Stops the IOC4 DMA Engine */
static int static int sgiioc4_dma_end(ide_drive_t *drive)
sgiioc4_ide_dma_end(ide_drive_t * drive)
{ {
u32 ioc4_dma, bc_dev, bc_mem, num, valid = 0, cnt = 0; u32 ioc4_dma, bc_dev, bc_mem, num, valid = 0, cnt = 0;
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
@ -232,7 +231,7 @@ sgiioc4_ide_dma_end(ide_drive_t * drive)
printk(KERN_ERR printk(KERN_ERR
"%s(%s): IOC4 DMA STOP bit is still 1 :" "%s(%s): IOC4 DMA STOP bit is still 1 :"
"ioc4_dma_reg 0x%x\n", "ioc4_dma_reg 0x%x\n",
__FUNCTION__, drive->name, ioc4_dma); __func__, drive->name, ioc4_dma);
dma_stat = 1; dma_stat = 1;
} }
@ -251,7 +250,7 @@ sgiioc4_ide_dma_end(ide_drive_t * drive)
udelay(1); udelay(1);
} }
if (!valid) { if (!valid) {
printk(KERN_ERR "%s(%s) : DMA incomplete\n", __FUNCTION__, printk(KERN_ERR "%s(%s) : DMA incomplete\n", __func__,
drive->name); drive->name);
dma_stat = 1; dma_stat = 1;
} }
@ -264,7 +263,7 @@ sgiioc4_ide_dma_end(ide_drive_t * drive)
printk(KERN_ERR printk(KERN_ERR
"%s(%s): WARNING!! byte_count_dev %d " "%s(%s): WARNING!! byte_count_dev %d "
"!= byte_count_mem %d\n", "!= byte_count_mem %d\n",
__FUNCTION__, drive->name, bc_dev, bc_mem); __func__, drive->name, bc_dev, bc_mem);
} }
} }
@ -279,8 +278,7 @@ static void sgiioc4_set_dma_mode(ide_drive_t *drive, const u8 speed)
} }
/* returns 1 if dma irq issued, 0 otherwise */ /* returns 1 if dma irq issued, 0 otherwise */
static int static int sgiioc4_dma_test_irq(ide_drive_t *drive)
sgiioc4_ide_dma_test_irq(ide_drive_t * drive)
{ {
return sgiioc4_checkirq(HWIF(drive)); return sgiioc4_checkirq(HWIF(drive));
} }
@ -294,7 +292,7 @@ static void sgiioc4_dma_host_set(ide_drive_t *drive, int on)
static void static void
sgiioc4_resetproc(ide_drive_t * drive) sgiioc4_resetproc(ide_drive_t * drive)
{ {
sgiioc4_ide_dma_end(drive); sgiioc4_dma_end(drive);
sgiioc4_clearirq(drive); sgiioc4_clearirq(drive);
} }
@ -329,13 +327,17 @@ sgiioc4_INB(unsigned long port)
/* Creates a dma map for the scatter-gather list entries */ /* Creates a dma map for the scatter-gather list entries */
static int __devinit static int __devinit
ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base) ide_dma_sgiioc4(ide_hwif_t *hwif, const struct ide_port_info *d)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
unsigned long dma_base = pci_resource_start(dev, 0) + IOC4_DMA_OFFSET;
void __iomem *virt_dma_base; void __iomem *virt_dma_base;
int num_ports = sizeof (ioc4_dma_regs_t); int num_ports = sizeof (ioc4_dma_regs_t);
void *pad; void *pad;
if (dma_base == 0)
return -1;
printk(KERN_INFO "%s: BM-DMA at 0x%04lx-0x%04lx\n", hwif->name, printk(KERN_INFO "%s: BM-DMA at 0x%04lx-0x%04lx\n", hwif->name,
dma_base, dma_base + num_ports - 1); dma_base, dma_base + num_ports - 1);
@ -343,7 +345,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
printk(KERN_ERR printk(KERN_ERR
"%s(%s) -- ERROR, Addresses 0x%p to 0x%p " "%s(%s) -- ERROR, Addresses 0x%p to 0x%p "
"ALREADY in use\n", "ALREADY in use\n",
__FUNCTION__, hwif->name, (void *) dma_base, __func__, hwif->name, (void *) dma_base,
(void *) dma_base + num_ports - 1); (void *) dma_base + num_ports - 1);
return -1; return -1;
} }
@ -352,7 +354,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
if (virt_dma_base == NULL) { if (virt_dma_base == NULL) {
printk(KERN_ERR printk(KERN_ERR
"%s(%s) -- ERROR, Unable to map addresses 0x%lx to 0x%lx\n", "%s(%s) -- ERROR, Unable to map addresses 0x%lx to 0x%lx\n",
__FUNCTION__, hwif->name, dma_base, dma_base + num_ports - 1); __func__, hwif->name, dma_base, dma_base + num_ports - 1);
goto dma_remap_failure; goto dma_remap_failure;
} }
hwif->dma_base = (unsigned long) virt_dma_base; hwif->dma_base = (unsigned long) virt_dma_base;
@ -378,7 +380,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
hwif->dmatable_cpu, hwif->dmatable_dma); hwif->dmatable_cpu, hwif->dmatable_dma);
printk(KERN_INFO printk(KERN_INFO
"%s() -- Error! Unable to allocate DMA Maps for drive %s\n", "%s() -- Error! Unable to allocate DMA Maps for drive %s\n",
__FUNCTION__, hwif->name); __func__, hwif->name);
printk(KERN_INFO printk(KERN_INFO
"Changing from DMA to PIO mode for Drive %s\n", hwif->name); "Changing from DMA to PIO mode for Drive %s\n", hwif->name);
@ -406,14 +408,14 @@ sgiioc4_configure_for_dma(int dma_direction, ide_drive_t * drive)
if (ioc4_dma & IOC4_S_DMA_ACTIVE) { if (ioc4_dma & IOC4_S_DMA_ACTIVE) {
printk(KERN_WARNING printk(KERN_WARNING
"%s(%s):Warning!! DMA from previous transfer was still active\n", "%s(%s):Warning!! DMA from previous transfer was still active\n",
__FUNCTION__, drive->name); __func__, drive->name);
writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr); writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr);
ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base); ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base);
if (ioc4_dma & IOC4_S_DMA_STOP) if (ioc4_dma & IOC4_S_DMA_STOP)
printk(KERN_ERR printk(KERN_ERR
"%s(%s) : IOC4 Dma STOP bit is still 1\n", "%s(%s) : IOC4 Dma STOP bit is still 1\n",
__FUNCTION__, drive->name); __func__, drive->name);
} }
ioc4_dma = readl((void __iomem *)ioc4_dma_addr); ioc4_dma = readl((void __iomem *)ioc4_dma_addr);
@ -421,14 +423,14 @@ sgiioc4_configure_for_dma(int dma_direction, ide_drive_t * drive)
printk(KERN_WARNING printk(KERN_WARNING
"%s(%s) : Warning!! - DMA Error during Previous" "%s(%s) : Warning!! - DMA Error during Previous"
" transfer | status 0x%x\n", " transfer | status 0x%x\n",
__FUNCTION__, drive->name, ioc4_dma); __func__, drive->name, ioc4_dma);
writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr); writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr);
ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base); ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base);
if (ioc4_dma & IOC4_S_DMA_STOP) if (ioc4_dma & IOC4_S_DMA_STOP)
printk(KERN_ERR printk(KERN_ERR
"%s(%s) : IOC4 DMA STOP bit is still 1\n", "%s(%s) : IOC4 DMA STOP bit is still 1\n",
__FUNCTION__, drive->name); __func__, drive->name);
} }
/* Address of the Scatter Gather List */ /* Address of the Scatter Gather List */
@ -519,7 +521,7 @@ sgiioc4_build_dma_table(ide_drive_t * drive, struct request *rq, int ddir)
return 0; /* revert to PIO for this request */ return 0; /* revert to PIO for this request */
} }
static int sgiioc4_ide_dma_setup(ide_drive_t *drive) static int sgiioc4_dma_setup(ide_drive_t *drive)
{ {
struct request *rq = HWGROUP(drive)->rq; struct request *rq = HWGROUP(drive)->rq;
unsigned int count = 0; unsigned int count = 0;
@ -548,45 +550,37 @@ static int sgiioc4_ide_dma_setup(ide_drive_t *drive)
return 0; return 0;
} }
static void __devinit static const struct ide_port_ops sgiioc4_port_ops = {
ide_init_sgiioc4(ide_hwif_t * hwif) .set_dma_mode = sgiioc4_set_dma_mode,
{ /* reset DMA engine, clear IRQs */
hwif->mmio = 1; .resetproc = sgiioc4_resetproc,
hwif->set_pio_mode = NULL; /* Sets timing for PIO mode */ /* mask on/off NIEN register */
hwif->set_dma_mode = &sgiioc4_set_dma_mode; .maskproc = sgiioc4_maskproc,
hwif->selectproc = NULL;/* Use the default routine to select drive */ };
hwif->reset_poll = NULL;/* No HBA specific reset_poll needed */
hwif->pre_reset = NULL; /* No HBA specific pre_set needed */
hwif->resetproc = &sgiioc4_resetproc;/* Reset DMA engine,
clear interrupts */
hwif->maskproc = &sgiioc4_maskproc; /* Mask on/off NIEN register */
hwif->quirkproc = NULL;
hwif->INB = &sgiioc4_INB; static const struct ide_dma_ops sgiioc4_dma_ops = {
.dma_host_set = sgiioc4_dma_host_set,
if (hwif->dma_base == 0) .dma_setup = sgiioc4_dma_setup,
return; .dma_start = sgiioc4_dma_start,
.dma_end = sgiioc4_dma_end,
hwif->dma_host_set = &sgiioc4_dma_host_set; .dma_test_irq = sgiioc4_dma_test_irq,
hwif->dma_setup = &sgiioc4_ide_dma_setup; .dma_lost_irq = sgiioc4_dma_lost_irq,
hwif->dma_start = &sgiioc4_ide_dma_start; .dma_timeout = ide_dma_timeout,
hwif->ide_dma_end = &sgiioc4_ide_dma_end; };
hwif->ide_dma_test_irq = &sgiioc4_ide_dma_test_irq;
hwif->dma_lost_irq = &sgiioc4_dma_lost_irq;
hwif->dma_timeout = &ide_dma_timeout;
}
static const struct ide_port_info sgiioc4_port_info __devinitdata = { static const struct ide_port_info sgiioc4_port_info __devinitdata = {
.chipset = ide_pci, .chipset = ide_pci,
.host_flags = IDE_HFLAG_NO_DMA | /* no SFF-style DMA */ .init_dma = ide_dma_sgiioc4,
IDE_HFLAG_NO_AUTOTUNE, .port_ops = &sgiioc4_port_ops,
.dma_ops = &sgiioc4_dma_ops,
.host_flags = IDE_HFLAG_NO_AUTOTUNE,
.mwdma_mask = ATA_MWDMA2_ONLY, .mwdma_mask = ATA_MWDMA2_ONLY,
}; };
static int __devinit static int __devinit
sgiioc4_ide_setup_pci_device(struct pci_dev *dev) sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
{ {
unsigned long cmd_base, dma_base, irqport; unsigned long cmd_base, irqport;
unsigned long bar0, cmd_phys_base, ctl; unsigned long bar0, cmd_phys_base, ctl;
void __iomem *virt_base; void __iomem *virt_base;
ide_hwif_t *hwif; ide_hwif_t *hwif;
@ -612,7 +606,6 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
cmd_base = (unsigned long) virt_base + IOC4_CMD_OFFSET; cmd_base = (unsigned long) virt_base + IOC4_CMD_OFFSET;
ctl = (unsigned long) virt_base + IOC4_CTRL_OFFSET; ctl = (unsigned long) virt_base + IOC4_CTRL_OFFSET;
irqport = (unsigned long) virt_base + IOC4_INTR_OFFSET; irqport = (unsigned long) virt_base + IOC4_INTR_OFFSET;
dma_base = pci_resource_start(dev, 0) + IOC4_DMA_OFFSET;
cmd_phys_base = bar0 + IOC4_CMD_OFFSET; cmd_phys_base = bar0 + IOC4_CMD_OFFSET;
if (!request_mem_region(cmd_phys_base, IOC4_CMD_CTL_BLK_SIZE, if (!request_mem_region(cmd_phys_base, IOC4_CMD_CTL_BLK_SIZE,
@ -620,7 +613,7 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
printk(KERN_ERR printk(KERN_ERR
"%s : %s -- ERROR, Addresses " "%s : %s -- ERROR, Addresses "
"0x%p to 0x%p ALREADY in use\n", "0x%p to 0x%p ALREADY in use\n",
__FUNCTION__, hwif->name, (void *) cmd_phys_base, __func__, hwif->name, (void *) cmd_phys_base,
(void *) cmd_phys_base + IOC4_CMD_CTL_BLK_SIZE); (void *) cmd_phys_base + IOC4_CMD_CTL_BLK_SIZE);
return -ENOMEM; return -ENOMEM;
} }
@ -641,13 +634,7 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
/* Initializing chipset IRQ Registers */ /* Initializing chipset IRQ Registers */
writel(0x03, (void __iomem *)(irqport + IOC4_INTR_SET * 4)); writel(0x03, (void __iomem *)(irqport + IOC4_INTR_SET * 4));
if (dma_base == 0 || ide_dma_sgiioc4(hwif, dma_base)) { hwif->INB = &sgiioc4_INB;
printk(KERN_INFO "%s: %s Bus-Master DMA disabled\n",
hwif->name, DRV_NAME);
d.mwdma_mask = 0;
}
ide_init_sgiioc4(hwif);
idx[0] = hwif->index; idx[0] = hwif->index;

114
drivers/ide/pci/siimage.c
View file

@ -301,7 +301,7 @@ static void sil_set_dma_mode(ide_drive_t *drive, const u8 speed)
} }
/* returns 1 if dma irq issued, 0 otherwise */ /* returns 1 if dma irq issued, 0 otherwise */
static int siimage_io_ide_dma_test_irq (ide_drive_t *drive) static int siimage_io_dma_test_irq(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
@ -320,14 +320,14 @@ static int siimage_io_ide_dma_test_irq (ide_drive_t *drive)
} }
/** /**
* siimage_mmio_ide_dma_test_irq - check we caused an IRQ * siimage_mmio_dma_test_irq - check we caused an IRQ
* @drive: drive we are testing * @drive: drive we are testing
* *
* Check if we caused an IDE DMA interrupt. We may also have caused * Check if we caused an IDE DMA interrupt. We may also have caused
* SATA status interrupts, if so we clean them up and continue. * SATA status interrupts, if so we clean them up and continue.
*/ */
static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive) static int siimage_mmio_dma_test_irq(ide_drive_t *drive)
{ {
ide_hwif_t *hwif = HWIF(drive); ide_hwif_t *hwif = HWIF(drive);
unsigned long addr = siimage_selreg(hwif, 0x1); unsigned long addr = siimage_selreg(hwif, 0x1);
@ -347,7 +347,7 @@ static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive)
printk(KERN_WARNING "%s: sata_error = 0x%08x, " printk(KERN_WARNING "%s: sata_error = 0x%08x, "
"watchdog = %d, %s\n", "watchdog = %d, %s\n",
drive->name, sata_error, watchdog, drive->name, sata_error, watchdog,
__FUNCTION__); __func__);
} else { } else {
watchdog = (ext_stat & 0x8000) ? 1 : 0; watchdog = (ext_stat & 0x8000) ? 1 : 0;
@ -369,6 +369,14 @@ static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive)
return 0; return 0;
} }
static int siimage_dma_test_irq(ide_drive_t *drive)
{
if (drive->hwif->mmio)
return siimage_mmio_dma_test_irq(drive);
else
return siimage_io_dma_test_irq(drive);
}
/** /**
* sil_sata_reset_poll - wait for SATA reset * sil_sata_reset_poll - wait for SATA reset
* @drive: drive we are resetting * @drive: drive we are resetting
@ -735,14 +743,14 @@ static void __devinit init_iops_siimage(ide_hwif_t *hwif)
} }
/** /**
* ata66_siimage - check for 80 pin cable * sil_cable_detect - cable detection
* @hwif: interface to check * @hwif: interface to check
* *
* Check for the presence of an ATA66 capable cable on the * Check for the presence of an ATA66 capable cable on the
* interface. * interface.
*/ */
static u8 __devinit ata66_siimage(ide_hwif_t *hwif) static u8 __devinit sil_cable_detect(ide_hwif_t *hwif)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
unsigned long addr = siimage_selreg(hwif, 0); unsigned long addr = siimage_selreg(hwif, 0);
@ -756,67 +764,44 @@ static u8 __devinit ata66_siimage(ide_hwif_t *hwif)
return (ata66 & 0x01) ? ATA_CBL_PATA80 : ATA_CBL_PATA40; return (ata66 & 0x01) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
} }
/** static const struct ide_port_ops sil_pata_port_ops = {
* init_hwif_siimage - set up hwif structs .set_pio_mode = sil_set_pio_mode,
* @hwif: interface to set up .set_dma_mode = sil_set_dma_mode,
* .quirkproc = sil_quirkproc,
* We do the basic set up of the interface structure. The SIIMAGE .udma_filter = sil_pata_udma_filter,
* requires several custom handlers so we override the default .cable_detect = sil_cable_detect,
* ide DMA handlers appropriately };
*/
static void __devinit init_hwif_siimage(ide_hwif_t *hwif) static const struct ide_port_ops sil_sata_port_ops = {
{ .set_pio_mode = sil_set_pio_mode,
u8 sata = is_sata(hwif); .set_dma_mode = sil_set_dma_mode,
.reset_poll = sil_sata_reset_poll,
.pre_reset = sil_sata_pre_reset,
.quirkproc = sil_quirkproc,
.udma_filter = sil_sata_udma_filter,
.cable_detect = sil_cable_detect,
};
hwif->set_pio_mode = &sil_set_pio_mode; static struct ide_dma_ops sil_dma_ops = {
hwif->set_dma_mode = &sil_set_dma_mode; .dma_test_irq = siimage_dma_test_irq,
hwif->quirkproc = &sil_quirkproc; };
if (sata) { #define DECLARE_SII_DEV(name_str, p_ops) \
static int first = 1;
hwif->reset_poll = &sil_sata_reset_poll;
hwif->pre_reset = &sil_sata_pre_reset;
hwif->udma_filter = &sil_sata_udma_filter;
if (first) {
printk(KERN_INFO "siimage: For full SATA support you should use the libata sata_sil module.\n");
first = 0;
}
} else
hwif->udma_filter = &sil_pata_udma_filter;
hwif->cable_detect = ata66_siimage;
if (hwif->dma_base == 0)
return;
if (sata)
hwif->host_flags |= IDE_HFLAG_NO_ATAPI_DMA;
if (hwif->mmio) {
hwif->ide_dma_test_irq = &siimage_mmio_ide_dma_test_irq;
} else {
hwif->ide_dma_test_irq = & siimage_io_ide_dma_test_irq;
}
}
#define DECLARE_SII_DEV(name_str) \
{ \ { \
.name = name_str, \ .name = name_str, \
.init_chipset = init_chipset_siimage, \ .init_chipset = init_chipset_siimage, \
.init_iops = init_iops_siimage, \ .init_iops = init_iops_siimage, \
.init_hwif = init_hwif_siimage, \ .port_ops = p_ops, \
.dma_ops = &sil_dma_ops, \
.pio_mask = ATA_PIO4, \ .pio_mask = ATA_PIO4, \
.mwdma_mask = ATA_MWDMA2, \ .mwdma_mask = ATA_MWDMA2, \
.udma_mask = ATA_UDMA6, \ .udma_mask = ATA_UDMA6, \
} }
static const struct ide_port_info siimage_chipsets[] __devinitdata = { static const struct ide_port_info siimage_chipsets[] __devinitdata = {
/* 0 */ DECLARE_SII_DEV("SiI680"), /* 0 */ DECLARE_SII_DEV("SiI680", &sil_pata_port_ops),
/* 1 */ DECLARE_SII_DEV("SiI3112 Serial ATA"), /* 1 */ DECLARE_SII_DEV("SiI3112 Serial ATA", &sil_sata_port_ops),
/* 2 */ DECLARE_SII_DEV("Adaptec AAR-1210SA") /* 2 */ DECLARE_SII_DEV("Adaptec AAR-1210SA", &sil_sata_port_ops)
}; };
/** /**
@ -830,7 +815,24 @@ static const struct ide_port_info siimage_chipsets[] __devinitdata = {
static int __devinit siimage_init_one(struct pci_dev *dev, const struct pci_device_id *id) static int __devinit siimage_init_one(struct pci_dev *dev, const struct pci_device_id *id)
{ {
return ide_setup_pci_device(dev, &siimage_chipsets[id->driver_data]); struct ide_port_info d;
u8 idx = id->driver_data;
d = siimage_chipsets[idx];
if (idx) {
static int first = 1;
if (first) {
printk(KERN_INFO "siimage: For full SATA support you "
"should use the libata sata_sil module.\n");
first = 0;
}
d.host_flags |= IDE_HFLAG_NO_ATAPI_DMA;
}
return ide_setup_pci_device(dev, &d);
} }
static const struct pci_device_id siimage_pci_tbl[] = { static const struct pci_device_id siimage_pci_tbl[] = {

30
drivers/ide/pci/sis5513.c
View file

@ -347,7 +347,7 @@ static void sis_set_dma_mode(ide_drive_t *drive, const u8 speed)
sis_program_timings(drive, speed); sis_program_timings(drive, speed);
} }
static u8 sis5513_ata133_udma_filter(ide_drive_t *drive) static u8 sis_ata133_udma_filter(ide_drive_t *drive)
{ {
struct pci_dev *dev = to_pci_dev(drive->hwif->dev); struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
u32 regdw = 0; u32 regdw = 0;
@ -514,7 +514,7 @@ static const struct sis_laptop sis_laptop[] = {
{ 0, } { 0, }
}; };
static u8 __devinit ata66_sis5513(ide_hwif_t *hwif) static u8 __devinit sis_cable_detect(ide_hwif_t *hwif)
{ {
struct pci_dev *pdev = to_pci_dev(hwif->dev); struct pci_dev *pdev = to_pci_dev(hwif->dev);
const struct sis_laptop *lap = &sis_laptop[0]; const struct sis_laptop *lap = &sis_laptop[0];
@ -543,21 +543,22 @@ static u8 __devinit ata66_sis5513(ide_hwif_t *hwif)
return ata66 ? ATA_CBL_PATA80 : ATA_CBL_PATA40; return ata66 ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
} }
static void __devinit init_hwif_sis5513(ide_hwif_t *hwif) static const struct ide_port_ops sis_port_ops = {
{ .set_pio_mode = sis_set_pio_mode,
hwif->set_pio_mode = &sis_set_pio_mode; .set_dma_mode = sis_set_dma_mode,
hwif->set_dma_mode = &sis_set_dma_mode; .cable_detect = sis_cable_detect,
};
if (chipset_family >= ATA_133) static const struct ide_port_ops sis_ata133_port_ops = {
hwif->udma_filter = sis5513_ata133_udma_filter; .set_pio_mode = sis_set_pio_mode,
.set_dma_mode = sis_set_dma_mode,
hwif->cable_detect = ata66_sis5513; .udma_filter = sis_ata133_udma_filter,
} .cable_detect = sis_cable_detect,
};
static const struct ide_port_info sis5513_chipset __devinitdata = { static const struct ide_port_info sis5513_chipset __devinitdata = {
.name = "SIS5513", .name = "SIS5513",
.init_chipset = init_chipset_sis5513, .init_chipset = init_chipset_sis5513,
.init_hwif = init_hwif_sis5513,
.enablebits = { {0x4a, 0x02, 0x02}, {0x4a, 0x04, 0x04} }, .enablebits = { {0x4a, 0x02, 0x02}, {0x4a, 0x04, 0x04} },
.host_flags = IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_NO_AUTODMA, .host_flags = IDE_HFLAG_LEGACY_IRQS | IDE_HFLAG_NO_AUTODMA,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
@ -572,6 +573,11 @@ static int __devinit sis5513_init_one(struct pci_dev *dev, const struct pci_devi
if (sis_find_family(dev) == 0) if (sis_find_family(dev) == 0)
return -ENOTSUPP; return -ENOTSUPP;
if (chipset_family >= ATA_133)
d.port_ops = &sis_ata133_port_ops;
else
d.port_ops = &sis_port_ops;
d.udma_mask = udma_rates[chipset_family]; d.udma_mask = udma_rates[chipset_family];
return ide_setup_pci_device(dev, &d); return ide_setup_pci_device(dev, &d);

80
drivers/ide/pci/sl82c105.c
View file

@ -179,7 +179,7 @@ static void sl82c105_dma_start(ide_drive_t *drive)
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
int reg = 0x44 + drive->dn * 4; int reg = 0x44 + drive->dn * 4;
DBG(("%s(drive:%s)\n", __FUNCTION__, drive->name)); DBG(("%s(drive:%s)\n", __func__, drive->name));
pci_write_config_word(dev, reg, drive->drive_data >> 16); pci_write_config_word(dev, reg, drive->drive_data >> 16);
@ -203,7 +203,7 @@ static int sl82c105_dma_end(ide_drive_t *drive)
int reg = 0x44 + drive->dn * 4; int reg = 0x44 + drive->dn * 4;
int ret; int ret;
DBG(("%s(drive:%s)\n", __FUNCTION__, drive->name)); DBG(("%s(drive:%s)\n", __func__, drive->name));
ret = __ide_dma_end(drive); ret = __ide_dma_end(drive);
@ -232,7 +232,7 @@ static void sl82c105_resetproc(ide_drive_t *drive)
* Return the revision of the Winbond bridge * Return the revision of the Winbond bridge
* which this function is part of. * which this function is part of.
*/ */
static unsigned int sl82c105_bridge_revision(struct pci_dev *dev) static u8 sl82c105_bridge_revision(struct pci_dev *dev)
{ {
struct pci_dev *bridge; struct pci_dev *bridge;
@ -282,63 +282,59 @@ static unsigned int __devinit init_chipset_sl82c105(struct pci_dev *dev, const c
return dev->irq; return dev->irq;
} }
/* static const struct ide_port_ops sl82c105_port_ops = {
* Initialise IDE channel .set_pio_mode = sl82c105_set_pio_mode,
*/ .set_dma_mode = sl82c105_set_dma_mode,
static void __devinit init_hwif_sl82c105(ide_hwif_t *hwif) .resetproc = sl82c105_resetproc,
{ };
struct pci_dev *dev = to_pci_dev(hwif->dev);
unsigned int rev;
DBG(("init_hwif_sl82c105(hwif: ide%d)\n", hwif->index)); static const struct ide_dma_ops sl82c105_dma_ops = {
.dma_host_set = ide_dma_host_set,
hwif->set_pio_mode = &sl82c105_set_pio_mode; .dma_setup = ide_dma_setup,
hwif->set_dma_mode = &sl82c105_set_dma_mode; .dma_exec_cmd = ide_dma_exec_cmd,
hwif->resetproc = &sl82c105_resetproc; .dma_start = sl82c105_dma_start,
.dma_end = sl82c105_dma_end,
if (!hwif->dma_base) .dma_test_irq = ide_dma_test_irq,
return; .dma_lost_irq = sl82c105_dma_lost_irq,
.dma_timeout = sl82c105_dma_timeout,
rev = sl82c105_bridge_revision(dev); };
if (rev <= 5) {
/*
* Never ever EVER under any circumstances enable
* DMA when the bridge is this old.
*/
printk(" %s: Winbond W83C553 bridge revision %d, "
"BM-DMA disabled\n", hwif->name, rev);
return;
}
hwif->mwdma_mask = ATA_MWDMA2;
hwif->dma_lost_irq = &sl82c105_dma_lost_irq;
hwif->dma_start = &sl82c105_dma_start;
hwif->ide_dma_end = &sl82c105_dma_end;
hwif->dma_timeout = &sl82c105_dma_timeout;
if (hwif->mate)
hwif->serialized = hwif->mate->serialized = 1;
}
static const struct ide_port_info sl82c105_chipset __devinitdata = { static const struct ide_port_info sl82c105_chipset __devinitdata = {
.name = "W82C105", .name = "W82C105",
.init_chipset = init_chipset_sl82c105, .init_chipset = init_chipset_sl82c105,
.init_hwif = init_hwif_sl82c105,
.enablebits = {{0x40,0x01,0x01}, {0x40,0x10,0x10}}, .enablebits = {{0x40,0x01,0x01}, {0x40,0x10,0x10}},
.port_ops = &sl82c105_port_ops,
.dma_ops = &sl82c105_dma_ops,
.host_flags = IDE_HFLAG_IO_32BIT | .host_flags = IDE_HFLAG_IO_32BIT |
IDE_HFLAG_UNMASK_IRQS | IDE_HFLAG_UNMASK_IRQS |
/* FIXME: check for Compatibility mode in generic IDE PCI code */ /* FIXME: check for Compatibility mode in generic IDE PCI code */
#if defined(CONFIG_LOPEC) || defined(CONFIG_SANDPOINT) #if defined(CONFIG_LOPEC) || defined(CONFIG_SANDPOINT)
IDE_HFLAG_FORCE_LEGACY_IRQS | IDE_HFLAG_FORCE_LEGACY_IRQS |
#endif #endif
IDE_HFLAG_SERIALIZE_DMA |
IDE_HFLAG_NO_AUTODMA, IDE_HFLAG_NO_AUTODMA,
.pio_mask = ATA_PIO5, .pio_mask = ATA_PIO5,
.mwdma_mask = ATA_MWDMA2,
}; };
static int __devinit sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id) static int __devinit sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id)
{ {
return ide_setup_pci_device(dev, &sl82c105_chipset); struct ide_port_info d = sl82c105_chipset;
u8 rev = sl82c105_bridge_revision(dev);
if (rev <= 5) {
/*
* Never ever EVER under any circumstances enable
* DMA when the bridge is this old.
*/
printk(KERN_INFO "W82C105_IDE: Winbond W83C553 bridge "
"revision %d, BM-DMA disabled\n", rev);
d.dma_ops = NULL;
d.mwdma_mask = 0;
d.host_flags &= ~IDE_HFLAG_SERIALIZE_DMA;
}
return ide_setup_pci_device(dev, &d);
} }
static const struct pci_device_id sl82c105_pci_tbl[] = { static const struct pci_device_id sl82c105_pci_tbl[] = {

14
drivers/ide/pci/slc90e66.c
View file

@ -125,18 +125,16 @@ static u8 __devinit slc90e66_cable_detect(ide_hwif_t *hwif)
return (reg47 & mask) ? ATA_CBL_PATA40 : ATA_CBL_PATA80; return (reg47 & mask) ? ATA_CBL_PATA40 : ATA_CBL_PATA80;
} }
static void __devinit init_hwif_slc90e66(ide_hwif_t *hwif) static const struct ide_port_ops slc90e66_port_ops = {
{ .set_pio_mode = slc90e66_set_pio_mode,
hwif->set_pio_mode = &slc90e66_set_pio_mode; .set_dma_mode = slc90e66_set_dma_mode,
hwif->set_dma_mode = &slc90e66_set_dma_mode; .cable_detect = slc90e66_cable_detect,
};
hwif->cable_detect = slc90e66_cable_detect;
}
static const struct ide_port_info slc90e66_chipset __devinitdata = { static const struct ide_port_info slc90e66_chipset __devinitdata = {
.name = "SLC90E66", .name = "SLC90E66",
.init_hwif = init_hwif_slc90e66,
.enablebits = { {0x41, 0x80, 0x80}, {0x43, 0x80, 0x80} }, .enablebits = { {0x41, 0x80, 0x80}, {0x43, 0x80, 0x80} },
.port_ops = &slc90e66_port_ops,
.host_flags = IDE_HFLAG_LEGACY_IRQS, .host_flags = IDE_HFLAG_LEGACY_IRQS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.swdma_mask = ATA_SWDMA2_ONLY, .swdma_mask = ATA_SWDMA2_ONLY,

26
drivers/ide/pci/tc86c001.c
View file

@ -157,11 +157,6 @@ static void __devinit init_hwif_tc86c001(ide_hwif_t *hwif)
/* Store the system control register base for convenience... */ /* Store the system control register base for convenience... */
hwif->config_data = sc_base; hwif->config_data = sc_base;
hwif->set_pio_mode = &tc86c001_set_pio_mode;
hwif->set_dma_mode = &tc86c001_set_mode;
hwif->cable_detect = tc86c001_cable_detect;
if (!hwif->dma_base) if (!hwif->dma_base)
return; return;
@ -173,8 +168,6 @@ static void __devinit init_hwif_tc86c001(ide_hwif_t *hwif)
/* Sector Count Register limit */ /* Sector Count Register limit */
hwif->rqsize = 0xffff; hwif->rqsize = 0xffff;
hwif->dma_start = &tc86c001_dma_start;
} }
static unsigned int __devinit init_chipset_tc86c001(struct pci_dev *dev, static unsigned int __devinit init_chipset_tc86c001(struct pci_dev *dev,
@ -187,10 +180,29 @@ static unsigned int __devinit init_chipset_tc86c001(struct pci_dev *dev,
return err; return err;
} }
static const struct ide_port_ops tc86c001_port_ops = {
.set_pio_mode = tc86c001_set_pio_mode,
.set_dma_mode = tc86c001_set_mode,
.cable_detect = tc86c001_cable_detect,
};
static const struct ide_dma_ops tc86c001_dma_ops = {
.dma_host_set = ide_dma_host_set,
.dma_setup = ide_dma_setup,
.dma_exec_cmd = ide_dma_exec_cmd,
.dma_start = tc86c001_dma_start,
.dma_end = __ide_dma_end,
.dma_test_irq = ide_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
static const struct ide_port_info tc86c001_chipset __devinitdata = { static const struct ide_port_info tc86c001_chipset __devinitdata = {
.name = "TC86C001", .name = "TC86C001",
.init_chipset = init_chipset_tc86c001, .init_chipset = init_chipset_tc86c001,
.init_hwif = init_hwif_tc86c001, .init_hwif = init_hwif_tc86c001,
.port_ops = &tc86c001_port_ops,
.dma_ops = &tc86c001_dma_ops,
.host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_OFF_BOARD | .host_flags = IDE_HFLAG_SINGLE | IDE_HFLAG_OFF_BOARD |
IDE_HFLAG_ABUSE_SET_DMA_MODE, IDE_HFLAG_ABUSE_SET_DMA_MODE,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,

11
drivers/ide/pci/triflex.c
View file

@ -87,16 +87,15 @@ static void triflex_set_pio_mode(ide_drive_t *drive, const u8 pio)
triflex_set_mode(drive, XFER_PIO_0 + pio); triflex_set_mode(drive, XFER_PIO_0 + pio);
} }
static void __devinit init_hwif_triflex(ide_hwif_t *hwif) static const struct ide_port_ops triflex_port_ops = {
{ .set_pio_mode = triflex_set_pio_mode,
hwif->set_pio_mode = &triflex_set_pio_mode; .set_dma_mode = triflex_set_mode,
hwif->set_dma_mode = &triflex_set_mode; };
}
static const struct ide_port_info triflex_device __devinitdata = { static const struct ide_port_info triflex_device __devinitdata = {
.name = "TRIFLEX", .name = "TRIFLEX",
.init_hwif = init_hwif_triflex,
.enablebits = {{0x80, 0x01, 0x01}, {0x80, 0x02, 0x02}}, .enablebits = {{0x80, 0x01, 0x01}, {0x80, 0x02, 0x02}},
.port_ops = &triflex_port_ops,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.swdma_mask = ATA_SWDMA2, .swdma_mask = ATA_SWDMA2,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,

44
drivers/ide/pci/trm290.c
View file

@ -214,7 +214,7 @@ static void trm290_dma_start(ide_drive_t *drive)
{ {
} }
static int trm290_ide_dma_end (ide_drive_t *drive) static int trm290_dma_end(ide_drive_t *drive)
{ {
u16 status; u16 status;
@ -225,7 +225,7 @@ static int trm290_ide_dma_end (ide_drive_t *drive)
return status != 0x00ff; return status != 0x00ff;
} }
static int trm290_ide_dma_test_irq (ide_drive_t *drive) static int trm290_dma_test_irq(ide_drive_t *drive)
{ {
u16 status; u16 status;
@ -254,22 +254,11 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
hwif->config_data = cfg_base; hwif->config_data = cfg_base;
hwif->dma_base = (cfg_base + 4) ^ (hwif->channel ? 0x80 : 0); hwif->dma_base = (cfg_base + 4) ^ (hwif->channel ? 0x80 : 0);
printk(KERN_INFO " %s: BM-DMA at 0x%04lx-0x%04lx", printk(KERN_INFO " %s: BM-DMA at 0x%04lx-0x%04lx\n",
hwif->name, hwif->dma_base, hwif->dma_base + 3); hwif->name, hwif->dma_base, hwif->dma_base + 3);
if (!request_region(hwif->dma_base, 4, hwif->name)) { if (ide_allocate_dma_engine(hwif))
printk(KERN_CONT " -- Error, ports in use.\n");
return; return;
}
hwif->dmatable_cpu = pci_alloc_consistent(dev, PRD_ENTRIES * PRD_BYTES,
&hwif->dmatable_dma);
if (!hwif->dmatable_cpu) {
printk(KERN_CONT " -- Error, unable to allocate DMA table.\n");
release_region(hwif->dma_base, 4);
return;
}
printk(KERN_CONT "\n");
local_irq_save(flags); local_irq_save(flags);
/* put config reg into first byte of hwif->select_data */ /* put config reg into first byte of hwif->select_data */
@ -291,14 +280,6 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
/* sharing IRQ with mate */ /* sharing IRQ with mate */
hwif->irq = hwif->mate->irq; hwif->irq = hwif->mate->irq;
hwif->dma_host_set = &trm290_dma_host_set;
hwif->dma_setup = &trm290_dma_setup;
hwif->dma_exec_cmd = &trm290_dma_exec_cmd;
hwif->dma_start = &trm290_dma_start;
hwif->ide_dma_end = &trm290_ide_dma_end;
hwif->ide_dma_test_irq = &trm290_ide_dma_test_irq;
hwif->selectproc = &trm290_selectproc;
#if 1 #if 1
{ {
/* /*
@ -328,10 +309,27 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
#endif #endif
} }
static const struct ide_port_ops trm290_port_ops = {
.selectproc = trm290_selectproc,
};
static struct ide_dma_ops trm290_dma_ops = {
.dma_host_set = trm290_dma_host_set,
.dma_setup = trm290_dma_setup,
.dma_exec_cmd = trm290_dma_exec_cmd,
.dma_start = trm290_dma_start,
.dma_end = trm290_dma_end,
.dma_test_irq = trm290_dma_test_irq,
.dma_lost_irq = ide_dma_lost_irq,
.dma_timeout = ide_dma_timeout,
};
static const struct ide_port_info trm290_chipset __devinitdata = { static const struct ide_port_info trm290_chipset __devinitdata = {
.name = "TRM290", .name = "TRM290",
.init_hwif = init_hwif_trm290, .init_hwif = init_hwif_trm290,
.chipset = ide_trm290, .chipset = ide_trm290,
.port_ops = &trm290_port_ops,
.dma_ops = &trm290_dma_ops,
.host_flags = IDE_HFLAG_NO_ATAPI_DMA | .host_flags = IDE_HFLAG_NO_ATAPI_DMA |
#if 0 /* play it safe for now */ #if 0 /* play it safe for now */
IDE_HFLAG_TRUST_BIOS_FOR_DMA | IDE_HFLAG_TRUST_BIOS_FOR_DMA |

14
drivers/ide/pci/via82cxxx.c
View file

@ -415,19 +415,17 @@ static u8 __devinit via82cxxx_cable_detect(ide_hwif_t *hwif)
return ATA_CBL_PATA40; return ATA_CBL_PATA40;
} }
static void __devinit init_hwif_via82cxxx(ide_hwif_t *hwif) static const struct ide_port_ops via_port_ops = {
{ .set_pio_mode = via_set_pio_mode,
hwif->set_pio_mode = &via_set_pio_mode; .set_dma_mode = via_set_drive,
hwif->set_dma_mode = &via_set_drive; .cable_detect = via82cxxx_cable_detect,
};
hwif->cable_detect = via82cxxx_cable_detect;
}
static const struct ide_port_info via82cxxx_chipset __devinitdata = { static const struct ide_port_info via82cxxx_chipset __devinitdata = {
.name = "VP_IDE", .name = "VP_IDE",
.init_chipset = init_chipset_via82cxxx, .init_chipset = init_chipset_via82cxxx,
.init_hwif = init_hwif_via82cxxx,
.enablebits = { { 0x40, 0x02, 0x02 }, { 0x40, 0x01, 0x01 } }, .enablebits = { { 0x40, 0x02, 0x02 }, { 0x40, 0x01, 0x01 } },
.port_ops = &via_port_ops,
.host_flags = IDE_HFLAG_PIO_NO_BLACKLIST | .host_flags = IDE_HFLAG_PIO_NO_BLACKLIST |
IDE_HFLAG_ABUSE_SET_DMA_MODE | IDE_HFLAG_ABUSE_SET_DMA_MODE |
IDE_HFLAG_POST_SET_MODE | IDE_HFLAG_POST_SET_MODE |

12
drivers/ide/ppc/mpc8xx.c
View file

@ -438,10 +438,14 @@ static void m8xx_ide_set_pio_mode(ide_drive_t *drive, const u8 pio)
#elif defined(CONFIG_IDE_EXT_DIRECT) #elif defined(CONFIG_IDE_EXT_DIRECT)
printk("%s[%d] %s: not implemented yet!\n", printk("%s[%d] %s: not implemented yet!\n",
__FILE__,__LINE__,__FUNCTION__); __FILE__, __LINE__, __func__);
#endif /* defined(CONFIG_IDE_8xx_PCCARD) || defined(CONFIG_IDE_8xx_PCMCIA */ #endif /* defined(CONFIG_IDE_8xx_PCCARD) || defined(CONFIG_IDE_8xx_PCMCIA */
} }
static const struct ide_port_ops m8xx_port_ops = {
.set_pio_mode = m8xx_ide_set_pio_mode,
};
static void static void
ide_interrupt_ack (void *dev) ide_interrupt_ack (void *dev)
{ {
@ -810,9 +814,8 @@ static int __init mpc8xx_ide_probe(void)
ide_hwif_t *hwif = &ide_hwifs[0]; ide_hwif_t *hwif = &ide_hwifs[0];
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->mmio = 1;
hwif->pio_mask = ATA_PIO4; hwif->pio_mask = ATA_PIO4;
hwif->set_pio_mode = m8xx_ide_set_pio_mode; hwif->port_ops = &m8xx_port_ops;
idx[0] = 0; idx[0] = 0;
} }
@ -822,9 +825,8 @@ static int __init mpc8xx_ide_probe(void)
ide_hwif_t *mate = &ide_hwifs[1]; ide_hwif_t *mate = &ide_hwifs[1];
ide_init_port_hw(mate, &hw); ide_init_port_hw(mate, &hw);
mate->mmio = 1;
mate->pio_mask = ATA_PIO4; mate->pio_mask = ATA_PIO4;
mate->set_pio_mode = m8xx_ide_set_pio_mode; mate->port_ops = &m8xx_port_ops;
idx[1] = 1; idx[1] = 1;
} }

86
drivers/ide/ppc/pmac.c
View file

@ -409,7 +409,7 @@ kauai_lookup_timing(struct kauai_timing* table, int cycle_time)
*/ */
#define IDE_WAKEUP_DELAY (1*HZ) #define IDE_WAKEUP_DELAY (1*HZ)
static int pmac_ide_setup_dma(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif); static int pmac_ide_init_dma(ide_hwif_t *, const struct ide_port_info *);
static int pmac_ide_build_dmatable(ide_drive_t *drive, struct request *rq); static int pmac_ide_build_dmatable(ide_drive_t *drive, struct request *rq);
static void pmac_ide_selectproc(ide_drive_t *drive); static void pmac_ide_selectproc(ide_drive_t *drive);
static void pmac_ide_kauai_selectproc(ide_drive_t *drive); static void pmac_ide_kauai_selectproc(ide_drive_t *drive);
@ -918,11 +918,29 @@ pmac_ide_do_resume(ide_hwif_t *hwif)
return 0; return 0;
} }
static const struct ide_port_ops pmac_ide_ata6_port_ops = {
.set_pio_mode = pmac_ide_set_pio_mode,
.set_dma_mode = pmac_ide_set_dma_mode,
.selectproc = pmac_ide_kauai_selectproc,
};
static const struct ide_port_ops pmac_ide_port_ops = {
.set_pio_mode = pmac_ide_set_pio_mode,
.set_dma_mode = pmac_ide_set_dma_mode,
.selectproc = pmac_ide_selectproc,
};
static const struct ide_dma_ops pmac_dma_ops;
static const struct ide_port_info pmac_port_info = { static const struct ide_port_info pmac_port_info = {
.init_dma = pmac_ide_init_dma,
.chipset = ide_pmac, .chipset = ide_pmac,
#ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
.dma_ops = &pmac_dma_ops,
#endif
.port_ops = &pmac_ide_port_ops,
.host_flags = IDE_HFLAG_SET_PIO_MODE_KEEP_DMA | .host_flags = IDE_HFLAG_SET_PIO_MODE_KEEP_DMA |
IDE_HFLAG_POST_SET_MODE | IDE_HFLAG_POST_SET_MODE |
IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
IDE_HFLAG_UNMASK_IRQS, IDE_HFLAG_UNMASK_IRQS,
.pio_mask = ATA_PIO4, .pio_mask = ATA_PIO4,
.mwdma_mask = ATA_MWDMA2, .mwdma_mask = ATA_MWDMA2,
@ -947,12 +965,15 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif, hw_regs_t *hw)
pmif->broken_dma = pmif->broken_dma_warn = 0; pmif->broken_dma = pmif->broken_dma_warn = 0;
if (of_device_is_compatible(np, "shasta-ata")) { if (of_device_is_compatible(np, "shasta-ata")) {
pmif->kind = controller_sh_ata6; pmif->kind = controller_sh_ata6;
d.port_ops = &pmac_ide_ata6_port_ops;
d.udma_mask = ATA_UDMA6; d.udma_mask = ATA_UDMA6;
} else if (of_device_is_compatible(np, "kauai-ata")) { } else if (of_device_is_compatible(np, "kauai-ata")) {
pmif->kind = controller_un_ata6; pmif->kind = controller_un_ata6;
d.port_ops = &pmac_ide_ata6_port_ops;
d.udma_mask = ATA_UDMA5; d.udma_mask = ATA_UDMA5;
} else if (of_device_is_compatible(np, "K2-UATA")) { } else if (of_device_is_compatible(np, "K2-UATA")) {
pmif->kind = controller_k2_ata6; pmif->kind = controller_k2_ata6;
d.port_ops = &pmac_ide_ata6_port_ops;
d.udma_mask = ATA_UDMA5; d.udma_mask = ATA_UDMA5;
} else if (of_device_is_compatible(np, "keylargo-ata")) { } else if (of_device_is_compatible(np, "keylargo-ata")) {
if (strcmp(np->name, "ata-4") == 0) { if (strcmp(np->name, "ata-4") == 0) {
@ -1029,37 +1050,29 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif, hw_regs_t *hw)
default_hwif_mmiops(hwif); default_hwif_mmiops(hwif);
hwif->OUTBSYNC = pmac_outbsync; hwif->OUTBSYNC = pmac_outbsync;
/* Tell common code _not_ to mess with resources */
hwif->mmio = 1;
hwif->hwif_data = pmif; hwif->hwif_data = pmif;
ide_init_port_hw(hwif, hw); ide_init_port_hw(hwif, hw);
hwif->noprobe = pmif->mediabay;
hwif->cbl = pmif->cable_80 ? ATA_CBL_PATA80 : ATA_CBL_PATA40; hwif->cbl = pmif->cable_80 ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
hwif->set_pio_mode = pmac_ide_set_pio_mode;
if (pmif->kind == controller_un_ata6
|| pmif->kind == controller_k2_ata6
|| pmif->kind == controller_sh_ata6)
hwif->selectproc = pmac_ide_kauai_selectproc;
else
hwif->selectproc = pmac_ide_selectproc;
hwif->set_dma_mode = pmac_ide_set_dma_mode;
printk(KERN_INFO "ide%d: Found Apple %s controller, bus ID %d%s, irq %d\n", printk(KERN_INFO "ide%d: Found Apple %s controller, bus ID %d%s, irq %d\n",
hwif->index, model_name[pmif->kind], pmif->aapl_bus_id, hwif->index, model_name[pmif->kind], pmif->aapl_bus_id,
pmif->mediabay ? " (mediabay)" : "", hwif->irq); pmif->mediabay ? " (mediabay)" : "", hwif->irq);
if (pmif->mediabay) {
#ifdef CONFIG_PMAC_MEDIABAY #ifdef CONFIG_PMAC_MEDIABAY
if (pmif->mediabay && check_media_bay_by_base(pmif->regbase, MB_CD) == 0) if (check_media_bay_by_base(pmif->regbase, MB_CD)) {
hwif->noprobe = 0; #else
#endif /* CONFIG_PMAC_MEDIABAY */ if (1) {
#endif
hwif->drives[0].noprobe = 1;
hwif->drives[1].noprobe = 1;
}
}
#ifdef CONFIG_BLK_DEV_IDEDMA_PMAC #ifdef CONFIG_BLK_DEV_IDEDMA_PMAC
if (pmif->cable_80 == 0) if (pmif->cable_80 == 0)
d.udma_mask &= ATA_UDMA2; d.udma_mask &= ATA_UDMA2;
/* has a DBDMA controller channel */
if (pmif->dma_regs == 0 || pmac_ide_setup_dma(pmif, hwif) < 0)
#endif #endif
d.udma_mask = d.mwdma_mask = 0;
idx[0] = hwif->index; idx[0] = hwif->index;
@ -1662,18 +1675,31 @@ pmac_ide_dma_lost_irq (ide_drive_t *drive)
printk(KERN_ERR "ide-pmac lost interrupt, dma status: %lx\n", status); printk(KERN_ERR "ide-pmac lost interrupt, dma status: %lx\n", status);
} }
static const struct ide_dma_ops pmac_dma_ops = {
.dma_host_set = pmac_ide_dma_host_set,
.dma_setup = pmac_ide_dma_setup,
.dma_exec_cmd = pmac_ide_dma_exec_cmd,
.dma_start = pmac_ide_dma_start,
.dma_end = pmac_ide_dma_end,
.dma_test_irq = pmac_ide_dma_test_irq,
.dma_timeout = ide_dma_timeout,
.dma_lost_irq = pmac_ide_dma_lost_irq,
};
/* /*
* Allocate the data structures needed for using DMA with an interface * Allocate the data structures needed for using DMA with an interface
* and fill the proper list of functions pointers * and fill the proper list of functions pointers
*/ */
static int __devinit pmac_ide_setup_dma(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif) static int __devinit pmac_ide_init_dma(ide_hwif_t *hwif,
const struct ide_port_info *d)
{ {
pmac_ide_hwif_t *pmif = (pmac_ide_hwif_t *)hwif->hwif_data;
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
/* We won't need pci_dev if we switch to generic consistent /* We won't need pci_dev if we switch to generic consistent
* DMA routines ... * DMA routines ...
*/ */
if (dev == NULL) if (dev == NULL || pmif->dma_regs == 0)
return -ENODEV; return -ENODEV;
/* /*
* Allocate space for the DBDMA commands. * Allocate space for the DBDMA commands.
@ -1692,18 +1718,14 @@ static int __devinit pmac_ide_setup_dma(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
hwif->sg_max_nents = MAX_DCMDS; hwif->sg_max_nents = MAX_DCMDS;
hwif->dma_host_set = &pmac_ide_dma_host_set;
hwif->dma_setup = &pmac_ide_dma_setup;
hwif->dma_exec_cmd = &pmac_ide_dma_exec_cmd;
hwif->dma_start = &pmac_ide_dma_start;
hwif->ide_dma_end = &pmac_ide_dma_end;
hwif->ide_dma_test_irq = &pmac_ide_dma_test_irq;
hwif->dma_timeout = &ide_dma_timeout;
hwif->dma_lost_irq = &pmac_ide_dma_lost_irq;
return 0; return 0;
} }
#else
static int __devinit pmac_ide_init_dma(ide_hwif_t *hwif,
const struct ide_port_info *d)
{
return -EOPNOTSUPP;
}
#endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */ #endif /* CONFIG_BLK_DEV_IDEDMA_PMAC */
module_init(pmac_ide_probe); module_init(pmac_ide_probe);

101
drivers/ide/setup-pci.c
View file

@ -72,16 +72,16 @@ static void ide_pci_clear_simplex(unsigned long dma_base, const char *name)
} }
/** /**
* ide_get_or_set_dma_base - setup BMIBA * ide_pci_dma_base - setup BMIBA
* @d: IDE port info
* @hwif: IDE interface * @hwif: IDE interface
* @d: IDE port info
* *
* Fetch the DMA Bus-Master-I/O-Base-Address (BMIBA) from PCI space. * Fetch the DMA Bus-Master-I/O-Base-Address (BMIBA) from PCI space.
* Where a device has a partner that is already in DMA mode we check * Where a device has a partner that is already in DMA mode we check
* and enforce IDE simplex rules. * and enforce IDE simplex rules.
*/ */
static unsigned long ide_get_or_set_dma_base(const struct ide_port_info *d, ide_hwif_t *hwif) unsigned long ide_pci_dma_base(ide_hwif_t *hwif, const struct ide_port_info *d)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
unsigned long dma_base = 0; unsigned long dma_base = 0;
@ -132,6 +132,31 @@ static unsigned long ide_get_or_set_dma_base(const struct ide_port_info *d, ide_
out: out:
return dma_base; return dma_base;
} }
EXPORT_SYMBOL_GPL(ide_pci_dma_base);
/*
* Set up BM-DMA capability (PnP BIOS should have done this)
*/
int ide_pci_set_master(struct pci_dev *dev, const char *name)
{
u16 pcicmd;
pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
if ((pcicmd & PCI_COMMAND_MASTER) == 0) {
pci_set_master(dev);
if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd) ||
(pcicmd & PCI_COMMAND_MASTER) == 0) {
printk(KERN_ERR "%s: error updating PCICMD on %s\n",
name, pci_name(dev));
return -EIO;
}
}
return 0;
}
EXPORT_SYMBOL_GPL(ide_pci_set_master);
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */ #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d) void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d)
@ -158,7 +183,7 @@ EXPORT_SYMBOL_GPL(ide_setup_pci_noise);
static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d) static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
{ {
int ret; int ret, bars;
if (pci_enable_device(dev)) { if (pci_enable_device(dev)) {
ret = pci_enable_device_io(dev); ret = pci_enable_device_io(dev);
@ -181,13 +206,21 @@ static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
goto out; goto out;
} }
/* FIXME: Temporary - until we put in the hotplug interface logic if (d->host_flags & IDE_HFLAG_SINGLE)
Check that the bits we want are not in use by someone else. */ bars = (1 << 2) - 1;
ret = pci_request_region(dev, 4, "ide_tmp"); else
if (ret < 0) bars = (1 << 4) - 1;
goto out;
pci_release_region(dev, 4); if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
if (d->host_flags & IDE_HFLAG_CS5520)
bars |= (1 << 2);
else
bars |= (1 << 4);
}
ret = pci_request_selected_regions(dev, bars, d->name);
if (ret < 0)
printk(KERN_ERR "%s: can't reserve resources\n", d->name);
out: out:
return ret; return ret;
} }
@ -314,7 +347,6 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev,
ide_init_port_hw(hwif, &hw); ide_init_port_hw(hwif, &hw);
hwif->dev = &dev->dev; hwif->dev = &dev->dev;
hwif->cds = d;
return hwif; return hwif;
} }
@ -330,40 +362,33 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev,
* state * state
*/ */
void ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d) int ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
{ {
struct pci_dev *dev = to_pci_dev(hwif->dev); struct pci_dev *dev = to_pci_dev(hwif->dev);
u16 pcicmd;
pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
if ((d->host_flags & IDE_HFLAG_NO_AUTODMA) == 0 || if ((d->host_flags & IDE_HFLAG_NO_AUTODMA) == 0 ||
((dev->class >> 8) == PCI_CLASS_STORAGE_IDE && ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
(dev->class & 0x80))) { (dev->class & 0x80))) {
unsigned long dma_base = ide_get_or_set_dma_base(d, hwif); unsigned long base = ide_pci_dma_base(hwif, d);
if (dma_base && !(pcicmd & PCI_COMMAND_MASTER)) {
/* if (base == 0 || ide_pci_set_master(dev, d->name) < 0)
* Set up BM-DMA capability return -1;
* (PnP BIOS should have done this)
*/ if (hwif->mmio)
pci_set_master(dev); printk(KERN_INFO " %s: MMIO-DMA\n", hwif->name);
if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd) || !(pcicmd & PCI_COMMAND_MASTER)) { else
printk(KERN_ERR "%s: %s error updating PCICMD\n", printk(KERN_INFO " %s: BM-DMA at 0x%04lx-0x%04lx\n",
hwif->name, d->name); hwif->name, base, base + 7);
dma_base = 0;
} hwif->extra_base = base + (hwif->channel ? 8 : 16);
}
if (dma_base) { if (ide_allocate_dma_engine(hwif))
if (d->init_dma) { return -1;
d->init_dma(hwif, dma_base);
} else { ide_setup_dma(hwif, base);
ide_setup_dma(hwif, dma_base);
}
} else {
printk(KERN_INFO "%s: %s Bus-Master DMA disabled "
"(BIOS)\n", hwif->name, d->name);
}
} }
return 0;
} }
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */ #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */

6
drivers/scsi/ide-scsi.c
View file

@ -393,7 +393,7 @@ static ide_startstop_t idescsi_pc_intr (ide_drive_t *drive)
printk ("ide-scsi: %s: DMA complete\n", drive->name); printk ("ide-scsi: %s: DMA complete\n", drive->name);
#endif /* IDESCSI_DEBUG_LOG */ #endif /* IDESCSI_DEBUG_LOG */
pc->xferred = pc->req_xfer; pc->xferred = pc->req_xfer;
(void) HWIF(drive)->ide_dma_end(drive); (void)hwif->dma_ops->dma_end(drive);
} }
/* Clear the interrupt */ /* Clear the interrupt */
@ -498,7 +498,7 @@ static ide_startstop_t idescsi_transfer_pc(ide_drive_t *drive)
drive->hwif->atapi_output_bytes(drive, scsi->pc->c, 12); drive->hwif->atapi_output_bytes(drive, scsi->pc->c, 12);
if (pc->flags & PC_FLAG_DMA_OK) { if (pc->flags & PC_FLAG_DMA_OK) {
pc->flags |= PC_FLAG_DMA_IN_PROGRESS; pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
hwif->dma_start(drive); hwif->dma_ops->dma_start(drive);
} }
return ide_started; return ide_started;
} }
@ -560,7 +560,7 @@ static ide_startstop_t idescsi_issue_pc(ide_drive_t *drive,
if (drive->using_dma && !idescsi_map_sg(drive, pc)) { if (drive->using_dma && !idescsi_map_sg(drive, pc)) {
hwif->sg_mapped = 1; hwif->sg_mapped = 1;
dma = !hwif->dma_setup(drive); dma = !hwif->dma_ops->dma_setup(drive);
hwif->sg_mapped = 0; hwif->sg_mapped = 0;
} }

42
include/asm-mips/mach-au1x00/au1xxx_ide.h
View file

@ -70,7 +70,6 @@ typedef struct
ide_hwif_t *hwif; ide_hwif_t *hwif;
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA #ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
ide_drive_t *drive; ide_drive_t *drive;
u8 white_list, black_list;
struct dbdma_cmd *dma_table_cpu; struct dbdma_cmd *dma_table_cpu;
dma_addr_t dma_table_dma; dma_addr_t dma_table_dma;
#endif #endif
@ -81,47 +80,6 @@ typedef struct
#endif #endif
} _auide_hwif; } _auide_hwif;
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
/* HD white list */
static const struct drive_list_entry dma_white_list [] = {
/*
* Hitachi
*/
{ "HITACHI_DK14FA-20" , NULL },
{ "HTS726060M9AT00" , NULL },
/*
* Maxtor
*/
{ "Maxtor 6E040L0" , NULL },
{ "Maxtor 6Y080P0" , NULL },
{ "Maxtor 6Y160P0" , NULL },
/*
* Seagate
*/
{ "ST3120026A" , NULL },
{ "ST320014A" , NULL },
{ "ST94011A" , NULL },
{ "ST340016A" , NULL },
/*
* Western Digital
*/
{ "WDC WD400UE-00HCT0" , NULL },
{ "WDC WD400JB-00JJC0" , NULL },
{ NULL , NULL }
};
/* HD black list */
static const struct drive_list_entry dma_black_list [] = {
/*
* Western Digital
*/
{ "WDC WD100EB-00CGH0" , NULL },
{ "WDC WD200BB-00AUA1" , NULL },
{ "WDC AC24300L" , NULL },
{ NULL , NULL }
};
#endif
/******************************************************************************* /*******************************************************************************
* PIO Mode timing calculation : * * PIO Mode timing calculation : *
* * * *

109
include/linux/ide.h
View file

@ -387,6 +387,43 @@ typedef struct ide_drive_s {
struct ide_port_info; struct ide_port_info;
struct ide_port_ops {
/* host specific initialization of devices on a port */
void (*port_init_devs)(struct hwif_s *);
/* routine to program host for PIO mode */
void (*set_pio_mode)(ide_drive_t *, const u8);
/* routine to program host for DMA mode */
void (*set_dma_mode)(ide_drive_t *, const u8);
/* tweaks hardware to select drive */
void (*selectproc)(ide_drive_t *);
/* chipset polling based on hba specifics */
int (*reset_poll)(ide_drive_t *);
/* chipset specific changes to default for device-hba resets */
void (*pre_reset)(ide_drive_t *);
/* routine to reset controller after a disk reset */
void (*resetproc)(ide_drive_t *);
/* special host masking for drive selection */
void (*maskproc)(ide_drive_t *, int);
/* check host's drive quirk list */
void (*quirkproc)(ide_drive_t *);
u8 (*mdma_filter)(ide_drive_t *);
u8 (*udma_filter)(ide_drive_t *);
u8 (*cable_detect)(struct hwif_s *);
};
struct ide_dma_ops {
void (*dma_host_set)(struct ide_drive_s *, int);
int (*dma_setup)(struct ide_drive_s *);
void (*dma_exec_cmd)(struct ide_drive_s *, u8);
void (*dma_start)(struct ide_drive_s *);
int (*dma_end)(struct ide_drive_s *);
int (*dma_test_irq)(struct ide_drive_s *);
void (*dma_lost_irq)(struct ide_drive_s *);
void (*dma_timeout)(struct ide_drive_s *);
};
typedef struct hwif_s { typedef struct hwif_s {
struct hwif_s *next; /* for linked-list in ide_hwgroup_t */ struct hwif_s *next; /* for linked-list in ide_hwgroup_t */
struct hwif_s *mate; /* other hwif from same PCI chip */ struct hwif_s *mate; /* other hwif from same PCI chip */
@ -420,38 +457,12 @@ typedef struct hwif_s {
struct device *dev; struct device *dev;
const struct ide_port_info *cds; /* chipset device struct */
ide_ack_intr_t *ack_intr; ide_ack_intr_t *ack_intr;
void (*rw_disk)(ide_drive_t *, struct request *); void (*rw_disk)(ide_drive_t *, struct request *);
#if 0 const struct ide_port_ops *port_ops;
ide_hwif_ops_t *hwifops; const struct ide_dma_ops *dma_ops;
#else
/* host specific initialization of devices on a port */
void (*port_init_devs)(struct hwif_s *);
/* routine to program host for PIO mode */
void (*set_pio_mode)(ide_drive_t *, const u8);
/* routine to program host for DMA mode */
void (*set_dma_mode)(ide_drive_t *, const u8);
/* tweaks hardware to select drive */
void (*selectproc)(ide_drive_t *);
/* chipset polling based on hba specifics */
int (*reset_poll)(ide_drive_t *);
/* chipset specific changes to default for device-hba resets */
void (*pre_reset)(ide_drive_t *);
/* routine to reset controller after a disk reset */
void (*resetproc)(ide_drive_t *);
/* special host masking for drive selection */
void (*maskproc)(ide_drive_t *, int);
/* check host's drive quirk list */
void (*quirkproc)(ide_drive_t *);
#endif
u8 (*mdma_filter)(ide_drive_t *);
u8 (*udma_filter)(ide_drive_t *);
u8 (*cable_detect)(struct hwif_s *);
void (*ata_input_data)(ide_drive_t *, void *, u32); void (*ata_input_data)(ide_drive_t *, void *, u32);
void (*ata_output_data)(ide_drive_t *, void *, u32); void (*ata_output_data)(ide_drive_t *, void *, u32);
@ -459,15 +470,7 @@ typedef struct hwif_s {
void (*atapi_input_bytes)(ide_drive_t *, void *, u32); void (*atapi_input_bytes)(ide_drive_t *, void *, u32);
void (*atapi_output_bytes)(ide_drive_t *, void *, u32); void (*atapi_output_bytes)(ide_drive_t *, void *, u32);
void (*dma_host_set)(ide_drive_t *, int);
int (*dma_setup)(ide_drive_t *);
void (*dma_exec_cmd)(ide_drive_t *, u8);
void (*dma_start)(ide_drive_t *);
int (*ide_dma_end)(ide_drive_t *drive);
int (*ide_dma_test_irq)(ide_drive_t *drive);
void (*ide_dma_clear_irq)(ide_drive_t *drive); void (*ide_dma_clear_irq)(ide_drive_t *drive);
void (*dma_lost_irq)(ide_drive_t *drive);
void (*dma_timeout)(ide_drive_t *drive);
void (*OUTB)(u8 addr, unsigned long port); void (*OUTB)(u8 addr, unsigned long port);
void (*OUTBSYNC)(ide_drive_t *drive, u8 addr, unsigned long port); void (*OUTBSYNC)(ide_drive_t *drive, u8 addr, unsigned long port);
@ -514,7 +517,6 @@ typedef struct hwif_s {
unsigned long extra_base; /* extra addr for dma ports */ unsigned long extra_base; /* extra addr for dma ports */
unsigned extra_ports; /* number of extra dma ports */ unsigned extra_ports; /* number of extra dma ports */
unsigned noprobe : 1; /* don't probe for this interface */
unsigned present : 1; /* this interface exists */ unsigned present : 1; /* this interface exists */
unsigned serialized : 1; /* serialized all channel operation */ unsigned serialized : 1; /* serialized all channel operation */
unsigned sharing_irq: 1; /* 1 = sharing irq with another hwif */ unsigned sharing_irq: 1; /* 1 = sharing irq with another hwif */
@ -1009,10 +1011,15 @@ void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *, int, u8
void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *); void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *);
#ifdef CONFIG_BLK_DEV_IDEDMA_PCI #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
void ide_hwif_setup_dma(ide_hwif_t *, const struct ide_port_info *); int ide_pci_set_master(struct pci_dev *, const char *);
unsigned long ide_pci_dma_base(ide_hwif_t *, const struct ide_port_info *);
int ide_hwif_setup_dma(ide_hwif_t *, const struct ide_port_info *);
#else #else
static inline void ide_hwif_setup_dma(ide_hwif_t *hwif, static inline int ide_hwif_setup_dma(ide_hwif_t *hwif,
const struct ide_port_info *d) { } const struct ide_port_info *d)
{
return -EINVAL;
}
#endif #endif
extern void default_hwif_iops(ide_hwif_t *); extern void default_hwif_iops(ide_hwif_t *);
@ -1084,6 +1091,8 @@ enum {
/* unmask IRQs */ /* unmask IRQs */
IDE_HFLAG_UNMASK_IRQS = (1 << 25), IDE_HFLAG_UNMASK_IRQS = (1 << 25),
IDE_HFLAG_ABUSE_SET_DMA_MODE = (1 << 26), IDE_HFLAG_ABUSE_SET_DMA_MODE = (1 << 26),
/* serialize ports if DMA is possible (for sl82c105) */
IDE_HFLAG_SERIALIZE_DMA = (1 << 27),
/* force host out of "simplex" mode */ /* force host out of "simplex" mode */
IDE_HFLAG_CLEAR_SIMPLEX = (1 << 28), IDE_HFLAG_CLEAR_SIMPLEX = (1 << 28),
/* DSC overlap is unsupported */ /* DSC overlap is unsupported */
@ -1105,10 +1114,14 @@ struct ide_port_info {
unsigned int (*init_chipset)(struct pci_dev *, const char *); unsigned int (*init_chipset)(struct pci_dev *, const char *);
void (*init_iops)(ide_hwif_t *); void (*init_iops)(ide_hwif_t *);
void (*init_hwif)(ide_hwif_t *); void (*init_hwif)(ide_hwif_t *);
void (*init_dma)(ide_hwif_t *, unsigned long); int (*init_dma)(ide_hwif_t *,
const struct ide_port_info *);
const struct ide_port_ops *port_ops;
const struct ide_dma_ops *dma_ops;
ide_pci_enablebit_t enablebits[2]; ide_pci_enablebit_t enablebits[2];
hwif_chipset_t chipset; hwif_chipset_t chipset;
u8 extra;
u32 host_flags; u32 host_flags;
u8 pio_mask; u8 pio_mask;
u8 swdma_mask; u8 swdma_mask;
@ -1155,13 +1168,16 @@ void ide_destroy_dmatable(ide_drive_t *);
#ifdef CONFIG_BLK_DEV_IDEDMA_SFF #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
extern int ide_build_dmatable(ide_drive_t *, struct request *); extern int ide_build_dmatable(ide_drive_t *, struct request *);
extern int ide_release_dma(ide_hwif_t *); int ide_allocate_dma_engine(ide_hwif_t *);
extern void ide_setup_dma(ide_hwif_t *, unsigned long); void ide_release_dma_engine(ide_hwif_t *);
void ide_setup_dma(ide_hwif_t *, unsigned long);
void ide_dma_host_set(ide_drive_t *, int); void ide_dma_host_set(ide_drive_t *, int);
extern int ide_dma_setup(ide_drive_t *); extern int ide_dma_setup(ide_drive_t *);
void ide_dma_exec_cmd(ide_drive_t *, u8);
extern void ide_dma_start(ide_drive_t *); extern void ide_dma_start(ide_drive_t *);
extern int __ide_dma_end(ide_drive_t *); extern int __ide_dma_end(ide_drive_t *);
int ide_dma_test_irq(ide_drive_t *);
extern void ide_dma_lost_irq(ide_drive_t *); extern void ide_dma_lost_irq(ide_drive_t *);
extern void ide_dma_timeout(ide_drive_t *); extern void ide_dma_timeout(ide_drive_t *);
#endif /* CONFIG_BLK_DEV_IDEDMA_SFF */ #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
@ -1179,7 +1195,7 @@ static inline void ide_check_dma_crc(ide_drive_t *drive) { ; }
#endif /* CONFIG_BLK_DEV_IDEDMA */ #endif /* CONFIG_BLK_DEV_IDEDMA */
#ifndef CONFIG_BLK_DEV_IDEDMA_SFF #ifndef CONFIG_BLK_DEV_IDEDMA_SFF
static inline void ide_release_dma(ide_hwif_t *drive) {;} static inline void ide_release_dma_engine(ide_hwif_t *hwif) { ; }
#endif #endif
#ifdef CONFIG_BLK_DEV_IDEACPI #ifdef CONFIG_BLK_DEV_IDEACPI
@ -1199,8 +1215,6 @@ static inline void ide_acpi_set_state(ide_hwif_t *hwif, int on) {}
#endif #endif
void ide_remove_port_from_hwgroup(ide_hwif_t *); void ide_remove_port_from_hwgroup(ide_hwif_t *);
extern int ide_hwif_request_regions(ide_hwif_t *hwif);
extern void ide_hwif_release_regions(ide_hwif_t* hwif);
void ide_unregister(unsigned int); void ide_unregister(unsigned int);
void ide_register_region(struct gendisk *); void ide_register_region(struct gendisk *);
@ -1210,6 +1224,7 @@ void ide_undecoded_slave(ide_drive_t *);
int ide_device_add_all(u8 *idx, const struct ide_port_info *); int ide_device_add_all(u8 *idx, const struct ide_port_info *);
int ide_device_add(u8 idx[4], const struct ide_port_info *); int ide_device_add(u8 idx[4], const struct ide_port_info *);
int ide_legacy_device_add(const struct ide_port_info *, unsigned long);
void ide_port_unregister_devices(ide_hwif_t *); void ide_port_unregister_devices(ide_hwif_t *);
void ide_port_scan(ide_hwif_t *); void ide_port_scan(ide_hwif_t *);