2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* sata_promise.c - Promise SATA
|
|
|
|
*
|
|
|
|
* Maintained by: Jeff Garzik <jgarzik@pobox.com>
|
2007-10-30 14:21:55 +01:00
|
|
|
* Mikael Pettersson <mikpe@it.uu.se>
|
2005-04-17 00:20:36 +02:00
|
|
|
* Please ALWAYS copy linux-ide@vger.kernel.org
|
|
|
|
* on emails.
|
|
|
|
*
|
|
|
|
* Copyright 2003-2004 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
*
|
2005-08-29 02:18:39 +02:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; see the file COPYING. If not, write to
|
|
|
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* libata documentation is available via 'make {ps|pdf}docs',
|
|
|
|
* as Documentation/DocBook/libata.*
|
|
|
|
*
|
|
|
|
* Hardware information only available under NDA.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/interrupt.h>
|
2005-10-30 20:39:11 +01:00
|
|
|
#include <linux/device.h>
|
2007-01-09 10:51:46 +01:00
|
|
|
#include <scsi/scsi.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <scsi/scsi_host.h>
|
2005-11-07 06:59:37 +01:00
|
|
|
#include <scsi/scsi_cmnd.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/libata.h>
|
|
|
|
#include "sata_promise.h"
|
|
|
|
|
|
|
|
#define DRV_NAME "sata_promise"
|
2008-03-23 18:41:01 +01:00
|
|
|
#define DRV_VERSION "2.12"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
enum {
|
2007-04-17 16:44:07 +02:00
|
|
|
PDC_MAX_PORTS = 4,
|
2007-02-01 07:06:36 +01:00
|
|
|
PDC_MMIO_BAR = 3,
|
2007-10-30 14:20:49 +01:00
|
|
|
PDC_MAX_PRD = LIBATA_MAX_PRD - 1, /* -1 for ASIC PRD bug workaround */
|
2007-02-01 07:06:36 +01:00
|
|
|
|
2007-01-09 10:51:46 +01:00
|
|
|
/* register offsets */
|
|
|
|
PDC_FEATURE = 0x04, /* Feature/Error reg (per port) */
|
|
|
|
PDC_SECTOR_COUNT = 0x08, /* Sector count reg (per port) */
|
|
|
|
PDC_SECTOR_NUMBER = 0x0C, /* Sector number reg (per port) */
|
|
|
|
PDC_CYLINDER_LOW = 0x10, /* Cylinder low reg (per port) */
|
|
|
|
PDC_CYLINDER_HIGH = 0x14, /* Cylinder high reg (per port) */
|
|
|
|
PDC_DEVICE = 0x18, /* Device/Head reg (per port) */
|
|
|
|
PDC_COMMAND = 0x1C, /* Command/status reg (per port) */
|
2007-01-10 09:32:34 +01:00
|
|
|
PDC_ALTSTATUS = 0x38, /* Alternate-status/device-control reg (per port) */
|
2005-04-17 00:20:36 +02:00
|
|
|
PDC_PKT_SUBMIT = 0x40, /* Command packet pointer addr */
|
|
|
|
PDC_INT_SEQMASK = 0x40, /* Mask of asserted SEQ INTs */
|
|
|
|
PDC_FLASH_CTL = 0x44, /* Flash control register */
|
|
|
|
PDC_GLOBAL_CTL = 0x48, /* Global control/status (per port) */
|
|
|
|
PDC_CTLSTAT = 0x60, /* IDE control and status (per port) */
|
|
|
|
PDC_SATA_PLUG_CSR = 0x6C, /* SATA Plug control/status reg */
|
2006-01-28 18:39:29 +01:00
|
|
|
PDC2_SATA_PLUG_CSR = 0x60, /* SATAII Plug control/status reg */
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
PDC_TBG_MODE = 0x41C, /* TBG mode (not SATAII) */
|
|
|
|
PDC_SLEW_CTL = 0x470, /* slew rate control reg (not SATAII) */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-03-14 09:51:35 +01:00
|
|
|
/* PDC_GLOBAL_CTL bit definitions */
|
|
|
|
PDC_PH_ERR = (1 << 8), /* PCI error while loading packet */
|
|
|
|
PDC_SH_ERR = (1 << 9), /* PCI error while loading S/G table */
|
|
|
|
PDC_DH_ERR = (1 << 10), /* PCI error while loading data */
|
|
|
|
PDC2_HTO_ERR = (1 << 12), /* host bus timeout */
|
|
|
|
PDC2_ATA_HBA_ERR = (1 << 13), /* error during SATA DATA FIS transmission */
|
|
|
|
PDC2_ATA_DMA_CNT_ERR = (1 << 14), /* DMA DATA FIS size differs from S/G count */
|
|
|
|
PDC_OVERRUN_ERR = (1 << 19), /* S/G byte count larger than HD requires */
|
|
|
|
PDC_UNDERRUN_ERR = (1 << 20), /* S/G byte count less than HD requires */
|
|
|
|
PDC_DRIVE_ERR = (1 << 21), /* drive error */
|
|
|
|
PDC_PCI_SYS_ERR = (1 << 22), /* PCI system error */
|
|
|
|
PDC1_PCI_PARITY_ERR = (1 << 23), /* PCI parity error (from SATA150 driver) */
|
|
|
|
PDC1_ERR_MASK = PDC1_PCI_PARITY_ERR,
|
2007-10-26 06:03:37 +02:00
|
|
|
PDC2_ERR_MASK = PDC2_HTO_ERR | PDC2_ATA_HBA_ERR |
|
|
|
|
PDC2_ATA_DMA_CNT_ERR,
|
|
|
|
PDC_ERR_MASK = PDC_PH_ERR | PDC_SH_ERR | PDC_DH_ERR |
|
|
|
|
PDC_OVERRUN_ERR | PDC_UNDERRUN_ERR |
|
|
|
|
PDC_DRIVE_ERR | PDC_PCI_SYS_ERR |
|
|
|
|
PDC1_ERR_MASK | PDC2_ERR_MASK,
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
board_2037x = 0, /* FastTrak S150 TX2plus */
|
2007-04-17 16:44:07 +02:00
|
|
|
board_2037x_pata = 1, /* FastTrak S150 TX2plus PATA port */
|
|
|
|
board_20319 = 2, /* FastTrak S150 TX4 */
|
|
|
|
board_20619 = 3, /* FastTrak TX4000 */
|
|
|
|
board_2057x = 4, /* SATAII150 Tx2plus */
|
2007-06-19 21:53:30 +02:00
|
|
|
board_2057x_pata = 5, /* SATAII150 Tx2plus PATA port */
|
2007-04-17 16:44:07 +02:00
|
|
|
board_40518 = 6, /* SATAII150 Tx4 */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-01-28 18:39:29 +01:00
|
|
|
PDC_HAS_PATA = (1 << 1), /* PDC20375/20575 has PATA */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-01-09 10:51:46 +01:00
|
|
|
/* Sequence counter control registers bit definitions */
|
|
|
|
PDC_SEQCNTRL_INT_MASK = (1 << 5), /* Sequence Interrupt Mask */
|
|
|
|
|
|
|
|
/* Feature register values */
|
|
|
|
PDC_FEATURE_ATAPI_PIO = 0x00, /* ATAPI data xfer by PIO */
|
|
|
|
PDC_FEATURE_ATAPI_DMA = 0x01, /* ATAPI data xfer by DMA */
|
|
|
|
|
|
|
|
/* Device/Head register values */
|
|
|
|
PDC_DEVICE_SATA = 0xE0, /* Device/Head value for SATA devices */
|
|
|
|
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
/* PDC_CTLSTAT bit definitions */
|
|
|
|
PDC_DMA_ENABLE = (1 << 7),
|
|
|
|
PDC_IRQ_DISABLE = (1 << 10),
|
2005-04-17 00:20:36 +02:00
|
|
|
PDC_RESET = (1 << 11), /* HDMA reset */
|
2005-12-13 08:29:45 +01:00
|
|
|
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
PDC_COMMON_FLAGS = ATA_FLAG_NO_LEGACY |
|
2007-01-09 10:51:46 +01:00
|
|
|
ATA_FLAG_MMIO |
|
2005-12-14 04:28:19 +01:00
|
|
|
ATA_FLAG_PIO_POLLING,
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
/* ap->flags bits */
|
|
|
|
PDC_FLAG_GEN_II = (1 << 24),
|
|
|
|
PDC_FLAG_SATA_PATA = (1 << 25), /* supports SATA + PATA */
|
|
|
|
PDC_FLAG_4_PORTS = (1 << 26), /* 4 ports */
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct pdc_port_priv {
|
|
|
|
u8 *pkt;
|
|
|
|
dma_addr_t pkt_dma;
|
|
|
|
};
|
|
|
|
|
2007-07-16 07:29:40 +02:00
|
|
|
static int pdc_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
|
|
|
|
static int pdc_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
|
2005-04-17 00:20:36 +02:00
|
|
|
static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
|
2007-04-17 16:44:07 +02:00
|
|
|
static int pdc_common_port_start(struct ata_port *ap);
|
|
|
|
static int pdc_sata_port_start(struct ata_port *ap);
|
2005-04-17 00:20:36 +02:00
|
|
|
static void pdc_qc_prep(struct ata_queued_cmd *qc);
|
2005-10-22 20:27:05 +02:00
|
|
|
static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
|
|
|
|
static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
|
2007-01-09 10:51:46 +01:00
|
|
|
static int pdc_check_atapi_dma(struct ata_queued_cmd *qc);
|
2007-03-11 21:20:43 +01:00
|
|
|
static int pdc_old_sata_check_atapi_dma(struct ata_queued_cmd *qc);
|
2005-04-17 00:20:36 +02:00
|
|
|
static void pdc_irq_clear(struct ata_port *ap);
|
2006-01-23 05:09:36 +01:00
|
|
|
static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc);
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
static void pdc_freeze(struct ata_port *ap);
|
2008-03-23 18:41:01 +01:00
|
|
|
static void pdc_sata_freeze(struct ata_port *ap);
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
static void pdc_thaw(struct ata_port *ap);
|
2008-03-23 18:41:01 +01:00
|
|
|
static void pdc_sata_thaw(struct ata_port *ap);
|
libata: make reset related methods proper port operations
Currently reset methods are not specified directly in the
ata_port_operations table. If a LLD wants to use custom reset
methods, it should construct and use a error_handler which uses those
reset methods. It's done this way for two reasons.
First, the ops table already contained too many methods and adding
four more of them would noticeably increase the amount of necessary
boilerplate code all over low level drivers.
Second, as ->error_handler uses those reset methods, it can get
confusing. ie. By overriding ->error_handler, those reset ops can be
made useless making layering a bit hazy.
Now that ops table uses inheritance, the first problem doesn't exist
anymore. The second isn't completely solved but is relieved by
providing default values - most drivers can just override what it has
implemented and don't have to concern itself about higher level
callbacks. In fact, there currently is no driver which actually
modifies error handling behavior. Drivers which override
->error_handler just wraps the standard error handler only to prepare
the controller for EH. I don't think making ops layering strict has
any noticeable benefit.
This patch makes ->prereset, ->softreset, ->hardreset, ->postreset and
their PMP counterparts propoer ops. Default ops are provided in the
base ops tables and drivers are converted to override individual reset
methods instead of creating custom error_handler.
* ata_std_error_handler() doesn't use sata_std_hardreset() if SCRs
aren't accessible. sata_promise doesn't need to use separate
error_handlers for PATA and SATA anymore.
* softreset is broken for sata_inic162x and sata_sx4. As libata now
always prefers hardreset, this doesn't really matter but the ops are
forced to NULL using ATA_OP_NULL for documentation purpose.
* pata_hpt374 needs to use different prereset for the first and second
PCI functions. This used to be done by branching from
hpt374_error_handler(). The proper way to do this is to use
separate ops and port_info tables for each function. Converted.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:50 +01:00
|
|
|
static void pdc_error_handler(struct ata_port *ap);
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
static void pdc_post_internal_cmd(struct ata_queued_cmd *qc);
|
2007-03-11 21:20:43 +01:00
|
|
|
static int pdc_pata_cable_detect(struct ata_port *ap);
|
|
|
|
static int pdc_sata_cable_detect(struct ata_port *ap);
|
2005-08-30 11:42:52 +02:00
|
|
|
|
2005-11-07 06:59:37 +01:00
|
|
|
static struct scsi_host_template pdc_ata_sht = {
|
2008-03-25 04:22:49 +01:00
|
|
|
ATA_BASE_SHT(DRV_NAME),
|
2007-10-30 14:20:49 +01:00
|
|
|
.sg_tablesize = PDC_MAX_PRD,
|
2005-04-17 00:20:36 +02:00
|
|
|
.dma_boundary = ATA_DMA_BOUNDARY,
|
|
|
|
};
|
|
|
|
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:49 +01:00
|
|
|
static const struct ata_port_operations pdc_common_ops = {
|
|
|
|
.inherits = &ata_sff_port_ops,
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
.tf_load = pdc_tf_load_mmio,
|
|
|
|
.exec_command = pdc_exec_command_mmio,
|
2007-01-09 10:51:46 +01:00
|
|
|
.check_atapi_dma = pdc_check_atapi_dma,
|
|
|
|
.qc_prep = pdc_qc_prep,
|
|
|
|
.qc_issue = pdc_qc_issue_prot,
|
|
|
|
.irq_clear = pdc_irq_clear,
|
|
|
|
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:49 +01:00
|
|
|
.post_internal_cmd = pdc_post_internal_cmd,
|
libata: make reset related methods proper port operations
Currently reset methods are not specified directly in the
ata_port_operations table. If a LLD wants to use custom reset
methods, it should construct and use a error_handler which uses those
reset methods. It's done this way for two reasons.
First, the ops table already contained too many methods and adding
four more of them would noticeably increase the amount of necessary
boilerplate code all over low level drivers.
Second, as ->error_handler uses those reset methods, it can get
confusing. ie. By overriding ->error_handler, those reset ops can be
made useless making layering a bit hazy.
Now that ops table uses inheritance, the first problem doesn't exist
anymore. The second isn't completely solved but is relieved by
providing default values - most drivers can just override what it has
implemented and don't have to concern itself about higher level
callbacks. In fact, there currently is no driver which actually
modifies error handling behavior. Drivers which override
->error_handler just wraps the standard error handler only to prepare
the controller for EH. I don't think making ops layering strict has
any noticeable benefit.
This patch makes ->prereset, ->softreset, ->hardreset, ->postreset and
their PMP counterparts propoer ops. Default ops are provided in the
base ops tables and drivers are converted to override individual reset
methods instead of creating custom error_handler.
* ata_std_error_handler() doesn't use sata_std_hardreset() if SCRs
aren't accessible. sata_promise doesn't need to use separate
error_handlers for PATA and SATA anymore.
* softreset is broken for sata_inic162x and sata_sx4. As libata now
always prefers hardreset, this doesn't really matter but the ops are
forced to NULL using ATA_OP_NULL for documentation purpose.
* pata_hpt374 needs to use different prereset for the first and second
PCI functions. This used to be done by branching from
hpt374_error_handler(). The proper way to do this is to use
separate ops and port_info tables for each function. Converted.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:50 +01:00
|
|
|
.error_handler = pdc_error_handler,
|
2007-01-09 10:51:46 +01:00
|
|
|
};
|
|
|
|
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:49 +01:00
|
|
|
static struct ata_port_operations pdc_sata_ops = {
|
|
|
|
.inherits = &pdc_common_ops,
|
|
|
|
.cable_detect = pdc_sata_cable_detect,
|
2008-03-23 18:41:01 +01:00
|
|
|
.freeze = pdc_sata_freeze,
|
|
|
|
.thaw = pdc_sata_thaw,
|
2005-04-17 00:20:36 +02:00
|
|
|
.scr_read = pdc_sata_scr_read,
|
|
|
|
.scr_write = pdc_sata_scr_write,
|
2007-04-17 16:44:07 +02:00
|
|
|
.port_start = pdc_sata_port_start,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:49 +01:00
|
|
|
/* First-generation chips need a more restrictive ->check_atapi_dma op */
|
|
|
|
static struct ata_port_operations pdc_old_sata_ops = {
|
|
|
|
.inherits = &pdc_sata_ops,
|
|
|
|
.check_atapi_dma = pdc_old_sata_check_atapi_dma,
|
|
|
|
};
|
2005-08-29 11:12:30 +02:00
|
|
|
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:49 +01:00
|
|
|
static struct ata_port_operations pdc_pata_ops = {
|
|
|
|
.inherits = &pdc_common_ops,
|
|
|
|
.cable_detect = pdc_pata_cable_detect,
|
2007-02-11 23:19:53 +01:00
|
|
|
.freeze = pdc_freeze,
|
|
|
|
.thaw = pdc_thaw,
|
2007-04-17 16:44:07 +02:00
|
|
|
.port_start = pdc_common_port_start,
|
2005-08-29 11:12:30 +02:00
|
|
|
};
|
|
|
|
|
2005-11-28 10:06:23 +01:00
|
|
|
static const struct ata_port_info pdc_port_info[] = {
|
2007-10-30 14:21:55 +01:00
|
|
|
[board_2037x] =
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-04-17 16:44:07 +02:00
|
|
|
.flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
|
|
|
|
PDC_FLAG_SATA_PATA,
|
2005-04-17 00:20:36 +02:00
|
|
|
.pio_mask = 0x1f, /* pio0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* mwdma0-2 */
|
2007-07-08 07:13:16 +02:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2007-01-09 10:51:46 +01:00
|
|
|
.port_ops = &pdc_old_sata_ops,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
|
|
|
|
2007-10-30 14:21:55 +01:00
|
|
|
[board_2037x_pata] =
|
2007-04-17 16:44:07 +02:00
|
|
|
{
|
|
|
|
.flags = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS,
|
|
|
|
.pio_mask = 0x1f, /* pio0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* mwdma0-2 */
|
2007-07-08 07:13:16 +02:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2007-04-17 16:44:07 +02:00
|
|
|
.port_ops = &pdc_pata_ops,
|
|
|
|
},
|
|
|
|
|
2007-10-30 14:21:55 +01:00
|
|
|
[board_20319] =
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-04-17 16:44:07 +02:00
|
|
|
.flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
|
|
|
|
PDC_FLAG_4_PORTS,
|
2005-04-17 00:20:36 +02:00
|
|
|
.pio_mask = 0x1f, /* pio0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* mwdma0-2 */
|
2007-07-08 07:13:16 +02:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2007-01-09 10:51:46 +01:00
|
|
|
.port_ops = &pdc_old_sata_ops,
|
2005-04-17 00:20:36 +02:00
|
|
|
},
|
2005-05-12 21:51:01 +02:00
|
|
|
|
2007-10-30 14:21:55 +01:00
|
|
|
[board_20619] =
|
2005-05-12 21:51:01 +02:00
|
|
|
{
|
2007-04-17 16:44:07 +02:00
|
|
|
.flags = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS |
|
|
|
|
PDC_FLAG_4_PORTS,
|
2005-05-12 21:51:01 +02:00
|
|
|
.pio_mask = 0x1f, /* pio0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* mwdma0-2 */
|
2007-07-08 07:13:16 +02:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2005-08-29 11:12:30 +02:00
|
|
|
.port_ops = &pdc_pata_ops,
|
2005-05-12 21:51:01 +02:00
|
|
|
},
|
2006-01-17 14:06:21 +01:00
|
|
|
|
2007-10-30 14:21:55 +01:00
|
|
|
[board_2057x] =
|
2006-01-28 18:39:29 +01:00
|
|
|
{
|
2007-04-17 16:44:07 +02:00
|
|
|
.flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
|
|
|
|
PDC_FLAG_GEN_II | PDC_FLAG_SATA_PATA,
|
2006-01-28 18:39:29 +01:00
|
|
|
.pio_mask = 0x1f, /* pio0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* mwdma0-2 */
|
2007-07-08 07:13:16 +02:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2006-01-28 18:39:29 +01:00
|
|
|
.port_ops = &pdc_sata_ops,
|
|
|
|
},
|
|
|
|
|
2007-10-30 14:21:55 +01:00
|
|
|
[board_2057x_pata] =
|
2007-04-17 16:44:07 +02:00
|
|
|
{
|
2007-05-25 05:35:59 +02:00
|
|
|
.flags = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS |
|
2007-04-17 16:44:07 +02:00
|
|
|
PDC_FLAG_GEN_II,
|
|
|
|
.pio_mask = 0x1f, /* pio0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* mwdma0-2 */
|
2007-07-08 07:13:16 +02:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2007-04-17 16:44:07 +02:00
|
|
|
.port_ops = &pdc_pata_ops,
|
|
|
|
},
|
|
|
|
|
2007-10-30 14:21:55 +01:00
|
|
|
[board_40518] =
|
2006-01-28 18:39:29 +01:00
|
|
|
{
|
2007-04-17 16:44:07 +02:00
|
|
|
.flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
|
|
|
|
PDC_FLAG_GEN_II | PDC_FLAG_4_PORTS,
|
2006-01-28 18:39:29 +01:00
|
|
|
.pio_mask = 0x1f, /* pio0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* mwdma0-2 */
|
2007-07-08 07:13:16 +02:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2006-01-28 18:39:29 +01:00
|
|
|
.port_ops = &pdc_sata_ops,
|
|
|
|
},
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2005-11-10 17:04:11 +01:00
|
|
|
static const struct pci_device_id pdc_ata_pci_tbl[] = {
|
2006-09-28 04:20:11 +02:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3371), board_2037x },
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3373), board_2037x },
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3375), board_2037x },
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3376), board_2037x },
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3570), board_2057x },
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3571), board_2057x },
|
2006-09-28 04:20:11 +02:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3574), board_2057x },
|
2006-12-06 09:55:43 +01:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3577), board_2057x },
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3d73), board_2057x },
|
2006-09-28 04:20:11 +02:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3d75), board_2057x },
|
|
|
|
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3318), board_20319 },
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3319), board_20319 },
|
2007-08-29 10:25:37 +02:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3515), board_40518 },
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3519), board_40518 },
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3d17), board_40518 },
|
2006-09-28 04:20:11 +02:00
|
|
|
{ PCI_VDEVICE(PROMISE, 0x3d18), board_40518 },
|
|
|
|
|
|
|
|
{ PCI_VDEVICE(PROMISE, 0x6629), board_20619 },
|
2005-05-12 21:51:01 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
{ } /* terminate list */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct pci_driver pdc_ata_pci_driver = {
|
|
|
|
.name = DRV_NAME,
|
|
|
|
.id_table = pdc_ata_pci_tbl,
|
|
|
|
.probe = pdc_ata_init_one,
|
|
|
|
.remove = ata_pci_remove_one,
|
|
|
|
};
|
|
|
|
|
2007-03-11 21:20:43 +01:00
|
|
|
static int pdc_common_port_start(struct ata_port *ap)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-24 09:19:22 +02:00
|
|
|
struct device *dev = ap->host->dev;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct pdc_port_priv *pp;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = ata_port_start(ap);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2007-01-20 08:00:28 +01:00
|
|
|
pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
|
|
|
|
if (!pp)
|
|
|
|
return -ENOMEM;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-01-20 08:00:28 +01:00
|
|
|
pp->pkt = dmam_alloc_coherent(dev, 128, &pp->pkt_dma, GFP_KERNEL);
|
|
|
|
if (!pp->pkt)
|
|
|
|
return -ENOMEM;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ap->private_data = pp;
|
|
|
|
|
2007-03-11 21:20:43 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pdc_sata_port_start(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = pdc_common_port_start(ap);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2006-12-01 10:55:58 +01:00
|
|
|
/* fix up PHYMODE4 align timing */
|
2007-04-17 16:44:07 +02:00
|
|
|
if (ap->flags & PDC_FLAG_GEN_II) {
|
2007-05-28 13:07:20 +02:00
|
|
|
void __iomem *mmio = ap->ioaddr.scr_addr;
|
2006-12-01 10:55:58 +01:00
|
|
|
unsigned int tmp;
|
|
|
|
|
|
|
|
tmp = readl(mmio + 0x014);
|
|
|
|
tmp = (tmp & ~3) | 1; /* set bits 1:0 = 0:1 */
|
|
|
|
writel(tmp, mmio + 0x014);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pdc_reset_port(struct ata_port *ap)
|
|
|
|
{
|
2007-02-01 07:06:36 +01:00
|
|
|
void __iomem *mmio = ap->ioaddr.cmd_addr + PDC_CTLSTAT;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int i;
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
for (i = 11; i > 0; i--) {
|
|
|
|
tmp = readl(mmio);
|
|
|
|
if (tmp & PDC_RESET)
|
|
|
|
break;
|
|
|
|
|
|
|
|
udelay(100);
|
|
|
|
|
|
|
|
tmp |= PDC_RESET;
|
|
|
|
writel(tmp, mmio);
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp &= ~PDC_RESET;
|
|
|
|
writel(tmp, mmio);
|
|
|
|
readl(mmio); /* flush */
|
|
|
|
}
|
|
|
|
|
2007-03-11 21:20:43 +01:00
|
|
|
static int pdc_pata_cable_detect(struct ata_port *ap)
|
2005-08-29 11:12:30 +02:00
|
|
|
{
|
2006-05-24 07:43:25 +02:00
|
|
|
u8 tmp;
|
2007-05-28 13:07:20 +02:00
|
|
|
void __iomem *mmio = ap->ioaddr.cmd_addr + PDC_CTLSTAT + 0x03;
|
2006-05-24 07:43:25 +02:00
|
|
|
|
2007-03-11 21:20:43 +01:00
|
|
|
tmp = readb(mmio);
|
|
|
|
if (tmp & 0x01)
|
|
|
|
return ATA_CBL_PATA40;
|
|
|
|
return ATA_CBL_PATA80;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pdc_sata_cable_detect(struct ata_port *ap)
|
|
|
|
{
|
2007-03-09 00:06:47 +01:00
|
|
|
return ATA_CBL_SATA;
|
2006-05-24 07:43:25 +02:00
|
|
|
}
|
2005-08-29 11:12:30 +02:00
|
|
|
|
2007-07-16 07:29:40 +02:00
|
|
|
static int pdc_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-03-11 21:20:43 +01:00
|
|
|
if (sc_reg > SCR_CONTROL)
|
2007-07-16 07:29:40 +02:00
|
|
|
return -EINVAL;
|
|
|
|
*val = readl(ap->ioaddr.scr_addr + (sc_reg * 4));
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-07-16 07:29:40 +02:00
|
|
|
static int pdc_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-03-11 21:20:43 +01:00
|
|
|
if (sc_reg > SCR_CONTROL)
|
2007-07-16 07:29:40 +02:00
|
|
|
return -EINVAL;
|
2007-02-01 07:06:36 +01:00
|
|
|
writel(val, ap->ioaddr.scr_addr + (sc_reg * 4));
|
2007-07-16 07:29:40 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-01-13 21:32:30 +01:00
|
|
|
static void pdc_atapi_pkt(struct ata_queued_cmd *qc)
|
2007-01-09 10:51:46 +01:00
|
|
|
{
|
2007-01-13 21:31:05 +01:00
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
dma_addr_t sg_table = ap->prd_dma;
|
|
|
|
unsigned int cdb_len = qc->dev->cdb_len;
|
|
|
|
u8 *cdb = qc->cdb;
|
|
|
|
struct pdc_port_priv *pp = ap->private_data;
|
|
|
|
u8 *buf = pp->pkt;
|
2008-03-25 06:18:11 +01:00
|
|
|
__le32 *buf32 = (__le32 *) buf;
|
2007-12-04 05:33:30 +01:00
|
|
|
unsigned int dev_sel, feature;
|
2007-01-09 10:51:46 +01:00
|
|
|
|
|
|
|
/* set control bits (byte 0), zero delay seq id (byte 3),
|
|
|
|
* and seq id (byte 2)
|
|
|
|
*/
|
2007-01-13 21:32:30 +01:00
|
|
|
switch (qc->tf.protocol) {
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_DMA:
|
2007-01-13 21:32:30 +01:00
|
|
|
if (!(qc->tf.flags & ATA_TFLAG_WRITE))
|
|
|
|
buf32[0] = cpu_to_le32(PDC_PKT_READ);
|
|
|
|
else
|
|
|
|
buf32[0] = 0;
|
|
|
|
break;
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_NODATA:
|
2007-01-13 21:32:30 +01:00
|
|
|
buf32[0] = cpu_to_le32(PDC_PKT_NODATA);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
break;
|
|
|
|
}
|
2007-01-09 10:51:46 +01:00
|
|
|
buf32[1] = cpu_to_le32(sg_table); /* S/G table addr */
|
|
|
|
buf32[2] = 0; /* no next-packet */
|
|
|
|
|
2007-01-13 21:31:05 +01:00
|
|
|
/* select drive */
|
2007-12-04 05:33:30 +01:00
|
|
|
if (sata_scr_valid(&ap->link))
|
2007-01-13 21:31:05 +01:00
|
|
|
dev_sel = PDC_DEVICE_SATA;
|
2007-12-04 05:33:30 +01:00
|
|
|
else
|
|
|
|
dev_sel = qc->tf.device;
|
|
|
|
|
2007-01-13 21:31:05 +01:00
|
|
|
buf[12] = (1 << 5) | ATA_REG_DEVICE;
|
|
|
|
buf[13] = dev_sel;
|
|
|
|
buf[14] = (1 << 5) | ATA_REG_DEVICE | PDC_PKT_CLEAR_BSY;
|
|
|
|
buf[15] = dev_sel; /* once more, waiting for BSY to clear */
|
|
|
|
|
|
|
|
buf[16] = (1 << 5) | ATA_REG_NSECT;
|
2007-12-04 05:33:30 +01:00
|
|
|
buf[17] = qc->tf.nsect;
|
2007-01-13 21:31:05 +01:00
|
|
|
buf[18] = (1 << 5) | ATA_REG_LBAL;
|
2007-12-04 05:33:30 +01:00
|
|
|
buf[19] = qc->tf.lbal;
|
2007-01-13 21:31:05 +01:00
|
|
|
|
|
|
|
/* set feature and byte counter registers */
|
2007-12-18 22:34:43 +01:00
|
|
|
if (qc->tf.protocol != ATAPI_PROT_DMA)
|
2007-01-13 21:31:05 +01:00
|
|
|
feature = PDC_FEATURE_ATAPI_PIO;
|
2007-12-04 05:33:30 +01:00
|
|
|
else
|
2007-01-13 21:31:05 +01:00
|
|
|
feature = PDC_FEATURE_ATAPI_DMA;
|
2007-12-04 05:33:30 +01:00
|
|
|
|
2007-01-13 21:31:05 +01:00
|
|
|
buf[20] = (1 << 5) | ATA_REG_FEATURE;
|
|
|
|
buf[21] = feature;
|
|
|
|
buf[22] = (1 << 5) | ATA_REG_BYTEL;
|
2007-12-04 05:33:30 +01:00
|
|
|
buf[23] = qc->tf.lbam;
|
2007-01-13 21:31:05 +01:00
|
|
|
buf[24] = (1 << 5) | ATA_REG_BYTEH;
|
2007-12-04 05:33:30 +01:00
|
|
|
buf[25] = qc->tf.lbah;
|
2007-01-13 21:31:05 +01:00
|
|
|
|
|
|
|
/* send ATAPI packet command 0xA0 */
|
|
|
|
buf[26] = (1 << 5) | ATA_REG_CMD;
|
2007-12-04 05:33:30 +01:00
|
|
|
buf[27] = qc->tf.command;
|
2007-01-13 21:31:05 +01:00
|
|
|
|
|
|
|
/* select drive and check DRQ */
|
|
|
|
buf[28] = (1 << 5) | ATA_REG_DEVICE | PDC_PKT_WAIT_DRDY;
|
|
|
|
buf[29] = dev_sel;
|
|
|
|
|
2007-01-09 10:51:46 +01:00
|
|
|
/* we can represent cdb lengths 2/4/6/8/10/12/14/16 */
|
|
|
|
BUG_ON(cdb_len & ~0x1E);
|
|
|
|
|
2007-01-13 21:31:05 +01:00
|
|
|
/* append the CDB as the final part */
|
|
|
|
buf[30] = (((cdb_len >> 1) & 7) << 5) | ATA_REG_DATA | PDC_LAST_REG;
|
|
|
|
memcpy(buf+31, cdb, cdb_len);
|
2007-01-09 10:51:46 +01:00
|
|
|
}
|
|
|
|
|
2007-10-30 14:20:49 +01:00
|
|
|
/**
|
|
|
|
* pdc_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.
|
|
|
|
* Make sure hardware does not choke on it.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* spin_lock_irqsave(host lock)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void pdc_fill_sg(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
struct scatterlist *sg;
|
|
|
|
const u32 SG_COUNT_ASIC_BUG = 41*4;
|
2007-12-05 08:43:11 +01:00
|
|
|
unsigned int si, idx;
|
|
|
|
u32 len;
|
2007-10-30 14:20:49 +01:00
|
|
|
|
|
|
|
if (!(qc->flags & ATA_QCFLAG_DMAMAP))
|
|
|
|
return;
|
|
|
|
|
|
|
|
idx = 0;
|
2007-12-05 08:43:11 +01:00
|
|
|
for_each_sg(qc->sg, sg, qc->n_elem, si) {
|
2007-10-30 14:20:49 +01:00
|
|
|
u32 addr, offset;
|
2008-02-14 06:14:08 +01:00
|
|
|
u32 sg_len;
|
2007-10-30 14:20:49 +01:00
|
|
|
|
|
|
|
/* determine if physical DMA addr spans 64K boundary.
|
|
|
|
* Note h/w doesn't support 64-bit, so we unconditionally
|
|
|
|
* truncate dma_addr_t to u32.
|
|
|
|
*/
|
|
|
|
addr = (u32) sg_dma_address(sg);
|
|
|
|
sg_len = sg_dma_len(sg);
|
|
|
|
|
|
|
|
while (sg_len) {
|
|
|
|
offset = addr & 0xffff;
|
|
|
|
len = sg_len;
|
|
|
|
if ((offset + sg_len) > 0x10000)
|
|
|
|
len = 0x10000 - offset;
|
|
|
|
|
|
|
|
ap->prd[idx].addr = cpu_to_le32(addr);
|
|
|
|
ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
|
|
|
|
VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
|
|
|
|
|
|
|
|
idx++;
|
|
|
|
sg_len -= len;
|
|
|
|
addr += len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-05 08:43:11 +01:00
|
|
|
len = le32_to_cpu(ap->prd[idx - 1].flags_len);
|
2007-10-30 14:20:49 +01:00
|
|
|
|
2007-12-05 08:43:11 +01:00
|
|
|
if (len > SG_COUNT_ASIC_BUG) {
|
|
|
|
u32 addr;
|
2007-10-30 14:20:49 +01:00
|
|
|
|
2007-12-05 08:43:11 +01:00
|
|
|
VPRINTK("Splitting last PRD.\n");
|
2007-10-30 14:20:49 +01:00
|
|
|
|
2007-12-05 08:43:11 +01:00
|
|
|
addr = le32_to_cpu(ap->prd[idx - 1].addr);
|
|
|
|
ap->prd[idx - 1].flags_len = cpu_to_le32(len - SG_COUNT_ASIC_BUG);
|
|
|
|
VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx - 1, addr, SG_COUNT_ASIC_BUG);
|
2007-10-30 14:20:49 +01:00
|
|
|
|
2007-12-05 08:43:11 +01:00
|
|
|
addr = addr + len - SG_COUNT_ASIC_BUG;
|
|
|
|
len = SG_COUNT_ASIC_BUG;
|
|
|
|
ap->prd[idx].addr = cpu_to_le32(addr);
|
|
|
|
ap->prd[idx].flags_len = cpu_to_le32(len);
|
|
|
|
VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
|
2007-10-30 14:20:49 +01:00
|
|
|
|
2007-12-05 08:43:11 +01:00
|
|
|
idx++;
|
2007-10-30 14:20:49 +01:00
|
|
|
}
|
2007-12-05 08:43:11 +01:00
|
|
|
|
|
|
|
ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
|
2007-10-30 14:20:49 +01:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static void pdc_qc_prep(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct pdc_port_priv *pp = qc->ap->private_data;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
VPRINTK("ENTER\n");
|
|
|
|
|
|
|
|
switch (qc->tf.protocol) {
|
|
|
|
case ATA_PROT_DMA:
|
2007-10-30 14:20:49 +01:00
|
|
|
pdc_fill_sg(qc);
|
2005-04-17 00:20:36 +02:00
|
|
|
/* fall through */
|
|
|
|
|
|
|
|
case ATA_PROT_NODATA:
|
|
|
|
i = pdc_pkt_header(&qc->tf, qc->ap->prd_dma,
|
|
|
|
qc->dev->devno, pp->pkt);
|
|
|
|
|
|
|
|
if (qc->tf.flags & ATA_TFLAG_LBA48)
|
|
|
|
i = pdc_prep_lba48(&qc->tf, pp->pkt, i);
|
|
|
|
else
|
|
|
|
i = pdc_prep_lba28(&qc->tf, pp->pkt, i);
|
|
|
|
|
|
|
|
pdc_pkt_footer(&qc->tf, pp->pkt, i);
|
|
|
|
break;
|
|
|
|
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_PIO:
|
2007-10-30 14:20:49 +01:00
|
|
|
pdc_fill_sg(qc);
|
2007-01-09 10:51:46 +01:00
|
|
|
break;
|
|
|
|
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_DMA:
|
2007-10-30 14:20:49 +01:00
|
|
|
pdc_fill_sg(qc);
|
2007-01-13 21:32:30 +01:00
|
|
|
/*FALLTHROUGH*/
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_NODATA:
|
2007-01-13 21:32:30 +01:00
|
|
|
pdc_atapi_pkt(qc);
|
2007-01-09 10:51:46 +01:00
|
|
|
break;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-23 18:41:01 +01:00
|
|
|
static int pdc_is_sataii_tx4(unsigned long flags)
|
|
|
|
{
|
|
|
|
const unsigned long mask = PDC_FLAG_GEN_II | PDC_FLAG_4_PORTS;
|
|
|
|
return (flags & mask) == mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int pdc_port_no_to_ata_no(unsigned int port_no,
|
|
|
|
int is_sataii_tx4)
|
|
|
|
{
|
|
|
|
static const unsigned char sataii_tx4_port_remap[4] = { 3, 1, 0, 2};
|
|
|
|
return is_sataii_tx4 ? sataii_tx4_port_remap[port_no] : port_no;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int pdc_sata_nr_ports(const struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return (ap->flags & PDC_FLAG_4_PORTS) ? 4 : 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int pdc_sata_ata_port_to_ata_no(const struct ata_port *ap)
|
|
|
|
{
|
|
|
|
const struct ata_host *host = ap->host;
|
|
|
|
unsigned int nr_ports = pdc_sata_nr_ports(ap);
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for(i = 0; i < nr_ports && host->ports[i] != ap; ++i)
|
|
|
|
;
|
|
|
|
BUG_ON(i >= nr_ports);
|
|
|
|
return pdc_port_no_to_ata_no(i, pdc_is_sataii_tx4(ap->flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int pdc_sata_hotplug_offset(const struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return (ap->flags & PDC_FLAG_GEN_II) ? PDC2_SATA_PLUG_CSR : PDC_SATA_PLUG_CSR;
|
|
|
|
}
|
|
|
|
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
static void pdc_freeze(struct ata_port *ap)
|
|
|
|
{
|
2007-05-28 13:07:20 +02:00
|
|
|
void __iomem *mmio = ap->ioaddr.cmd_addr;
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
tmp = readl(mmio + PDC_CTLSTAT);
|
|
|
|
tmp |= PDC_IRQ_DISABLE;
|
|
|
|
tmp &= ~PDC_DMA_ENABLE;
|
|
|
|
writel(tmp, mmio + PDC_CTLSTAT);
|
|
|
|
readl(mmio + PDC_CTLSTAT); /* flush */
|
|
|
|
}
|
|
|
|
|
2008-03-23 18:41:01 +01:00
|
|
|
static void pdc_sata_freeze(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct ata_host *host = ap->host;
|
|
|
|
void __iomem *host_mmio = host->iomap[PDC_MMIO_BAR];
|
|
|
|
unsigned int hotplug_offset = pdc_sata_hotplug_offset(ap);
|
|
|
|
unsigned int ata_no = pdc_sata_ata_port_to_ata_no(ap);
|
|
|
|
u32 hotplug_status;
|
|
|
|
|
|
|
|
/* Disable hotplug events on this port.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* 1) hotplug register accesses must be serialised via host->lock
|
|
|
|
* 2) ap->lock == &ap->host->lock
|
|
|
|
* 3) ->freeze() and ->thaw() are called with ap->lock held
|
|
|
|
*/
|
|
|
|
hotplug_status = readl(host_mmio + hotplug_offset);
|
|
|
|
hotplug_status |= 0x11 << (ata_no + 16);
|
|
|
|
writel(hotplug_status, host_mmio + hotplug_offset);
|
|
|
|
readl(host_mmio + hotplug_offset); /* flush */
|
|
|
|
|
|
|
|
pdc_freeze(ap);
|
|
|
|
}
|
|
|
|
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
static void pdc_thaw(struct ata_port *ap)
|
|
|
|
{
|
2007-05-28 13:07:20 +02:00
|
|
|
void __iomem *mmio = ap->ioaddr.cmd_addr;
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
/* clear IRQ */
|
|
|
|
readl(mmio + PDC_INT_SEQMASK);
|
|
|
|
|
|
|
|
/* turn IRQ back on */
|
|
|
|
tmp = readl(mmio + PDC_CTLSTAT);
|
|
|
|
tmp &= ~PDC_IRQ_DISABLE;
|
|
|
|
writel(tmp, mmio + PDC_CTLSTAT);
|
|
|
|
readl(mmio + PDC_CTLSTAT); /* flush */
|
|
|
|
}
|
|
|
|
|
2008-03-23 18:41:01 +01:00
|
|
|
static void pdc_sata_thaw(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct ata_host *host = ap->host;
|
|
|
|
void __iomem *host_mmio = host->iomap[PDC_MMIO_BAR];
|
|
|
|
unsigned int hotplug_offset = pdc_sata_hotplug_offset(ap);
|
|
|
|
unsigned int ata_no = pdc_sata_ata_port_to_ata_no(ap);
|
|
|
|
u32 hotplug_status;
|
|
|
|
|
|
|
|
pdc_thaw(ap);
|
|
|
|
|
|
|
|
/* Enable hotplug events on this port.
|
|
|
|
* Locking: see pdc_sata_freeze().
|
|
|
|
*/
|
|
|
|
hotplug_status = readl(host_mmio + hotplug_offset);
|
|
|
|
hotplug_status |= 0x11 << ata_no;
|
|
|
|
hotplug_status &= ~(0x11 << (ata_no + 16));
|
|
|
|
writel(hotplug_status, host_mmio + hotplug_offset);
|
|
|
|
readl(host_mmio + hotplug_offset); /* flush */
|
|
|
|
}
|
|
|
|
|
libata: make reset related methods proper port operations
Currently reset methods are not specified directly in the
ata_port_operations table. If a LLD wants to use custom reset
methods, it should construct and use a error_handler which uses those
reset methods. It's done this way for two reasons.
First, the ops table already contained too many methods and adding
four more of them would noticeably increase the amount of necessary
boilerplate code all over low level drivers.
Second, as ->error_handler uses those reset methods, it can get
confusing. ie. By overriding ->error_handler, those reset ops can be
made useless making layering a bit hazy.
Now that ops table uses inheritance, the first problem doesn't exist
anymore. The second isn't completely solved but is relieved by
providing default values - most drivers can just override what it has
implemented and don't have to concern itself about higher level
callbacks. In fact, there currently is no driver which actually
modifies error handling behavior. Drivers which override
->error_handler just wraps the standard error handler only to prepare
the controller for EH. I don't think making ops layering strict has
any noticeable benefit.
This patch makes ->prereset, ->softreset, ->hardreset, ->postreset and
their PMP counterparts propoer ops. Default ops are provided in the
base ops tables and drivers are converted to override individual reset
methods instead of creating custom error_handler.
* ata_std_error_handler() doesn't use sata_std_hardreset() if SCRs
aren't accessible. sata_promise doesn't need to use separate
error_handlers for PATA and SATA anymore.
* softreset is broken for sata_inic162x and sata_sx4. As libata now
always prefers hardreset, this doesn't really matter but the ops are
forced to NULL using ATA_OP_NULL for documentation purpose.
* pata_hpt374 needs to use different prereset for the first and second
PCI functions. This used to be done by branching from
hpt374_error_handler(). The proper way to do this is to use
separate ops and port_info tables for each function. Converted.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:50 +01:00
|
|
|
static void pdc_error_handler(struct ata_port *ap)
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
{
|
|
|
|
if (!(ap->pflags & ATA_PFLAG_FROZEN))
|
|
|
|
pdc_reset_port(ap);
|
|
|
|
|
libata: make reset related methods proper port operations
Currently reset methods are not specified directly in the
ata_port_operations table. If a LLD wants to use custom reset
methods, it should construct and use a error_handler which uses those
reset methods. It's done this way for two reasons.
First, the ops table already contained too many methods and adding
four more of them would noticeably increase the amount of necessary
boilerplate code all over low level drivers.
Second, as ->error_handler uses those reset methods, it can get
confusing. ie. By overriding ->error_handler, those reset ops can be
made useless making layering a bit hazy.
Now that ops table uses inheritance, the first problem doesn't exist
anymore. The second isn't completely solved but is relieved by
providing default values - most drivers can just override what it has
implemented and don't have to concern itself about higher level
callbacks. In fact, there currently is no driver which actually
modifies error handling behavior. Drivers which override
->error_handler just wraps the standard error handler only to prepare
the controller for EH. I don't think making ops layering strict has
any noticeable benefit.
This patch makes ->prereset, ->softreset, ->hardreset, ->postreset and
their PMP counterparts propoer ops. Default ops are provided in the
base ops tables and drivers are converted to override individual reset
methods instead of creating custom error_handler.
* ata_std_error_handler() doesn't use sata_std_hardreset() if SCRs
aren't accessible. sata_promise doesn't need to use separate
error_handlers for PATA and SATA anymore.
* softreset is broken for sata_inic162x and sata_sx4. As libata now
always prefers hardreset, this doesn't really matter but the ops are
forced to NULL using ATA_OP_NULL for documentation purpose.
* pata_hpt374 needs to use different prereset for the first and second
PCI functions. This used to be done by branching from
hpt374_error_handler(). The proper way to do this is to use
separate ops and port_info tables for each function. Converted.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 04:22:50 +01:00
|
|
|
ata_std_error_handler(ap);
|
2007-03-11 21:20:43 +01:00
|
|
|
}
|
|
|
|
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
static void pdc_post_internal_cmd(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
|
|
|
|
/* make DMA engine forget about the failed command */
|
2007-03-20 07:24:11 +01:00
|
|
|
if (qc->flags & ATA_QCFLAG_FAILED)
|
[PATCH] sata_promise: new EH conversion, take 2
This patch converts sata_promise to use new-style libata error
handling on Promise SATA chips, for both SATA and PATA ports.
* ATA_FLAG_SRST is no longer set
* ->phy_reset is no longer set as it is unused when ->error_handler
is present, and pdc_sata_phy_reset() has been removed
* pdc_freeze() masks interrupts and halts DMA via PDC_CTLSTAT
* pdc_thaw() clears interrupt status in PDC_INT_SEQMASK and then
unmasks interrupts in PDC_CTLSTAT
* pdc_error_handler() reinitialises the port if it isn't frozen,
and then invokes ata_do_eh() with standard {s,}ata reset methods
* pdc_post_internal_cmd() resets the port in case of errors
* the PATA-only 20619 chip continues to use old-style EH:
not by necessity but simply because I don't have documentation
for it or any way to test it
Since the previous version pdc_error_handler() has been rewritten
and it now mostly matches ahci and sata_sil24. In case anyone
wonders: the call to pdc_reset_port() isn't a heavy-duty reset,
it's a light-weight reset to quickly put a port into a sane state.
The discussion about the PCI flushes in pdc_freeze() and pdc_thaw()
seemed to end with a consensus that the flushes are OK and not
obviously redundant, so I decided to keep them for now.
This patch was prepared against 2.6.19-git7, but it also applies
to 2.6.19 + libata #upstream, with or without the revised sata_promise
cleanup patch I recently submitted.
This patch does conflict with the #promise-sata-pata patch:
this patch removes pdc_sata_phy_reset() while #promise-sata-pata
modifies it. The correct patch resolution is to remove the function.
Tested on 2037x and 2057x chips, with PATA patches on top and disks
on both SATA and PATA ports.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-12-07 00:06:51 +01:00
|
|
|
pdc_reset_port(ap);
|
|
|
|
}
|
|
|
|
|
2007-03-14 09:51:35 +01:00
|
|
|
static void pdc_error_intr(struct ata_port *ap, struct ata_queued_cmd *qc,
|
|
|
|
u32 port_status, u32 err_mask)
|
|
|
|
{
|
2007-08-06 11:36:22 +02:00
|
|
|
struct ata_eh_info *ehi = &ap->link.eh_info;
|
2007-03-14 09:51:35 +01:00
|
|
|
unsigned int ac_err_mask = 0;
|
|
|
|
|
|
|
|
ata_ehi_clear_desc(ehi);
|
|
|
|
ata_ehi_push_desc(ehi, "port_status 0x%08x", port_status);
|
|
|
|
port_status &= err_mask;
|
|
|
|
|
|
|
|
if (port_status & PDC_DRIVE_ERR)
|
|
|
|
ac_err_mask |= AC_ERR_DEV;
|
|
|
|
if (port_status & (PDC_OVERRUN_ERR | PDC_UNDERRUN_ERR))
|
|
|
|
ac_err_mask |= AC_ERR_HSM;
|
|
|
|
if (port_status & (PDC2_ATA_HBA_ERR | PDC2_ATA_DMA_CNT_ERR))
|
|
|
|
ac_err_mask |= AC_ERR_ATA_BUS;
|
|
|
|
if (port_status & (PDC_PH_ERR | PDC_SH_ERR | PDC_DH_ERR | PDC2_HTO_ERR
|
|
|
|
| PDC_PCI_SYS_ERR | PDC1_PCI_PARITY_ERR))
|
|
|
|
ac_err_mask |= AC_ERR_HOST_BUS;
|
|
|
|
|
2007-08-06 11:36:23 +02:00
|
|
|
if (sata_scr_valid(&ap->link)) {
|
2007-07-16 07:29:40 +02:00
|
|
|
u32 serror;
|
|
|
|
|
|
|
|
pdc_sata_scr_read(ap, SCR_ERROR, &serror);
|
|
|
|
ehi->serror |= serror;
|
|
|
|
}
|
2007-04-07 14:29:51 +02:00
|
|
|
|
2007-03-14 09:51:35 +01:00
|
|
|
qc->err_mask |= ac_err_mask;
|
2007-04-07 14:29:51 +02:00
|
|
|
|
|
|
|
pdc_reset_port(ap);
|
2007-05-06 22:12:31 +02:00
|
|
|
|
|
|
|
ata_port_abort(ap);
|
2007-03-14 09:51:35 +01:00
|
|
|
}
|
|
|
|
|
2007-06-19 21:53:30 +02:00
|
|
|
static inline unsigned int pdc_host_intr(struct ata_port *ap,
|
|
|
|
struct ata_queued_cmd *qc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-12-05 08:38:02 +01:00
|
|
|
unsigned int handled = 0;
|
2007-03-14 09:51:35 +01:00
|
|
|
void __iomem *port_mmio = ap->ioaddr.cmd_addr;
|
|
|
|
u32 port_status, err_mask;
|
|
|
|
|
|
|
|
err_mask = PDC_ERR_MASK;
|
2007-04-17 16:44:07 +02:00
|
|
|
if (ap->flags & PDC_FLAG_GEN_II)
|
2007-03-14 09:51:35 +01:00
|
|
|
err_mask &= ~PDC1_ERR_MASK;
|
|
|
|
else
|
|
|
|
err_mask &= ~PDC2_ERR_MASK;
|
|
|
|
port_status = readl(port_mmio + PDC_GLOBAL_CTL);
|
|
|
|
if (unlikely(port_status & err_mask)) {
|
|
|
|
pdc_error_intr(ap, qc, port_status, err_mask);
|
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (qc->tf.protocol) {
|
|
|
|
case ATA_PROT_DMA:
|
|
|
|
case ATA_PROT_NODATA:
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_DMA:
|
|
|
|
case ATAPI_PROT_NODATA:
|
2005-12-05 08:38:02 +01:00
|
|
|
qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
|
|
|
|
ata_qc_complete(qc);
|
2005-04-17 00:20:36 +02:00
|
|
|
handled = 1;
|
|
|
|
break;
|
|
|
|
|
2007-06-19 21:53:30 +02:00
|
|
|
default:
|
2005-09-27 11:34:38 +02:00
|
|
|
ap->stats.idle_irq++;
|
|
|
|
break;
|
2007-06-19 21:53:30 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-27 11:34:38 +02:00
|
|
|
return handled;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pdc_irq_clear(struct ata_port *ap)
|
|
|
|
{
|
2006-08-24 09:19:22 +02:00
|
|
|
struct ata_host *host = ap->host;
|
2007-02-01 07:06:36 +01:00
|
|
|
void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
readl(mmio + PDC_INT_SEQMASK);
|
|
|
|
}
|
|
|
|
|
2007-10-26 06:03:37 +02:00
|
|
|
static irqreturn_t pdc_interrupt(int irq, void *dev_instance)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-24 09:19:22 +02:00
|
|
|
struct ata_host *host = dev_instance;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct ata_port *ap;
|
|
|
|
u32 mask = 0;
|
|
|
|
unsigned int i, tmp;
|
|
|
|
unsigned int handled = 0;
|
2005-08-30 11:18:18 +02:00
|
|
|
void __iomem *mmio_base;
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
unsigned int hotplug_offset, ata_no;
|
|
|
|
u32 hotplug_status;
|
|
|
|
int is_sataii_tx4;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
VPRINTK("ENTER\n");
|
|
|
|
|
2007-02-01 07:06:36 +01:00
|
|
|
if (!host || !host->iomap[PDC_MMIO_BAR]) {
|
2005-04-17 00:20:36 +02:00
|
|
|
VPRINTK("QUICK EXIT\n");
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
2007-02-01 07:06:36 +01:00
|
|
|
mmio_base = host->iomap[PDC_MMIO_BAR];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-23 18:41:01 +01:00
|
|
|
spin_lock(&host->lock);
|
|
|
|
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
/* read and clear hotplug flags for all ports */
|
|
|
|
if (host->ports[0]->flags & PDC_FLAG_GEN_II)
|
|
|
|
hotplug_offset = PDC2_SATA_PLUG_CSR;
|
|
|
|
else
|
|
|
|
hotplug_offset = PDC_SATA_PLUG_CSR;
|
|
|
|
hotplug_status = readl(mmio_base + hotplug_offset);
|
|
|
|
if (hotplug_status & 0xff)
|
|
|
|
writel(hotplug_status | 0xff, mmio_base + hotplug_offset);
|
|
|
|
hotplug_status &= 0xff; /* clear uninteresting bits */
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* reading should also clear interrupts */
|
|
|
|
mask = readl(mmio_base + PDC_INT_SEQMASK);
|
|
|
|
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
if (mask == 0xffffffff && hotplug_status == 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
VPRINTK("QUICK EXIT 2\n");
|
2008-03-23 18:41:01 +01:00
|
|
|
goto done_irq;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-01-28 18:39:29 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
mask &= 0xffff; /* only 16 tags possible */
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
if (mask == 0 && hotplug_status == 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
VPRINTK("QUICK EXIT 3\n");
|
2006-01-28 18:39:29 +01:00
|
|
|
goto done_irq;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
writel(mask, mmio_base + PDC_INT_SEQMASK);
|
|
|
|
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
is_sataii_tx4 = pdc_is_sataii_tx4(host->ports[0]->flags);
|
|
|
|
|
2006-08-24 09:19:22 +02:00
|
|
|
for (i = 0; i < host->n_ports; i++) {
|
2005-04-17 00:20:36 +02:00
|
|
|
VPRINTK("port %u\n", i);
|
2006-08-24 09:19:22 +02:00
|
|
|
ap = host->ports[i];
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
|
|
|
|
/* check for a plug or unplug event */
|
|
|
|
ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4);
|
|
|
|
tmp = hotplug_status & (0x11 << ata_no);
|
|
|
|
if (tmp && ap &&
|
|
|
|
!(ap->flags & ATA_FLAG_DISABLED)) {
|
2007-08-06 11:36:22 +02:00
|
|
|
struct ata_eh_info *ehi = &ap->link.eh_info;
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
ata_ehi_clear_desc(ehi);
|
|
|
|
ata_ehi_hotplugged(ehi);
|
|
|
|
ata_ehi_push_desc(ehi, "hotplug_status %#x", tmp);
|
|
|
|
ata_port_freeze(ap);
|
|
|
|
++handled;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check for a packet interrupt */
|
2005-04-17 00:20:36 +02:00
|
|
|
tmp = mask & (1 << (i + 1));
|
2005-08-22 07:59:24 +02:00
|
|
|
if (tmp && ap &&
|
2006-04-02 16:30:40 +02:00
|
|
|
!(ap->flags & ATA_FLAG_DISABLED)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
struct ata_queued_cmd *qc;
|
|
|
|
|
2007-08-06 11:36:22 +02:00
|
|
|
qc = ata_qc_from_tag(ap, ap->link.active_tag);
|
2005-09-27 11:39:50 +02:00
|
|
|
if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
|
2005-04-17 00:20:36 +02:00
|
|
|
handled += pdc_host_intr(ap, qc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
VPRINTK("EXIT\n");
|
|
|
|
|
2006-01-28 18:39:29 +01:00
|
|
|
done_irq:
|
2006-08-24 09:19:22 +02:00
|
|
|
spin_unlock(&host->lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return IRQ_RETVAL(handled);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pdc_packet_start(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
struct pdc_port_priv *pp = ap->private_data;
|
2007-02-01 07:06:36 +01:00
|
|
|
void __iomem *mmio = ap->host->iomap[PDC_MMIO_BAR];
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int port_no = ap->port_no;
|
|
|
|
u8 seq = (u8) (port_no + 1);
|
|
|
|
|
|
|
|
VPRINTK("ENTER, ap %p\n", ap);
|
|
|
|
|
2007-02-01 07:06:36 +01:00
|
|
|
writel(0x00000001, mmio + (seq * 4));
|
|
|
|
readl(mmio + (seq * 4)); /* flush */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
pp->pkt[2] = seq;
|
|
|
|
wmb(); /* flush PRD, pkt writes */
|
2007-02-01 07:06:36 +01:00
|
|
|
writel(pp->pkt_dma, ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
|
|
|
|
readl(ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT); /* flush */
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-01-23 05:09:36 +01:00
|
|
|
static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
switch (qc->tf.protocol) {
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_NODATA:
|
2007-01-13 21:32:30 +01:00
|
|
|
if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
|
|
|
|
break;
|
|
|
|
/*FALLTHROUGH*/
|
2007-06-08 22:46:55 +02:00
|
|
|
case ATA_PROT_NODATA:
|
|
|
|
if (qc->tf.flags & ATA_TFLAG_POLLING)
|
|
|
|
break;
|
|
|
|
/*FALLTHROUGH*/
|
2007-12-18 22:34:43 +01:00
|
|
|
case ATAPI_PROT_DMA:
|
2005-04-17 00:20:36 +02:00
|
|
|
case ATA_PROT_DMA:
|
|
|
|
pdc_packet_start(qc);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ata_qc_issue_prot(qc);
|
|
|
|
}
|
|
|
|
|
2005-10-22 20:27:05 +02:00
|
|
|
static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-12-18 22:34:43 +01:00
|
|
|
WARN_ON(tf->protocol == ATA_PROT_DMA || tf->protocol == ATAPI_PROT_DMA);
|
2005-04-17 00:20:36 +02:00
|
|
|
ata_tf_load(ap, tf);
|
|
|
|
}
|
|
|
|
|
2007-10-26 06:03:37 +02:00
|
|
|
static void pdc_exec_command_mmio(struct ata_port *ap,
|
|
|
|
const struct ata_taskfile *tf)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-12-18 22:34:43 +01:00
|
|
|
WARN_ON(tf->protocol == ATA_PROT_DMA || tf->protocol == ATAPI_PROT_DMA);
|
2005-04-17 00:20:36 +02:00
|
|
|
ata_exec_command(ap, tf);
|
|
|
|
}
|
|
|
|
|
2007-01-09 10:51:46 +01:00
|
|
|
static int pdc_check_atapi_dma(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
u8 *scsicmd = qc->scsicmd->cmnd;
|
|
|
|
int pio = 1; /* atapi dma off by default */
|
|
|
|
|
|
|
|
/* Whitelist commands that may use DMA. */
|
|
|
|
switch (scsicmd[0]) {
|
|
|
|
case WRITE_12:
|
|
|
|
case WRITE_10:
|
|
|
|
case WRITE_6:
|
|
|
|
case READ_12:
|
|
|
|
case READ_10:
|
|
|
|
case READ_6:
|
|
|
|
case 0xad: /* READ_DVD_STRUCTURE */
|
|
|
|
case 0xbe: /* READ_CD */
|
|
|
|
pio = 0;
|
|
|
|
}
|
|
|
|
/* -45150 (FFFF4FA2) to -1 (FFFFFFFF) shall use PIO mode */
|
|
|
|
if (scsicmd[0] == WRITE_10) {
|
2007-10-26 06:03:37 +02:00
|
|
|
unsigned int lba =
|
|
|
|
(scsicmd[2] << 24) |
|
|
|
|
(scsicmd[3] << 16) |
|
|
|
|
(scsicmd[4] << 8) |
|
|
|
|
scsicmd[5];
|
2007-01-09 10:51:46 +01:00
|
|
|
if (lba >= 0xFFFF4FA2)
|
|
|
|
pio = 1;
|
|
|
|
}
|
|
|
|
return pio;
|
|
|
|
}
|
|
|
|
|
2007-03-11 21:20:43 +01:00
|
|
|
static int pdc_old_sata_check_atapi_dma(struct ata_queued_cmd *qc)
|
2007-01-09 10:51:46 +01:00
|
|
|
{
|
|
|
|
/* First generation chips cannot use ATAPI DMA on SATA ports */
|
2007-03-11 21:20:43 +01:00
|
|
|
return 1;
|
2007-01-09 10:51:46 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
static void pdc_ata_setup_port(struct ata_port *ap,
|
|
|
|
void __iomem *base, void __iomem *scr_addr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-04-17 16:44:07 +02:00
|
|
|
ap->ioaddr.cmd_addr = base;
|
|
|
|
ap->ioaddr.data_addr = base;
|
|
|
|
ap->ioaddr.feature_addr =
|
|
|
|
ap->ioaddr.error_addr = base + 0x4;
|
|
|
|
ap->ioaddr.nsect_addr = base + 0x8;
|
|
|
|
ap->ioaddr.lbal_addr = base + 0xc;
|
|
|
|
ap->ioaddr.lbam_addr = base + 0x10;
|
|
|
|
ap->ioaddr.lbah_addr = base + 0x14;
|
|
|
|
ap->ioaddr.device_addr = base + 0x18;
|
|
|
|
ap->ioaddr.command_addr =
|
|
|
|
ap->ioaddr.status_addr = base + 0x1c;
|
|
|
|
ap->ioaddr.altstatus_addr =
|
|
|
|
ap->ioaddr.ctl_addr = base + 0x38;
|
|
|
|
ap->ioaddr.scr_addr = scr_addr;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
static void pdc_host_init(struct ata_host *host)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-04-17 16:44:07 +02:00
|
|
|
void __iomem *mmio = host->iomap[PDC_MMIO_BAR];
|
|
|
|
int is_gen2 = host->ports[0]->flags & PDC_FLAG_GEN_II;
|
2006-12-06 09:55:43 +01:00
|
|
|
int hotplug_offset;
|
2005-04-17 00:20:36 +02:00
|
|
|
u32 tmp;
|
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
if (is_gen2)
|
2006-12-06 09:55:43 +01:00
|
|
|
hotplug_offset = PDC2_SATA_PLUG_CSR;
|
|
|
|
else
|
|
|
|
hotplug_offset = PDC_SATA_PLUG_CSR;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Except for the hotplug stuff, this is voodoo from the
|
|
|
|
* Promise driver. Label this entire section
|
|
|
|
* "TODO: figure out why we do this"
|
|
|
|
*/
|
|
|
|
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
/* enable BMR_BURST, maybe change FIFO_SHD to 8 dwords */
|
2005-04-17 00:20:36 +02:00
|
|
|
tmp = readl(mmio + PDC_FLASH_CTL);
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
tmp |= 0x02000; /* bit 13 (enable bmr burst) */
|
2007-04-17 16:44:07 +02:00
|
|
|
if (!is_gen2)
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
tmp |= 0x10000; /* bit 16 (fifo threshold at 8 dw) */
|
2005-04-17 00:20:36 +02:00
|
|
|
writel(tmp, mmio + PDC_FLASH_CTL);
|
|
|
|
|
|
|
|
/* clear plug/unplug flags for all ports */
|
2006-01-28 18:39:29 +01:00
|
|
|
tmp = readl(mmio + hotplug_offset);
|
|
|
|
writel(tmp | 0xff, mmio + hotplug_offset);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
/* unmask plug/unplug ints */
|
2006-01-28 18:39:29 +01:00
|
|
|
tmp = readl(mmio + hotplug_offset);
|
sata_promise: SATA hotplug support, take 2
This patch enables hotplugging of SATA devices in the
sata_promise driver. It's been tested successfully on
both first- and second-generation Promise SATA chips:
SATA150 TX2plus, SATAII150 TX2plus, SATAII150 TX4,
SATA300 TX2plus, and SATA300 TX4.
The only quirk I've seen is that hotplugging (insertion)
on the first-generation SATA150 TX2plus requires a lengthier
EH sequence than on the second-generation chips.
On the second-generation chips a simple soft reset seems
to suffice, but on the first-generation chip there's a
"port is slow to respond" after the initial soft reset,
after which libata issues a hard reset, and then the
device is recognised.
The hotplug checks are high up in the interrupt handling
path, not deep down in error_intr as in ahci/sata_sil24.
That's because the chip doesn't signal hotplug status changes
in the per-port status register: instead a global register
contains hotplug control and status flags for all ports.
I considered following the ahci/sata_sil24 structure, but
that would have required non-trivial changes to the interrupt
handling path, so I chose to keep the hotplug changes simple
and unobtrusive.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
--
This patch depends on the "sata_promise: cleanups" patch.
Changes since the previous version (posted June 19):
- Correct pdc_interrupt() to increment 'handled' also in
the hotplug case. This prevents IRQ_NONE from being
returned when an interrupt only has hotplug events to
handle, which could confuse the kernel's IRQ machinery.
- Added testing on the SATAII150 TX4.
drivers/ata/sata_promise.c | 41 ++++++++++++++++++++++++++++++++++++-----
1 files changed, 36 insertions(+), 5 deletions(-)
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-07-03 01:09:05 +02:00
|
|
|
writel(tmp & ~0xff0000, mmio + hotplug_offset);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
/* don't initialise TBG or SLEW on 2nd generation chips */
|
2007-04-17 16:44:07 +02:00
|
|
|
if (is_gen2)
|
[PATCH] sata_promise fixes and updates
This patch updates the sata_promise driver as follows:
- Correct typo in definition of PDC_TBG_MODE: it's at 0x41C not 0x41
in first-generation chips. This error caused PCI access alignment
exceptions on SPARC64, and on all platforms it disabled the expected
initialisation of TBG mode.
- Add flags field to struct pdc_host_priv. Define PDC_FLAG_GEN_II
and use it to distinguish first- and second-generation chips.
- Prevent the FLASH_CTL FIFO_SHD bit from being set to 1 on second-
generation chips. This matches Promises' ulsata2 driver.
- Prevent TBG mode and SLEW rate initialisation in second-generation chips.
These two registers have moved, TBG mode has been redefined, and
Promise's ulsata2 driver no longer attempts to initialise them.
- Correct PCI device table so devices 0x3570, 0x3571, and 0x3d73 are
marked as 2057x (2nd gen) not 2037x (1st gen).
- Correct PCI device table so device 0x3d17 is marked as 40518
(2nd gen 4 ports) not 20319 (1st gen 4 ports).
- Correct pdc_ata_init_one() to treat 20771 as a second-generation chip.
Tested on 0x3d75 (2nd gen), 0x3d73 (2nd gen), and 0x3373 (1st gen) chips.
The information comes from the newly uploaded Promise SATA HW specs,
Promise's ultra and ulsata2 drivers, and debugging on 3d75/3d73/3373 chips.
hp->hotplug_offset could now be removed and its value recomputed
in pdc_host_init() using hp->flags, but that would be a cleanup
not a functional change, so I'm ignoring it for now.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-11-22 22:00:15 +01:00
|
|
|
return;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* reduce TBG clock to 133 Mhz. */
|
|
|
|
tmp = readl(mmio + PDC_TBG_MODE);
|
|
|
|
tmp &= ~0x30000; /* clear bit 17, 16*/
|
|
|
|
tmp |= 0x10000; /* set bit 17:16 = 0:1 */
|
|
|
|
writel(tmp, mmio + PDC_TBG_MODE);
|
|
|
|
|
|
|
|
readl(mmio + PDC_TBG_MODE); /* flush */
|
|
|
|
msleep(10);
|
|
|
|
|
|
|
|
/* adjust slew rate control register. */
|
|
|
|
tmp = readl(mmio + PDC_SLEW_CTL);
|
|
|
|
tmp &= 0xFFFFF03F; /* clear bit 11 ~ 6 */
|
|
|
|
tmp |= 0x00000900; /* set bit 11-9 = 100b , bit 8-6 = 100 */
|
|
|
|
writel(tmp, mmio + PDC_SLEW_CTL);
|
|
|
|
}
|
|
|
|
|
2007-10-26 06:03:37 +02:00
|
|
|
static int pdc_ata_init_one(struct pci_dev *pdev,
|
|
|
|
const struct pci_device_id *ent)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
static int printed_version;
|
2007-04-17 16:44:07 +02:00
|
|
|
const struct ata_port_info *pi = &pdc_port_info[ent->driver_data];
|
|
|
|
const struct ata_port_info *ppi[PDC_MAX_PORTS];
|
|
|
|
struct ata_host *host;
|
2007-02-01 07:06:36 +01:00
|
|
|
void __iomem *base;
|
2007-04-17 16:44:07 +02:00
|
|
|
int n_ports, i, rc;
|
2007-05-06 22:14:01 +02:00
|
|
|
int is_sataii_tx4;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!printed_version++)
|
2005-10-30 20:39:11 +01:00
|
|
|
dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
/* enable and acquire resources */
|
2007-01-20 08:00:28 +01:00
|
|
|
rc = pcim_enable_device(pdev);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2007-02-01 07:06:36 +01:00
|
|
|
rc = pcim_iomap_regions(pdev, 1 << PDC_MMIO_BAR, DRV_NAME);
|
|
|
|
if (rc == -EBUSY)
|
2007-01-20 08:00:28 +01:00
|
|
|
pcim_pin_device(pdev);
|
2007-02-01 07:06:36 +01:00
|
|
|
if (rc)
|
2007-01-20 08:00:28 +01:00
|
|
|
return rc;
|
2007-04-17 16:44:07 +02:00
|
|
|
base = pcim_iomap_table(pdev)[PDC_MMIO_BAR];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
/* determine port configuration and setup host */
|
|
|
|
n_ports = 2;
|
|
|
|
if (pi->flags & PDC_FLAG_4_PORTS)
|
|
|
|
n_ports = 4;
|
|
|
|
for (i = 0; i < n_ports; i++)
|
|
|
|
ppi[i] = pi;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
if (pi->flags & PDC_FLAG_SATA_PATA) {
|
|
|
|
u8 tmp = readb(base + PDC_FLASH_CTL+1);
|
2007-06-19 21:53:30 +02:00
|
|
|
if (!(tmp & 0x80))
|
2007-04-17 16:44:07 +02:00
|
|
|
ppi[n_ports++] = pi + 1;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
|
|
|
|
if (!host) {
|
|
|
|
dev_printk(KERN_ERR, &pdev->dev, "failed to allocate host\n");
|
2007-01-20 08:00:28 +01:00
|
|
|
return -ENOMEM;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-04-17 16:44:07 +02:00
|
|
|
host->iomap = pcim_iomap_table(pdev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-06-19 21:53:30 +02:00
|
|
|
is_sataii_tx4 = pdc_is_sataii_tx4(pi->flags);
|
2007-05-06 22:14:01 +02:00
|
|
|
for (i = 0; i < host->n_ports; i++) {
|
2007-08-18 06:14:55 +02:00
|
|
|
struct ata_port *ap = host->ports[i];
|
2007-06-19 21:53:30 +02:00
|
|
|
unsigned int ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4);
|
2007-08-18 06:14:55 +02:00
|
|
|
unsigned int port_offset = 0x200 + ata_no * 0x80;
|
|
|
|
unsigned int scr_offset = 0x400 + ata_no * 0x100;
|
|
|
|
|
|
|
|
pdc_ata_setup_port(ap, base + port_offset, base + scr_offset);
|
|
|
|
|
|
|
|
ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
|
|
|
|
ata_port_pbar_desc(ap, PDC_MMIO_BAR, port_offset, "port");
|
2007-05-06 22:14:01 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* initialize adapter */
|
2007-04-17 16:44:07 +02:00
|
|
|
pdc_host_init(host);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-17 16:44:07 +02:00
|
|
|
/* start host, request IRQ and attach */
|
|
|
|
pci_set_master(pdev);
|
|
|
|
return ata_host_activate(host, pdev->irq, pdc_interrupt, IRQF_SHARED,
|
|
|
|
&pdc_ata_sht);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init pdc_ata_init(void)
|
|
|
|
{
|
2006-08-10 11:13:18 +02:00
|
|
|
return pci_register_driver(&pdc_ata_pci_driver);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit pdc_ata_exit(void)
|
|
|
|
{
|
|
|
|
pci_unregister_driver(&pdc_ata_pci_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Jeff Garzik");
|
2005-05-12 21:51:01 +02:00
|
|
|
MODULE_DESCRIPTION("Promise ATA TX2/TX4/TX4000 low-level driver");
|
2005-04-17 00:20:36 +02:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DEVICE_TABLE(pci, pdc_ata_pci_tbl);
|
|
|
|
MODULE_VERSION(DRV_VERSION);
|
|
|
|
|
|
|
|
module_init(pdc_ata_init);
|
|
|
|
module_exit(pdc_ata_exit);
|