Automatic merge of /spare/repo/linux-2.6/.git branch HEAD
author <jgarzik@pretzel.yyz.us> <>
Thu, 2 Jun 2005 22:43:09 +0000 (18:43 -0400)
committerJeff Garzik <jgarzik@pobox.com>
Thu, 2 Jun 2005 22:43:09 +0000 (18:43 -0400)
1  2 
drivers/scsi/ata_piix.c
drivers/scsi/libata-core.c
include/linux/libata.h

diff --combined drivers/scsi/ata_piix.c
index c2b00c9d40a82fe6661533ca3917ca751b4b3196,54c52349adc53297971c6e04067d931aabf3148d..3be546439252332131fac6aca81cbdea71d9934a
@@@ -153,6 -153,7 +153,7 @@@ static struct ata_port_operations piix_
  
        .port_start             = ata_port_start,
        .port_stop              = ata_port_stop,
+       .host_stop              = ata_host_stop,
  };
  
  static struct ata_port_operations piix_sata_ops = {
  
        .port_start             = ata_port_start,
        .port_stop              = ata_port_stop,
+       .host_stop              = ata_host_stop,
  };
  
  static struct ata_port_info piix_port_info[] = {
@@@ -663,6 -665,15 +665,6 @@@ static int piix_init_one (struct pci_de
        return ata_pci_init_one(pdev, port_info, n_ports);
  }
  
 -/**
 - *    piix_init -
 - *
 - *    LOCKING:
 - *
 - *    RETURNS:
 - *
 - */
 -
  static int __init piix_init(void)
  {
        int rc;
        return 0;
  }
  
 -/**
 - *    piix_exit -
 - *
 - *    LOCKING:
 - *
 - */
 -
  static void __exit piix_exit(void)
  {
        pci_unregister_driver(&piix_pci_driver);
index a5d7c33a434da803b33516d64a3c58a3e0b4e5d3,30a88f0e7bd61b4c6a1c2f5919da0c4df656e87e..21d194c6ace38b8595b4d6fb6fcfe8fe2cdf341b
@@@ -186,28 -186,6 +186,28 @@@ static void ata_tf_load_mmio(struct ata
        ata_wait_idle(ap);
  }
  
 +
 +/**
 + *    ata_tf_load - send taskfile registers to host controller
 + *    @ap: Port to which output is sent
 + *    @tf: ATA taskfile register set
 + *
 + *    Outputs ATA taskfile to standard ATA host controller using MMIO
 + *    or PIO as indicated by the ATA_FLAG_MMIO flag.
 + *    Writes the control, feature, nsect, lbal, lbam, and lbah registers.
 + *    Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
 + *    hob_lbal, hob_lbam, and hob_lbah.
 + *
 + *    This function waits for idle (!BUSY and !DRQ) after writing
 + *    registers.  If the control register has a new value, this
 + *    function also waits for idle after writing control and before
 + *    writing the remaining registers.
 + *
 + *    May be used as the tf_load() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
  void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
  {
        if (ap->flags & ATA_FLAG_MMIO)
  }
  
  /**
 - *    ata_exec_command - issue ATA command to host controller
 + *    ata_exec_command_pio - issue ATA command to host controller
   *    @ap: port to which command is being issued
   *    @tf: ATA taskfile register set
   *
 - *    Issues PIO/MMIO write to ATA command register, with proper
 + *    Issues PIO write to ATA command register, with proper
   *    synchronization with interrupt handler / other threads.
   *
   *    LOCKING:
@@@ -257,18 -235,6 +257,18 @@@ static void ata_exec_command_mmio(struc
        ata_pause(ap);
  }
  
 +
 +/**
 + *    ata_exec_command - issue ATA command to host controller
 + *    @ap: port to which command is being issued
 + *    @tf: ATA taskfile register set
 + *
 + *    Issues PIO/MMIO write to ATA command register, with proper
 + *    synchronization with interrupt handler / other threads.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
  void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
  {
        if (ap->flags & ATA_FLAG_MMIO)
@@@ -339,7 -305,7 +339,7 @@@ void ata_tf_to_host_nolock(struct ata_p
  }
  
  /**
 - *    ata_tf_read - input device's ATA taskfile shadow registers
 + *    ata_tf_read_pio - input device's ATA taskfile shadow registers
   *    @ap: Port from which input is read
   *    @tf: ATA taskfile register set for storing input
   *
@@@ -402,23 -368,6 +402,23 @@@ static void ata_tf_read_mmio(struct ata
        }
  }
  
 +
 +/**
 + *    ata_tf_read - input device's ATA taskfile shadow registers
 + *    @ap: Port from which input is read
 + *    @tf: ATA taskfile register set for storing input
 + *
 + *    Reads ATA taskfile registers for currently-selected device
 + *    into @tf.
 + *
 + *    Reads nsect, lbal, lbam, lbah, and device.  If ATA_TFLAG_LBA48
 + *    is set, also reads the hob registers.
 + *
 + *    May be used as the tf_read() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
  void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
  {
        if (ap->flags & ATA_FLAG_MMIO)
   *    @ap: port where the device is
   *
   *    Reads ATA taskfile status register for currently-selected device
 - *    and return it's value. This also clears pending interrupts
 + *    and return its value. This also clears pending interrupts
   *      from this device
   *
   *    LOCKING:
@@@ -448,7 -397,7 +448,7 @@@ static u8 ata_check_status_pio(struct a
   *    @ap: port where the device is
   *
   *    Reads ATA taskfile status register for currently-selected device
 - *    via MMIO and return it's value. This also clears pending interrupts
 + *    via MMIO and return its value. This also clears pending interrupts
   *      from this device
   *
   *    LOCKING:
@@@ -459,20 -408,6 +459,20 @@@ static u8 ata_check_status_mmio(struct 
                return readb((void __iomem *) ap->ioaddr.status_addr);
  }
  
 +
 +/**
 + *    ata_check_status - Read device status reg & clear interrupt
 + *    @ap: port where the device is
 + *
 + *    Reads ATA taskfile status register for currently-selected device
 + *    and return its value. This also clears pending interrupts
 + *      from this device
 + *
 + *    May be used as the check_status() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
  u8 ata_check_status(struct ata_port *ap)
  {
        if (ap->flags & ATA_FLAG_MMIO)
        return ata_check_status_pio(ap);
  }
  
 +
 +/**
 + *    ata_altstatus - Read device alternate status reg
 + *    @ap: port where the device is
 + *
 + *    Reads ATA taskfile alternate status register for
 + *    currently-selected device and return its value.
 + *
 + *    Note: may NOT be used as the check_altstatus() entry in
 + *    ata_port_operations.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
  u8 ata_altstatus(struct ata_port *ap)
  {
        if (ap->ops->check_altstatus)
        return inb(ap->ioaddr.altstatus_addr);
  }
  
 +
 +/**
 + *    ata_chk_err - Read device error reg
 + *    @ap: port where the device is
 + *
 + *    Reads ATA taskfile error register for
 + *    currently-selected device and return its value.
 + *
 + *    Note: may NOT be used as the check_err() entry in
 + *    ata_port_operations.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
  u8 ata_chk_err(struct ata_port *ap)
  {
        if (ap->ops->check_err)
@@@ -966,24 -873,10 +966,24 @@@ void ata_dev_id_string(u16 *id, unsigne
        }
  }
  
 +
 +/**
 + *    ata_noop_dev_select - Select device 0/1 on ATA bus
 + *    @ap: ATA channel to manipulate
 + *    @device: ATA device (numbered from zero) to select
 + *
 + *    This function performs no actual function.
 + *
 + *    May be used as the dev_select() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    caller.
 + */
  void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
  {
  }
  
 +
  /**
   *    ata_std_dev_select - Select device 0/1 on ATA bus
   *    @ap: ATA channel to manipulate
   *
   *    Use the method defined in the ATA specification to
   *    make either device 0, or device 1, active on the
 - *    ATA channel.
 + *    ATA channel.  Works with both PIO and MMIO.
 + *
 + *    May be used as the dev_select() entry in ata_port_operations.
   *
   *    LOCKING:
   *    caller.
@@@ -1299,12 -1190,7 +1299,12 @@@ err_out
   *    ata_bus_probe - Reset and probe ATA bus
   *    @ap: Bus to probe
   *
 + *    Master ATA bus probing function.  Initiates a hardware-dependent
 + *    bus reset, then attempts to identify any devices found on
 + *    the bus.
 + *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   *    RETURNS:
   *    Zero on success, non-zero on error.
@@@ -1343,14 -1229,10 +1343,14 @@@ err_out
  }
  
  /**
 - *    ata_port_probe -
 - *    @ap:
 + *    ata_port_probe - Mark port as enabled
 + *    @ap: Port for which we indicate enablement
   *
 - *    LOCKING:
 + *    Modify @ap data structure such that the system
 + *    thinks that the entire port is enabled.
 + *
 + *    LOCKING: host_set lock, or some other form of
 + *    serialization.
   */
  
  void ata_port_probe(struct ata_port *ap)
  }
  
  /**
 - *    __sata_phy_reset -
 - *    @ap:
 + *    __sata_phy_reset - Wake/reset a low-level SATA PHY
 + *    @ap: SATA port associated with target SATA PHY.
 + *
 + *    This function issues commands to standard SATA Sxxx
 + *    PHY registers, to wake up the phy (and device), and
 + *    clear any reset condition.
   *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   */
  void __sata_phy_reset(struct ata_port *ap)
  }
  
  /**
 - *    __sata_phy_reset -
 - *    @ap:
 + *    sata_phy_reset - Reset SATA bus.
 + *    @ap: SATA port associated with target SATA PHY.
 + *
 + *    This function resets the SATA bus, and then probes
 + *    the bus for devices.
   *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   */
  void sata_phy_reset(struct ata_port *ap)
  }
  
  /**
 - *    ata_port_disable -
 - *    @ap:
 + *    ata_port_disable - Disable port.
 + *    @ap: Port to be disabled.
   *
 - *    LOCKING:
 + *    Modify @ap data structure such that the system
 + *    thinks that the entire port is disabled, and should
 + *    never attempt to probe or communicate with devices
 + *    on this port.
 + *
 + *    LOCKING: host_set lock, or some other form of
 + *    serialization.
   */
  
  void ata_port_disable(struct ata_port *ap)
@@@ -1549,10 -1416,7 +1549,10 @@@ static void ata_host_set_dma(struct ata
   *    ata_set_mode - Program timings and issue SET FEATURES - XFER
   *    @ap: port on which timings will be programmed
   *
 + *    Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
 + *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   */
  static void ata_set_mode(struct ata_port *ap)
@@@ -1603,10 -1467,7 +1603,10 @@@ err_out
   *    @tmout_pat: impatience timeout
   *    @tmout: overall timeout
   *
 - *    LOCKING:
 + *    Sleep until ATA Status register bit BSY clears,
 + *    or a timeout occurs.
 + *
 + *    LOCKING: None.
   *
   */
  
@@@ -1692,14 -1553,10 +1692,14 @@@ static void ata_bus_post_reset(struct a
  }
  
  /**
 - *    ata_bus_edd -
 - *    @ap:
 + *    ata_bus_edd - Issue EXECUTE DEVICE DIAGNOSTIC command.
 + *    @ap: Port to reset and probe
 + *
 + *    Use the EXECUTE DEVICE DIAGNOSTIC command to reset and
 + *    probe the bus.  Not often used these days.
   *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   */
  
@@@ -1776,8 -1633,8 +1776,8 @@@ static unsigned int ata_bus_softreset(s
   *    the device is ATA or ATAPI.
   *
   *    LOCKING:
 - *    Inherited from caller.  Some functions called by this function
 - *    obtain the host_set lock.
 + *    PCI/etc. bus probe sem.
 + *    Obtains host_set lock.
   *
   *    SIDE EFFECTS:
   *    Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
@@@ -2019,11 -1876,7 +2019,11 @@@ static int fgb(u32 bitmap
   *    @xfer_mode_out: (output) SET FEATURES - XFER MODE code
   *    @xfer_shift_out: (output) bit shift that selects this mode
   *
 + *    Based on host and device capabilities, determine the
 + *    maximum transfer mode that is amenable to all.
 + *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   *    RETURNS:
   *    Zero on success, negative on error.
@@@ -2056,11 -1909,7 +2056,11 @@@ static int ata_choose_xfer_mode(struct 
   *    @ap: Port associated with device @dev
   *    @dev: Device to which command will be sent
   *
 + *    Issue SET FEATURES - XFER MODE command to device @dev
 + *    on port @ap.
 + *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   */
  
  static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
  }
  
  /**
 - *    ata_sg_clean -
 - *    @qc:
 + *    ata_sg_clean - Unmap DMA memory associated with command
 + *    @qc: Command containing DMA memory to be released
 + *
 + *    Unmap all mapped DMA memory associated with this command.
   *
   *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
   */
  
  static void ata_sg_clean(struct ata_queued_cmd *qc)
   *    ata_fill_sg - Fill PCI IDE PRD table
   *    @qc: Metadata associated with taskfile to be transferred
   *
 + *    Fill PCI IDE PRD (scatter-gather) table with segments
 + *    associated with the current disk command.
 + *
   *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
   *
   */
  static void ata_fill_sg(struct ata_queued_cmd *qc)
   *    ata_check_atapi_dma - Check whether ATAPI DMA can be supported
   *    @qc: Metadata associated with taskfile to check
   *
 + *    Allow low-level driver to filter ATA PACKET commands, returning
 + *    a status indicating whether or not it is OK to use DMA for the
 + *    supplied PACKET command.
 + *
   *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + *
   *    RETURNS: 0 when ATAPI DMA can be used
   *               nonzero otherwise
   */
@@@ -2210,8 -2046,6 +2210,8 @@@ int ata_check_atapi_dma(struct ata_queu
   *    ata_qc_prep - Prepare taskfile for submission
   *    @qc: Metadata associated with taskfile to be prepared
   *
 + *    Prepare ATA taskfile for submission.
 + *
   *    LOCKING:
   *    spin_lock_irqsave(host_set lock)
   */
@@@ -2223,32 -2057,6 +2223,32 @@@ void ata_qc_prep(struct ata_queued_cmd 
        ata_fill_sg(qc);
  }
  
 +/**
 + *    ata_sg_init_one - Associate command with memory buffer
 + *    @qc: Command to be associated
 + *    @buf: Memory buffer
 + *    @buflen: Length of memory buffer, in bytes.
 + *
 + *    Initialize the data-related elements of queued_cmd @qc
 + *    to point to a single memory buffer, @buf of byte length @buflen.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
 +
 +
 +
 +/**
 + *    ata_sg_init_one - Prepare a one-entry scatter-gather list.
 + *    @qc:  Queued command
 + *    @buf:  transfer buffer
 + *    @buflen:  length of buf
 + *
 + *    Builds a single-entry scatter-gather list to initiate a
 + *    transfer utilizing the specified buffer.
 + *
 + *    LOCKING:
 + */
  void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
  {
        struct scatterlist *sg;
        sg->length = buflen;
  }
  
 +/**
 + *    ata_sg_init - Associate command with scatter-gather table.
 + *    @qc: Command to be associated
 + *    @sg: Scatter-gather table.
 + *    @n_elem: Number of elements in s/g table.
 + *
 + *    Initialize the data-related elements of queued_cmd @qc
 + *    to point to a scatter-gather table @sg, containing @n_elem
 + *    elements.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
 +
 +
 +/**
 + *    ata_sg_init - Assign a scatter gather list to a queued command
 + *    @qc:  Queued command
 + *    @sg:  Scatter-gather list
 + *    @n_elem:  length of sg list
 + *
 + *    Attaches a scatter-gather list to a queued command.
 + *
 + *    LOCKING:
 + */
 +
  void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
                 unsigned int n_elem)
  {
  }
  
  /**
 - *    ata_sg_setup_one -
 - *    @qc:
 + *    ata_sg_setup_one - DMA-map the memory buffer associated with a command.
 + *    @qc: Command with memory buffer to be mapped.
 + *
 + *    DMA-map the memory buffer associated with queued_cmd @qc.
   *
   *    LOCKING:
   *    spin_lock_irqsave(host_set lock)
   *
   *    RETURNS:
 - *
 + *    Zero on success, negative on error.
   */
  
  static int ata_sg_setup_one(struct ata_queued_cmd *qc)
  }
  
  /**
 - *    ata_sg_setup -
 - *    @qc:
 + *    ata_sg_setup - DMA-map the scatter-gather table associated with a command.
 + *    @qc: Command with scatter-gather table to be mapped.
 + *
 + *    DMA-map the scatter-gather table associated with queued_cmd @qc.
   *
   *    LOCKING:
   *    spin_lock_irqsave(host_set lock)
   *
   *    RETURNS:
 + *    Zero on success, negative on error.
   *
   */
  
@@@ -2374,7 -2151,6 +2374,7 @@@ static int ata_sg_setup(struct ata_queu
   *    @ap:
   *
   *    LOCKING:
 + *    None.  (executing in kernel thread context)
   *
   *    RETURNS:
   *
@@@ -2422,7 -2198,6 +2422,7 @@@ static unsigned long ata_pio_poll(struc
   *    @ap:
   *
   *    LOCKING:
 + *    None.  (executing in kernel thread context)
   */
  
  static void ata_pio_complete (struct ata_port *ap)
        ata_qc_complete(qc, drv_stat);
  }
  
 +
 +/**
 + *    swap_buf_le16 -
 + *    @buf:  Buffer to swap
 + *    @buf_words:  Number of 16-bit words in buffer.
 + *
 + *    Swap halves of 16-bit words if needed to convert from
 + *    little-endian byte order to native cpu byte order, or
 + *    vice-versa.
 + *
 + *    LOCKING:
 + */
  void swap_buf_le16(u16 *buf, unsigned int buf_words)
  {
  #ifdef __BIG_ENDIAN
@@@ -2652,7 -2415,6 +2652,7 @@@ err_out
   *    @ap:
   *
   *    LOCKING:
 + *    None.  (executing in kernel thread context)
   */
  
  static void ata_pio_block(struct ata_port *ap)
@@@ -2821,7 -2583,6 +2821,7 @@@ static void atapi_request_sense(struct 
   *    transaction completed successfully.
   *
   *    LOCKING:
 + *    Inherited from SCSI layer (none, can sleep)
   */
  
  static void ata_qc_timeout(struct ata_queued_cmd *qc)
@@@ -2931,7 -2692,6 +2931,7 @@@ out
   *    @dev: Device from whom we request an available command structure
   *
   *    LOCKING:
 + *    None.
   */
  
  static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
   *    @dev: Device from whom we request an available command structure
   *
   *    LOCKING:
 + *    None.
   */
  
  struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
@@@ -3022,7 -2781,6 +3022,7 @@@ static void __ata_qc_complete(struct at
   *    in case something prevents using it.
   *
   *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
   *
   */
  void ata_qc_free(struct ata_queued_cmd *qc)
  /**
   *    ata_qc_complete - Complete an active ATA command
   *    @qc: Command to complete
 - *    @drv_stat: ATA status register contents
 + *    @drv_stat: ATA Status register contents
 + *
 + *    Indicate to the mid and upper layers that an ATA
 + *    command has completed, with either an ok or not-ok status.
   *
   *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
   *
   */
  
@@@ -3138,7 -2892,6 +3138,7 @@@ err_out
        return -1;
  }
  
 +
  /**
   *    ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
   *    @qc: command to issue to device
   *    classes called "protocols", and issuing each type of protocol
   *    is slightly different.
   *
 + *    May be used as the qc_issue() entry in ata_port_operations.
 + *
   *    LOCKING:
   *    spin_lock_irqsave(host_set lock)
   *
@@@ -3207,7 -2958,7 +3207,7 @@@ int ata_qc_issue_prot(struct ata_queued
  }
  
  /**
 - *    ata_bmdma_setup - Set up PCI IDE BMDMA transaction
 + *    ata_bmdma_setup_mmio - Set up PCI IDE BMDMA transaction
   *    @qc: Info associated with this ATA transaction.
   *
   *    LOCKING:
@@@ -3314,18 -3065,6 +3314,18 @@@ static void ata_bmdma_start_pio (struc
             ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
  }
  
 +
 +/**
 + *    ata_bmdma_start - Start a PCI IDE BMDMA transaction
 + *    @qc: Info associated with this ATA transaction.
 + *
 + *    Writes the ATA_DMA_START flag to the DMA command register.
 + *
 + *    May be used as the bmdma_start() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
  void ata_bmdma_start(struct ata_queued_cmd *qc)
  {
        if (qc->ap->flags & ATA_FLAG_MMIO)
                ata_bmdma_start_pio(qc);
  }
  
 +
 +/**
 + *    ata_bmdma_setup - Set up PCI IDE BMDMA transaction
 + *    @qc: Info associated with this ATA transaction.
 + *
 + *    Writes address of PRD table to device's PRD Table Address
 + *    register, sets the DMA control register, and calls
 + *    ops->exec_command() to start the transfer.
 + *
 + *    May be used as the bmdma_setup() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
  void ata_bmdma_setup(struct ata_queued_cmd *qc)
  {
        if (qc->ap->flags & ATA_FLAG_MMIO)
                ata_bmdma_setup_pio(qc);
  }
  
 +
 +/**
 + *    ata_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
 + *    @ap: Port associated with this ATA transaction.
 + *
 + *    Clear interrupt and error flags in DMA status register.
 + *
 + *    May be used as the irq_clear() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
 +
  void ata_bmdma_irq_clear(struct ata_port *ap)
  {
      if (ap->flags & ATA_FLAG_MMIO) {
  
  }
  
 +
 +/**
 + *    ata_bmdma_status - Read PCI IDE BMDMA status
 + *    @ap: Port associated with this ATA transaction.
 + *
 + *    Read and return BMDMA status register.
 + *
 + *    May be used as the bmdma_status() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
 +
  u8 ata_bmdma_status(struct ata_port *ap)
  {
        u8 host_stat;
        return host_stat;
  }
  
 +
 +/**
 + *    ata_bmdma_stop - Stop PCI IDE BMDMA transfer
 + *    @ap: Port associated with this ATA transaction.
 + *
 + *    Clears the ATA_DMA_START flag in the dma control register
 + *
 + *    May be used as the bmdma_stop() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + *    spin_lock_irqsave(host_set lock)
 + */
 +
  void ata_bmdma_stop(struct ata_port *ap)
  {
        if (ap->flags & ATA_FLAG_MMIO) {
@@@ -3517,18 -3203,13 +3517,18 @@@ idle_irq
  
  /**
   *    ata_interrupt - Default ATA host interrupt handler
 - *    @irq: irq line
 - *    @dev_instance: pointer to our host information structure
 + *    @irq: irq line (unused)
 + *    @dev_instance: pointer to our ata_host_set information structure
   *    @regs: unused
   *
 + *    Default interrupt handler for PCI IDE devices.  Calls
 + *    ata_host_intr() for each port that is not disabled.
 + *
   *    LOCKING:
 + *    Obtains host_set lock during operation.
   *
   *    RETURNS:
 + *    IRQ_NONE or IRQ_HANDLED.
   *
   */
  
@@@ -3621,19 -3302,6 +3621,19 @@@ err_out
        ata_qc_complete(qc, ATA_ERR);
  }
  
 +
 +/**
 + *    ata_port_start - Set port up for dma.
 + *    @ap: Port to initialize
 + *
 + *    Called just after data structures for each port are
 + *    initialized.  Allocates space for PRD table.
 + *
 + *    May be used as the port_start() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + */
 +
  int ata_port_start (struct ata_port *ap)
  {
        struct device *dev = ap->host_set->dev;
        return 0;
  }
  
 +
 +/**
 + *    ata_port_stop - Undo ata_port_start()
 + *    @ap: Port to shut down
 + *
 + *    Frees the PRD table.
 + *
 + *    May be used as the port_stop() entry in ata_port_operations.
 + *
 + *    LOCKING:
 + */
 +
  void ata_port_stop (struct ata_port *ap)
  {
        struct device *dev = ap->host_set->dev;
        dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
  }
  
+ void ata_host_stop (struct ata_host_set *host_set)
+ {
+       if (host_set->mmio_base)
+               iounmap(host_set->mmio_base);
+ }
  /**
   *    ata_host_remove - Unregister SCSI host structure with upper layers
   *    @ap: Port to unregister
@@@ -3694,11 -3357,7 +3701,11 @@@ static void ata_host_remove(struct ata_
   *    @ent: Probe information provided by low-level driver
   *    @port_no: Port number associated with this ata_port
   *
 + *    Initialize a new ata_port structure, and its associated
 + *    scsi_host.
 + *
   *    LOCKING:
 + *    Inherited from caller.
   *
   */
  
@@@ -3753,13 -3412,9 +3760,13 @@@ static void ata_host_init(struct ata_po
   *    @host_set: Collections of ports to which we add
   *    @port_no: Port number associated with this host
   *
 + *    Attach low-level ATA driver to system.
 + *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   *    RETURNS:
 + *    New ata_port on success, for NULL on error.
   *
   */
  
@@@ -3792,22 -3447,12 +3799,22 @@@ err_out
  }
  
  /**
 - *    ata_device_add -
 - *    @ent:
 + *    ata_device_add - Register hardware device with ATA and SCSI layers
 + *    @ent: Probe information describing hardware device to be registered
 + *
 + *    This function processes the information provided in the probe
 + *    information struct @ent, allocates the necessary ATA and SCSI
 + *    host information structures, initializes them, and registers
 + *    everything with requisite kernel subsystems.
 + *
 + *    This function requests irqs, probes the ATA bus, and probes
 + *    the SCSI bus.
   *
   *    LOCKING:
 + *    PCI/etc. bus probe sem.
   *
   *    RETURNS:
 + *    Number of ports registered.  Zero on error (no ports registered).
   *
   */
  
@@@ -3959,15 -3604,7 +3966,15 @@@ int ata_scsi_release(struct Scsi_Host *
  /**
   *    ata_std_ports - initialize ioaddr with standard port offsets.
   *    @ioaddr: IO address structure to be initialized
 + *
 + *    Utility function which initializes data_addr, error_addr,
 + *    feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
 + *    device_addr, status_addr, and command_addr to standard offsets
 + *    relative to cmd_addr.
 + *
 + *    Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
   */
 +
  void ata_std_ports(struct ata_ioports *ioaddr)
  {
        ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
@@@ -4009,20 -3646,6 +4016,20 @@@ ata_probe_ent_alloc(struct device *dev
        return probe_ent;
  }
  
 +
 +
 +/**
 + *    ata_pci_init_native_mode - Initialize native-mode driver
 + *    @pdev:  pci device to be initialized
 + *    @port:  array[2] of pointers to port info structures.
 + *
 + *    Utility function which allocates and initializes an
 + *    ata_probe_ent structure for a standard dual-port
 + *    PIO-based IDE controller.  The returned ata_probe_ent
 + *    structure can be passed to ata_device_add().  The returned
 + *    ata_probe_ent structure should then be freed with kfree().
 + */
 +
  #ifdef CONFIG_PCI
  struct ata_probe_ent *
  ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
@@@ -4104,19 -3727,10 +4111,19 @@@ ata_pci_init_legacy_mode(struct pci_de
   *    @port_info: Information from low-level host driver
   *    @n_ports: Number of ports attached to host controller
   *
 + *    This is a helper function which can be called from a driver's
 + *    xxx_init_one() probe function if the hardware uses traditional
 + *    IDE taskfile registers.
 + *
 + *    This function calls pci_enable_device(), reserves its register
 + *    regions, sets the dma mask, enables bus master mode, and calls
 + *    ata_device_add()
 + *
   *    LOCKING:
   *    Inherited from PCI layer (may sleep).
   *
   *    RETURNS:
 + *    Zero on success, negative on errno-based value on error.
   *
   */
  
@@@ -4271,10 -3885,6 +4278,6 @@@ void ata_pci_remove_one (struct pci_de
        }
  
        free_irq(host_set->irq, host_set);
-       if (host_set->ops->host_stop)
-               host_set->ops->host_stop(host_set);
-       if (host_set->mmio_base)
-               iounmap(host_set->mmio_base);
  
        for (i = 0; i < host_set->n_ports; i++) {
                ap = host_set->ports[i];
                scsi_host_put(ap->host);
        }
  
+       if (host_set->ops->host_stop)
+               host_set->ops->host_stop(host_set);
        kfree(host_set);
  
        pci_release_regions(pdev);
@@@ -4336,6 -3949,15 +4342,6 @@@ int pci_test_config_bits(struct pci_de
  #endif /* CONFIG_PCI */
  
  
 -/**
 - *    ata_init -
 - *
 - *    LOCKING:
 - *
 - *    RETURNS:
 - *
 - */
 -
  static int __init ata_init(void)
  {
        ata_wq = create_workqueue("ata");
@@@ -4381,6 -4003,7 +4387,7 @@@ EXPORT_SYMBOL_GPL(ata_chk_err)
  EXPORT_SYMBOL_GPL(ata_exec_command);
  EXPORT_SYMBOL_GPL(ata_port_start);
  EXPORT_SYMBOL_GPL(ata_port_stop);
+ EXPORT_SYMBOL_GPL(ata_host_stop);
  EXPORT_SYMBOL_GPL(ata_interrupt);
  EXPORT_SYMBOL_GPL(ata_qc_prep);
  EXPORT_SYMBOL_GPL(ata_bmdma_setup);
diff --combined include/linux/libata.h
index ad410590664f19df2f2a694eb7fce9ece588ef03,e74f301e9baea59df14efbbd75943a61b496651c..b009f801e7c5880d671668fa31176bf824d4bf31
@@@ -410,6 -410,7 +410,7 @@@ extern u8 ata_chk_err(struct ata_port *
  extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
  extern int ata_port_start (struct ata_port *ap);
  extern void ata_port_stop (struct ata_port *ap);
+ extern void ata_host_stop (struct ata_host_set *host_set);
  extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
  extern void ata_qc_prep(struct ata_queued_cmd *qc);
  extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
@@@ -466,34 -467,12 +467,34 @@@ static inline u8 ata_chk_status(struct 
        return ap->ops->check_status(ap);
  }
  
 +
 +/**
 + *    ata_pause - Flush writes and pause 400 nanoseconds.
 + *    @ap: Port to wait for.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
 +
  static inline void ata_pause(struct ata_port *ap)
  {
        ata_altstatus(ap);
        ndelay(400);
  }
  
 +
 +/**
 + *    ata_busy_wait - Wait for a port status register
 + *    @ap: Port to wait for.
 + *
 + *    Waits up to max*10 microseconds for the selected bits in the port's
 + *    status register to be cleared.
 + *    Returns final value of status register.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
 +
  static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
                               unsigned int max)
  {
        return status;
  }
  
 +
 +/**
 + *    ata_wait_idle - Wait for a port to be idle.
 + *    @ap: Port to wait for.
 + *
 + *    Waits up to 10ms for port's BUSY and DRQ signals to clear.
 + *    Returns final value of status register.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
 +
  static inline u8 ata_wait_idle(struct ata_port *ap)
  {
        u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
@@@ -558,18 -525,6 +559,18 @@@ static inline void ata_tf_init(struct a
                tf->device = ATA_DEVICE_OBS | ATA_DEV1;
  }
  
 +
 +/**
 + *    ata_irq_on - Enable interrupts on a port.
 + *    @ap: Port on which interrupts are enabled.
 + *
 + *    Enable interrupts on a legacy IDE device using MMIO or PIO,
 + *    wait for idle, clear any pending interrupts.
 + *
 + *    LOCKING:
 + *    Inherited from caller.
 + */
 +
  static inline u8 ata_irq_on(struct ata_port *ap)
  {
        struct ata_ioports *ioaddr = &ap->ioaddr;
        return tmp;
  }
  
 +
 +/**
 + *    ata_irq_ack - Acknowledge a device interrupt.
 + *    @ap: Port on which interrupts are enabled.
 + *
 + *    Wait up to 10 ms for legacy IDE device to become idle (BUSY
 + *    or BUSY+DRQ clear).  Obtain dma status and port status from
 + *    device.  Clear the interrupt.  Return port status.
 + *
 + *    LOCKING:
 + */
 +
  static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
  {
        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;