2005-09-01 22:26:17 +00:00
|
|
|
/*
|
|
|
|
* sata_mv.c - Marvell SATA support
|
|
|
|
*
|
2009-03-10 22:51:04 +00:00
|
|
|
* Copyright 2008-2009: Marvell Corporation, all rights reserved.
|
2005-11-12 17:32:50 +00:00
|
|
|
* Copyright 2005: EMC Corporation, all rights reserved.
|
2005-11-18 19:04:23 +00:00
|
|
|
* Copyright 2005 Red Hat, Inc. All rights reserved.
|
2005-09-01 22:26:17 +00:00
|
|
|
*
|
2009-03-10 22:51:04 +00:00
|
|
|
* Originally written by Brett Russ.
|
|
|
|
* Extensive overhaul and enhancement by Mark Lord <mlord@pobox.com>.
|
|
|
|
*
|
2005-09-01 22:26:17 +00:00
|
|
|
* Please ALWAYS copy linux-ide@vger.kernel.org on emails.
|
|
|
|
*
|
|
|
|
* 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; version 2 of the License.
|
|
|
|
*
|
|
|
|
* 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; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2007-05-25 03:40:15 +00:00
|
|
|
/*
|
2008-04-19 18:54:41 +00:00
|
|
|
* sata_mv TODO list:
|
|
|
|
*
|
|
|
|
* --> Develop a low-power-consumption strategy, and implement it.
|
|
|
|
*
|
2009-03-11 02:01:17 +00:00
|
|
|
* --> Add sysfs attributes for per-chip / per-HC IRQ coalescing thresholds.
|
2008-04-19 18:54:41 +00:00
|
|
|
*
|
|
|
|
* --> [Experiment, Marvell value added] Is it possible to use target
|
|
|
|
* mode to cross-connect two Linux boxes with Marvell cards? If so,
|
|
|
|
* creating LibATA target mode support would be very interesting.
|
|
|
|
*
|
|
|
|
* Target mode, for those without docs, is the ability to directly
|
|
|
|
* connect two SATA ports.
|
|
|
|
*/
|
2007-05-25 03:40:15 +00:00
|
|
|
|
2009-04-06 19:24:14 +00:00
|
|
|
/*
|
|
|
|
* 80x1-B2 errata PCI#11:
|
|
|
|
*
|
|
|
|
* Users of the 6041/6081 Rev.B2 chips (current is C0)
|
|
|
|
* should be careful to insert those cards only onto PCI-X bus #0,
|
|
|
|
* and only in device slots 0..7, not higher. The chips may not
|
|
|
|
* work correctly otherwise (note: this is a pretty rare condition).
|
|
|
|
*/
|
|
|
|
|
2005-09-01 22:26:17 +00: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>
|
2008-02-05 07:43:44 +00:00
|
|
|
#include <linux/dmapool.h>
|
2005-09-01 22:26:17 +00:00
|
|
|
#include <linux/dma-mapping.h>
|
2005-10-30 19:39:11 +00:00
|
|
|
#include <linux/device.h>
|
2009-12-06 16:26:18 +00:00
|
|
|
#include <linux/clk.h>
|
2008-02-01 23:08:03 +00:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/ata_platform.h>
|
2008-03-27 18:51:39 +00:00
|
|
|
#include <linux/mbus.h>
|
2008-05-02 18:02:28 +00:00
|
|
|
#include <linux/bitops.h>
|
2005-09-01 22:26:17 +00:00
|
|
|
#include <scsi/scsi_host.h>
|
2005-11-07 05:59:37 +00:00
|
|
|
#include <scsi/scsi_cmnd.h>
|
2007-10-12 04:16:23 +00:00
|
|
|
#include <scsi/scsi_device.h>
|
2005-09-01 22:26:17 +00:00
|
|
|
#include <linux/libata.h>
|
|
|
|
|
|
|
|
#define DRV_NAME "sata_mv"
|
2009-04-06 20:43:45 +00:00
|
|
|
#define DRV_VERSION "1.28"
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-03-10 22:51:04 +00:00
|
|
|
/*
|
|
|
|
* module options
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int msi;
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
module_param(msi, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
|
|
|
|
#endif
|
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
static int irq_coalescing_io_count;
|
|
|
|
module_param(irq_coalescing_io_count, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(irq_coalescing_io_count,
|
|
|
|
"IRQ coalescing I/O count threshold (0..255)");
|
|
|
|
|
|
|
|
static int irq_coalescing_usecs;
|
|
|
|
module_param(irq_coalescing_usecs, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(irq_coalescing_usecs,
|
|
|
|
"IRQ coalescing time threshold in usecs");
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
enum {
|
|
|
|
/* BAR's are enumerated in terms of pci_resource_start() terms */
|
|
|
|
MV_PRIMARY_BAR = 0, /* offset 0x10: memory space */
|
|
|
|
MV_IO_BAR = 2, /* offset 0x18: IO space */
|
|
|
|
MV_MISC_BAR = 3, /* offset 0x1c: FLASH, NVRAM, SRAM */
|
|
|
|
|
|
|
|
MV_MAJOR_REG_AREA_SZ = 0x10000, /* 64KB */
|
|
|
|
MV_MINOR_REG_AREA_SZ = 0x2000, /* 8KB */
|
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
/* For use with both IRQ coalescing methods ("all ports" or "per-HC" */
|
|
|
|
COAL_CLOCKS_PER_USEC = 150, /* for calculating COAL_TIMEs */
|
|
|
|
MAX_COAL_TIME_THRESHOLD = ((1 << 24) - 1), /* internal clocks count */
|
|
|
|
MAX_COAL_IO_COUNT = 255, /* completed I/O count */
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
MV_PCI_REG_BASE = 0,
|
2006-05-19 20:24:56 +00:00
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
/*
|
|
|
|
* Per-chip ("all ports") interrupt coalescing feature.
|
|
|
|
* This is only for GEN_II / GEN_IIE hardware.
|
|
|
|
*
|
|
|
|
* Coalescing defers the interrupt until either the IO_THRESHOLD
|
|
|
|
* (count of completed I/Os) is met, or the TIME_THRESHOLD is met.
|
|
|
|
*/
|
2009-04-06 20:43:45 +00:00
|
|
|
COAL_REG_BASE = 0x18000,
|
|
|
|
IRQ_COAL_CAUSE = (COAL_REG_BASE + 0x08),
|
2009-03-11 02:01:17 +00:00
|
|
|
ALL_PORTS_COAL_IRQ = (1 << 4), /* all ports irq event */
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
IRQ_COAL_IO_THRESHOLD = (COAL_REG_BASE + 0xcc),
|
|
|
|
IRQ_COAL_TIME_THRESHOLD = (COAL_REG_BASE + 0xd0),
|
2009-03-11 02:01:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Registers for the (unused here) transaction coalescing feature:
|
|
|
|
*/
|
2009-04-06 20:43:45 +00:00
|
|
|
TRAN_COAL_CAUSE_LO = (COAL_REG_BASE + 0x88),
|
|
|
|
TRAN_COAL_CAUSE_HI = (COAL_REG_BASE + 0x8c),
|
2009-03-11 02:01:17 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
SATAHC0_REG_BASE = 0x20000,
|
|
|
|
FLASH_CTL = 0x1046c,
|
|
|
|
GPIO_PORT_CTL = 0x104f0,
|
|
|
|
RESET_CFG = 0x180d8,
|
2005-09-01 22:26:17 +00:00
|
|
|
|
|
|
|
MV_PCI_REG_SZ = MV_MAJOR_REG_AREA_SZ,
|
|
|
|
MV_SATAHC_REG_SZ = MV_MAJOR_REG_AREA_SZ,
|
|
|
|
MV_SATAHC_ARBTR_REG_SZ = MV_MINOR_REG_AREA_SZ, /* arbiter */
|
|
|
|
MV_PORT_REG_SZ = MV_MINOR_REG_AREA_SZ,
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
MV_MAX_Q_DEPTH = 32,
|
|
|
|
MV_MAX_Q_DEPTH_MASK = MV_MAX_Q_DEPTH - 1,
|
|
|
|
|
|
|
|
/* CRQB needs alignment on a 1KB boundary. Size == 1KB
|
|
|
|
* CRPB needs alignment on a 256B boundary. Size == 256B
|
|
|
|
* ePRD (SG) entries need alignment on a 16B boundary. Size == 16B
|
|
|
|
*/
|
|
|
|
MV_CRQB_Q_SZ = (32 * MV_MAX_Q_DEPTH),
|
|
|
|
MV_CRPB_Q_SZ = (8 * MV_MAX_Q_DEPTH),
|
2008-01-26 23:32:45 +00:00
|
|
|
MV_MAX_SG_CT = 256,
|
2005-09-30 05:36:00 +00:00
|
|
|
MV_SG_TBL_SZ = (16 * MV_MAX_SG_CT),
|
|
|
|
|
2008-04-19 18:43:42 +00:00
|
|
|
/* Determine hc from 0-7 port: hc = port >> MV_PORT_HC_SHIFT */
|
2005-09-01 22:26:17 +00:00
|
|
|
MV_PORT_HC_SHIFT = 2,
|
2008-04-19 18:43:42 +00:00
|
|
|
MV_PORTS_PER_HC = (1 << MV_PORT_HC_SHIFT), /* 4 */
|
|
|
|
/* Determine hc port from 0-7 port: hardport = port & MV_PORT_MASK */
|
|
|
|
MV_PORT_MASK = (MV_PORTS_PER_HC - 1), /* 3 */
|
2005-09-01 22:26:17 +00:00
|
|
|
|
|
|
|
/* Host Flags */
|
|
|
|
MV_FLAG_DUAL_HC = (1 << 30), /* two SATA Host Controllers */
|
2008-01-30 22:50:45 +00:00
|
|
|
|
2007-07-11 22:30:50 +00:00
|
|
|
MV_COMMON_FLAGS = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
|
2009-01-30 23:46:39 +00:00
|
|
|
ATA_FLAG_MMIO | ATA_FLAG_PIO_POLLING,
|
2008-05-14 13:21:43 +00:00
|
|
|
|
2009-01-30 23:46:39 +00:00
|
|
|
MV_GEN_I_FLAGS = MV_COMMON_FLAGS | ATA_FLAG_NO_ATAPI,
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-03-10 22:51:04 +00:00
|
|
|
MV_GEN_II_FLAGS = MV_COMMON_FLAGS | ATA_FLAG_NCQ |
|
|
|
|
ATA_FLAG_PMP | ATA_FLAG_ACPI_SATA,
|
2009-01-30 23:46:39 +00:00
|
|
|
|
|
|
|
MV_GEN_IIE_FLAGS = MV_GEN_II_FLAGS | ATA_FLAG_AN,
|
2008-05-14 13:21:43 +00:00
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
CRQB_FLAG_READ = (1 << 0),
|
|
|
|
CRQB_TAG_SHIFT = 1,
|
2007-07-11 22:30:50 +00:00
|
|
|
CRQB_IOID_SHIFT = 6, /* CRQB Gen-II/IIE IO Id shift */
|
2008-03-31 23:33:56 +00:00
|
|
|
CRQB_PMP_SHIFT = 12, /* CRQB Gen-II/IIE PMP shift */
|
2007-07-11 22:30:50 +00:00
|
|
|
CRQB_HOSTQ_SHIFT = 17, /* CRQB Gen-II/IIE HostQueTag shift */
|
2005-09-30 05:36:00 +00:00
|
|
|
CRQB_CMD_ADDR_SHIFT = 8,
|
|
|
|
CRQB_CMD_CS = (0x2 << 11),
|
|
|
|
CRQB_CMD_LAST = (1 << 15),
|
|
|
|
|
|
|
|
CRPB_FLAG_STATUS_SHIFT = 8,
|
2007-07-11 22:30:50 +00:00
|
|
|
CRPB_IOID_SHIFT_6 = 5, /* CRPB Gen-II IO Id shift */
|
|
|
|
CRPB_IOID_SHIFT_7 = 7, /* CRPB Gen-IIE IO Id shift */
|
2005-09-30 05:36:00 +00:00
|
|
|
|
|
|
|
EPRD_FLAG_END_OF_TBL = (1 << 31),
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
/* PCI interface registers */
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
MV_PCI_COMMAND = 0xc00,
|
|
|
|
MV_PCI_COMMAND_MWRCOM = (1 << 4), /* PCI Master Write Combining */
|
|
|
|
MV_PCI_COMMAND_MRDTRIG = (1 << 7), /* PCI Master Read Trigger */
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
PCI_MAIN_CMD_STS = 0xd30,
|
2005-09-01 22:26:17 +00:00
|
|
|
STOP_PCI_MASTER = (1 << 2),
|
|
|
|
PCI_MASTER_EMPTY = (1 << 3),
|
|
|
|
GLOB_SFT_RST = (1 << 4),
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
MV_PCI_MODE = 0xd00,
|
2008-05-02 06:07:51 +00:00
|
|
|
MV_PCI_MODE_MASK = 0x30,
|
|
|
|
|
2005-11-13 03:14:02 +00:00
|
|
|
MV_PCI_EXP_ROM_BAR_CTL = 0xd2c,
|
|
|
|
MV_PCI_DISC_TIMER = 0xd04,
|
|
|
|
MV_PCI_MSI_TRIGGER = 0xc38,
|
|
|
|
MV_PCI_SERR_MASK = 0xc28,
|
2009-04-06 20:43:45 +00:00
|
|
|
MV_PCI_XBAR_TMOUT = 0x1d04,
|
2005-11-13 03:14:02 +00:00
|
|
|
MV_PCI_ERR_LOW_ADDRESS = 0x1d40,
|
|
|
|
MV_PCI_ERR_HIGH_ADDRESS = 0x1d44,
|
|
|
|
MV_PCI_ERR_ATTRIBUTE = 0x1d48,
|
|
|
|
MV_PCI_ERR_COMMAND = 0x1d50,
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
PCI_IRQ_CAUSE = 0x1d58,
|
|
|
|
PCI_IRQ_MASK = 0x1d5c,
|
2005-09-01 22:26:17 +00:00
|
|
|
PCI_UNMASK_ALL_IRQS = 0x7fffff, /* bits 22-0 */
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
PCIE_IRQ_CAUSE = 0x1900,
|
|
|
|
PCIE_IRQ_MASK = 0x1910,
|
2008-01-26 23:30:37 +00:00
|
|
|
PCIE_UNMASK_ALL_IRQS = 0x40a, /* assorted bits */
|
2007-12-01 18:07:22 +00:00
|
|
|
|
2008-04-25 15:24:24 +00:00
|
|
|
/* Host Controller Main Interrupt Cause/Mask registers (1 per-chip) */
|
2009-04-06 20:43:45 +00:00
|
|
|
PCI_HC_MAIN_IRQ_CAUSE = 0x1d60,
|
|
|
|
PCI_HC_MAIN_IRQ_MASK = 0x1d64,
|
|
|
|
SOC_HC_MAIN_IRQ_CAUSE = 0x20020,
|
|
|
|
SOC_HC_MAIN_IRQ_MASK = 0x20024,
|
2009-03-10 22:51:04 +00:00
|
|
|
ERR_IRQ = (1 << 0), /* shift by (2 * port #) */
|
|
|
|
DONE_IRQ = (1 << 1), /* shift by (2 * port #) */
|
2005-09-01 22:26:17 +00:00
|
|
|
HC0_IRQ_PEND = 0x1ff, /* bits 0-8 = HC0's ports */
|
|
|
|
HC_SHIFT = 9, /* bits 9-17 = HC1's ports */
|
2009-03-11 02:01:17 +00:00
|
|
|
DONE_IRQ_0_3 = 0x000000aa, /* DONE_IRQ ports 0,1,2,3 */
|
|
|
|
DONE_IRQ_4_7 = (DONE_IRQ_0_3 << HC_SHIFT), /* 4,5,6,7 */
|
2005-09-01 22:26:17 +00:00
|
|
|
PCI_ERR = (1 << 18),
|
2009-03-10 22:51:04 +00:00
|
|
|
TRAN_COAL_LO_DONE = (1 << 19), /* transaction coalescing */
|
|
|
|
TRAN_COAL_HI_DONE = (1 << 20), /* transaction coalescing */
|
|
|
|
PORTS_0_3_COAL_DONE = (1 << 8), /* HC0 IRQ coalescing */
|
|
|
|
PORTS_4_7_COAL_DONE = (1 << 17), /* HC1 IRQ coalescing */
|
|
|
|
ALL_PORTS_COAL_DONE = (1 << 21), /* GEN_II(E) IRQ coalescing */
|
2005-09-01 22:26:17 +00:00
|
|
|
GPIO_INT = (1 << 22),
|
|
|
|
SELF_INT = (1 << 23),
|
|
|
|
TWSI_INT = (1 << 24),
|
|
|
|
HC_MAIN_RSVD = (0x7f << 25), /* bits 31-25 */
|
2007-02-25 09:19:45 +00:00
|
|
|
HC_MAIN_RSVD_5 = (0x1fff << 19), /* bits 31-19 */
|
2008-03-31 23:33:56 +00:00
|
|
|
HC_MAIN_RSVD_SOC = (0x3fffffb << 6), /* bits 31-9, 7-6 */
|
2005-09-01 22:26:17 +00:00
|
|
|
|
|
|
|
/* SATAHC registers */
|
2009-04-06 20:43:45 +00:00
|
|
|
HC_CFG = 0x00,
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
HC_IRQ_CAUSE = 0x14,
|
2008-04-19 18:43:42 +00:00
|
|
|
DMA_IRQ = (1 << 0), /* shift by port # */
|
|
|
|
HC_COAL_IRQ = (1 << 4), /* IRQ coalescing */
|
2005-09-01 22:26:17 +00:00
|
|
|
DEV_IRQ = (1 << 8), /* shift by port # */
|
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
/*
|
|
|
|
* Per-HC (Host-Controller) interrupt coalescing feature.
|
|
|
|
* This is present on all chip generations.
|
|
|
|
*
|
|
|
|
* Coalescing defers the interrupt until either the IO_THRESHOLD
|
|
|
|
* (count of completed I/Os) is met, or the TIME_THRESHOLD is met.
|
|
|
|
*/
|
2009-04-06 20:43:45 +00:00
|
|
|
HC_IRQ_COAL_IO_THRESHOLD = 0x000c,
|
|
|
|
HC_IRQ_COAL_TIME_THRESHOLD = 0x0010,
|
2009-03-11 02:01:17 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
SOC_LED_CTRL = 0x2c,
|
2009-03-15 15:33:19 +00:00
|
|
|
SOC_LED_CTRL_BLINK = (1 << 0), /* Active LED blink */
|
|
|
|
SOC_LED_CTRL_ACT_PRESENCE = (1 << 2), /* Multiplex dev presence */
|
|
|
|
/* with dev activity LED */
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
/* Shadow block registers */
|
2009-04-06 20:43:45 +00:00
|
|
|
SHD_BLK = 0x100,
|
|
|
|
SHD_CTL_AST = 0x20, /* ofs from SHD_BLK */
|
2005-09-01 22:26:17 +00:00
|
|
|
|
|
|
|
/* SATA registers */
|
2009-04-06 20:43:45 +00:00
|
|
|
SATA_STATUS = 0x300, /* ctrl, err regs follow status */
|
|
|
|
SATA_ACTIVE = 0x350,
|
|
|
|
FIS_IRQ_CAUSE = 0x364,
|
|
|
|
FIS_IRQ_CAUSE_AN = (1 << 9), /* async notification */
|
2008-04-16 18:56:51 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
LTMODE = 0x30c, /* requires read-after-write */
|
2008-04-16 18:56:51 +00:00
|
|
|
LTMODE_BIT8 = (1 << 8), /* unknown, but necessary */
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
PHY_MODE2 = 0x330,
|
2005-11-13 02:13:17 +00:00
|
|
|
PHY_MODE3 = 0x310,
|
2009-04-06 20:43:45 +00:00
|
|
|
|
|
|
|
PHY_MODE4 = 0x314, /* requires read-after-write */
|
2008-05-31 20:46:34 +00:00
|
|
|
PHY_MODE4_CFG_MASK = 0x00000003, /* phy internal config field */
|
|
|
|
PHY_MODE4_CFG_VALUE = 0x00000001, /* phy internal config field */
|
|
|
|
PHY_MODE4_RSVD_ZEROS = 0x5de3fffa, /* Gen2e always write zeros */
|
|
|
|
PHY_MODE4_RSVD_ONES = 0x00000005, /* Gen2e always write ones */
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
SATA_IFCTL = 0x344,
|
|
|
|
SATA_TESTCTL = 0x348,
|
|
|
|
SATA_IFSTAT = 0x34c,
|
|
|
|
VENDOR_UNIQUE_FIS = 0x35c,
|
2008-04-16 18:56:51 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
FISCFG = 0x360,
|
2008-05-02 06:07:51 +00:00
|
|
|
FISCFG_WAIT_DEV_ERR = (1 << 8), /* wait for host on DevErr */
|
|
|
|
FISCFG_SINGLE_SYNC = (1 << 16), /* SYNC on DMA activation */
|
2008-04-16 18:56:51 +00:00
|
|
|
|
2009-05-04 18:58:50 +00:00
|
|
|
PHY_MODE9_GEN2 = 0x398,
|
|
|
|
PHY_MODE9_GEN1 = 0x39c,
|
|
|
|
PHYCFG_OFS = 0x3a0, /* only in 65n devices */
|
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
MV5_PHY_MODE = 0x74,
|
2009-04-06 20:43:45 +00:00
|
|
|
MV5_LTMODE = 0x30,
|
|
|
|
MV5_PHY_CTL = 0x0C,
|
|
|
|
SATA_IFCFG = 0x050,
|
2005-11-12 17:48:15 +00:00
|
|
|
|
|
|
|
MV_M2_PREAMP_MASK = 0x7e0,
|
2005-09-01 22:26:17 +00:00
|
|
|
|
|
|
|
/* Port registers */
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_CFG = 0,
|
2008-01-26 23:31:16 +00:00
|
|
|
EDMA_CFG_Q_DEPTH = 0x1f, /* max device queue depth */
|
|
|
|
EDMA_CFG_NCQ = (1 << 5), /* for R/W FPDMA queued */
|
|
|
|
EDMA_CFG_NCQ_GO_ON_ERR = (1 << 14), /* continue on error */
|
|
|
|
EDMA_CFG_RD_BRST_EXT = (1 << 11), /* read burst 512B */
|
|
|
|
EDMA_CFG_WR_BUFF_LEN = (1 << 13), /* write buffer 512B */
|
2008-03-31 23:33:56 +00:00
|
|
|
EDMA_CFG_EDMA_FBS = (1 << 16), /* EDMA FIS-Based Switching */
|
|
|
|
EDMA_CFG_FBS = (1 << 26), /* FIS-Based Switching */
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_ERR_IRQ_CAUSE = 0x8,
|
|
|
|
EDMA_ERR_IRQ_MASK = 0xc,
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_D_PAR = (1 << 0), /* UDMA data parity err */
|
|
|
|
EDMA_ERR_PRD_PAR = (1 << 1), /* UDMA PRD parity err */
|
|
|
|
EDMA_ERR_DEV = (1 << 2), /* device error */
|
|
|
|
EDMA_ERR_DEV_DCON = (1 << 3), /* device disconnect */
|
|
|
|
EDMA_ERR_DEV_CON = (1 << 4), /* device connected */
|
|
|
|
EDMA_ERR_SERR = (1 << 5), /* SError bits [WBDST] raised */
|
2007-07-11 22:30:50 +00:00
|
|
|
EDMA_ERR_SELF_DIS = (1 << 7), /* Gen II/IIE self-disable */
|
|
|
|
EDMA_ERR_SELF_DIS_5 = (1 << 8), /* Gen I self-disable */
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_BIST_ASYNC = (1 << 8), /* BIST FIS or Async Notify */
|
2007-07-11 22:30:50 +00:00
|
|
|
EDMA_ERR_TRANS_IRQ_7 = (1 << 8), /* Gen IIE transprt layer irq */
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_CRQB_PAR = (1 << 9), /* CRQB parity error */
|
|
|
|
EDMA_ERR_CRPB_PAR = (1 << 10), /* CRPB parity error */
|
|
|
|
EDMA_ERR_INTRL_PAR = (1 << 11), /* internal parity error */
|
|
|
|
EDMA_ERR_IORDY = (1 << 12), /* IORdy timeout */
|
2008-01-26 23:30:37 +00:00
|
|
|
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_LNK_CTRL_RX = (0xf << 13), /* link ctrl rx error */
|
2008-01-26 23:30:37 +00:00
|
|
|
EDMA_ERR_LNK_CTRL_RX_0 = (1 << 13), /* transient: CRC err */
|
|
|
|
EDMA_ERR_LNK_CTRL_RX_1 = (1 << 14), /* transient: FIFO err */
|
|
|
|
EDMA_ERR_LNK_CTRL_RX_2 = (1 << 15), /* fatal: caught SYNC */
|
|
|
|
EDMA_ERR_LNK_CTRL_RX_3 = (1 << 16), /* transient: FIS rx err */
|
|
|
|
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_LNK_DATA_RX = (0xf << 17), /* link data rx error */
|
2008-01-26 23:30:37 +00:00
|
|
|
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_LNK_CTRL_TX = (0x1f << 21), /* link ctrl tx error */
|
2008-01-26 23:30:37 +00:00
|
|
|
EDMA_ERR_LNK_CTRL_TX_0 = (1 << 21), /* transient: CRC err */
|
|
|
|
EDMA_ERR_LNK_CTRL_TX_1 = (1 << 22), /* transient: FIFO err */
|
|
|
|
EDMA_ERR_LNK_CTRL_TX_2 = (1 << 23), /* transient: caught SYNC */
|
|
|
|
EDMA_ERR_LNK_CTRL_TX_3 = (1 << 24), /* transient: caught DMAT */
|
|
|
|
EDMA_ERR_LNK_CTRL_TX_4 = (1 << 25), /* transient: FIS collision */
|
|
|
|
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_LNK_DATA_TX = (0x1f << 26), /* link data tx error */
|
2008-01-26 23:30:37 +00:00
|
|
|
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_TRANS_PROTO = (1 << 31), /* transport protocol error */
|
2007-07-11 22:30:50 +00:00
|
|
|
EDMA_ERR_OVERRUN_5 = (1 << 5),
|
|
|
|
EDMA_ERR_UNDERRUN_5 = (1 << 6),
|
2008-01-26 23:30:37 +00:00
|
|
|
|
|
|
|
EDMA_ERR_IRQ_TRANSIENT = EDMA_ERR_LNK_CTRL_RX_0 |
|
|
|
|
EDMA_ERR_LNK_CTRL_RX_1 |
|
|
|
|
EDMA_ERR_LNK_CTRL_RX_3 |
|
2008-04-19 18:54:41 +00:00
|
|
|
EDMA_ERR_LNK_CTRL_TX,
|
2008-01-26 23:30:37 +00:00
|
|
|
|
2007-07-12 18:34:26 +00:00
|
|
|
EDMA_EH_FREEZE = EDMA_ERR_D_PAR |
|
|
|
|
EDMA_ERR_PRD_PAR |
|
|
|
|
EDMA_ERR_DEV_DCON |
|
|
|
|
EDMA_ERR_DEV_CON |
|
|
|
|
EDMA_ERR_SERR |
|
|
|
|
EDMA_ERR_SELF_DIS |
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_CRQB_PAR |
|
2007-07-12 18:34:26 +00:00
|
|
|
EDMA_ERR_CRPB_PAR |
|
|
|
|
EDMA_ERR_INTRL_PAR |
|
|
|
|
EDMA_ERR_IORDY |
|
|
|
|
EDMA_ERR_LNK_CTRL_RX_2 |
|
|
|
|
EDMA_ERR_LNK_DATA_RX |
|
|
|
|
EDMA_ERR_LNK_DATA_TX |
|
|
|
|
EDMA_ERR_TRANS_PROTO,
|
2008-03-31 23:33:56 +00:00
|
|
|
|
2007-07-12 18:34:26 +00:00
|
|
|
EDMA_EH_FREEZE_5 = EDMA_ERR_D_PAR |
|
|
|
|
EDMA_ERR_PRD_PAR |
|
|
|
|
EDMA_ERR_DEV_DCON |
|
|
|
|
EDMA_ERR_DEV_CON |
|
|
|
|
EDMA_ERR_OVERRUN_5 |
|
|
|
|
EDMA_ERR_UNDERRUN_5 |
|
|
|
|
EDMA_ERR_SELF_DIS_5 |
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_CRQB_PAR |
|
2007-07-12 18:34:26 +00:00
|
|
|
EDMA_ERR_CRPB_PAR |
|
|
|
|
EDMA_ERR_INTRL_PAR |
|
|
|
|
EDMA_ERR_IORDY,
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_REQ_Q_BASE_HI = 0x10,
|
|
|
|
EDMA_REQ_Q_IN_PTR = 0x14, /* also contains BASE_LO */
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_REQ_Q_OUT_PTR = 0x18,
|
2005-09-30 05:36:00 +00:00
|
|
|
EDMA_REQ_Q_PTR_SHIFT = 5,
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_RSP_Q_BASE_HI = 0x1c,
|
|
|
|
EDMA_RSP_Q_IN_PTR = 0x20,
|
|
|
|
EDMA_RSP_Q_OUT_PTR = 0x24, /* also contains BASE_LO */
|
2005-09-30 05:36:00 +00:00
|
|
|
EDMA_RSP_Q_PTR_SHIFT = 3,
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_CMD = 0x28, /* EDMA command register */
|
2007-07-13 21:06:45 +00:00
|
|
|
EDMA_EN = (1 << 0), /* enable EDMA */
|
|
|
|
EDMA_DS = (1 << 1), /* disable EDMA; self-negated */
|
2008-05-02 06:07:51 +00:00
|
|
|
EDMA_RESET = (1 << 2), /* reset eng/trans/link/phy */
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_STATUS = 0x30, /* EDMA engine status */
|
2008-05-02 06:07:51 +00:00
|
|
|
EDMA_STATUS_CACHE_EMPTY = (1 << 6), /* GenIIe command cache empty */
|
|
|
|
EDMA_STATUS_IDLE = (1 << 7), /* GenIIe EDMA enabled/idle */
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_IORDY_TMOUT = 0x34,
|
|
|
|
EDMA_ARB_CFG = 0x38,
|
2008-05-02 06:07:51 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
EDMA_HALTCOND = 0x60, /* GenIIe halt conditions */
|
|
|
|
EDMA_UNKNOWN_RSVD = 0x6C, /* GenIIe unknown/reserved */
|
2009-01-30 23:51:54 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
BMDMA_CMD = 0x224, /* bmdma command register */
|
|
|
|
BMDMA_STATUS = 0x228, /* bmdma status register */
|
|
|
|
BMDMA_PRD_LOW = 0x22c, /* bmdma PRD addr 31:0 */
|
|
|
|
BMDMA_PRD_HIGH = 0x230, /* bmdma PRD addr 63:32 */
|
2009-01-30 23:51:54 +00:00
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
/* Host private flags (hp_flags) */
|
|
|
|
MV_HP_FLAG_MSI = (1 << 0),
|
2005-11-13 02:13:17 +00:00
|
|
|
MV_HP_ERRATA_50XXB0 = (1 << 1),
|
|
|
|
MV_HP_ERRATA_50XXB2 = (1 << 2),
|
|
|
|
MV_HP_ERRATA_60X1B2 = (1 << 3),
|
|
|
|
MV_HP_ERRATA_60X1C0 = (1 << 4),
|
2007-07-13 21:06:45 +00:00
|
|
|
MV_HP_GEN_I = (1 << 6), /* Generation I: 50xx */
|
|
|
|
MV_HP_GEN_II = (1 << 7), /* Generation II: 60xx */
|
|
|
|
MV_HP_GEN_IIE = (1 << 8), /* Generation IIE: 6042/7042 */
|
2007-12-01 18:07:22 +00:00
|
|
|
MV_HP_PCIE = (1 << 9), /* PCIe bus/regs: 7042 */
|
2008-05-02 06:08:32 +00:00
|
|
|
MV_HP_CUT_THROUGH = (1 << 10), /* can use EDMA cut-through */
|
2008-05-27 21:54:48 +00:00
|
|
|
MV_HP_FLAG_SOC = (1 << 11), /* SystemOnChip, no PCI */
|
2009-03-15 15:33:19 +00:00
|
|
|
MV_HP_QUIRK_LED_BLINK_EN = (1 << 12), /* is led blinking enabled? */
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
/* Port private flags (pp_flags) */
|
2007-07-13 21:06:45 +00:00
|
|
|
MV_PP_FLAG_EDMA_EN = (1 << 0), /* is EDMA engine enabled? */
|
2008-01-26 23:31:33 +00:00
|
|
|
MV_PP_FLAG_NCQ_EN = (1 << 1), /* is EDMA set up for NCQ? */
|
2008-05-02 06:11:45 +00:00
|
|
|
MV_PP_FLAG_FBS_EN = (1 << 2), /* is EDMA set up for FBS? */
|
2008-05-02 06:15:37 +00:00
|
|
|
MV_PP_FLAG_DELAYED_EH = (1 << 3), /* delayed dev err handling */
|
2009-02-25 20:17:43 +00:00
|
|
|
MV_PP_FLAG_FAKE_ATA_BUSY = (1 << 4), /* ignore initial ATA_DRDY */
|
2005-09-01 22:26:17 +00:00
|
|
|
};
|
|
|
|
|
2007-07-12 19:51:22 +00:00
|
|
|
#define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
|
|
|
|
#define IS_GEN_II(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_II)
|
2006-01-31 17:18:41 +00:00
|
|
|
#define IS_GEN_IIE(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_IIE)
|
2008-05-02 06:07:51 +00:00
|
|
|
#define IS_PCIE(hpriv) ((hpriv)->hp_flags & MV_HP_PCIE)
|
2008-05-27 21:54:48 +00:00
|
|
|
#define IS_SOC(hpriv) ((hpriv)->hp_flags & MV_HP_FLAG_SOC)
|
2005-11-12 17:48:15 +00:00
|
|
|
|
2008-03-27 18:51:39 +00:00
|
|
|
#define WINDOW_CTRL(i) (0x20030 + ((i) << 4))
|
|
|
|
#define WINDOW_BASE(i) (0x20034 + ((i) << 4))
|
|
|
|
|
2005-11-12 14:50:49 +00:00
|
|
|
enum {
|
2007-10-09 17:51:57 +00:00
|
|
|
/* DMA boundary 0xffff is required by the s/g splitting
|
|
|
|
* we need on /length/ in mv_fill-sg().
|
|
|
|
*/
|
|
|
|
MV_DMA_BOUNDARY = 0xffffU,
|
2005-11-12 14:50:49 +00:00
|
|
|
|
2007-07-13 21:06:45 +00:00
|
|
|
/* mask of register bits containing lower 32 bits
|
|
|
|
* of EDMA request queue DMA address
|
|
|
|
*/
|
2005-11-12 14:50:49 +00:00
|
|
|
EDMA_REQ_Q_BASE_LO_MASK = 0xfffffc00U,
|
|
|
|
|
2007-07-13 21:06:45 +00:00
|
|
|
/* ditto, for response queue */
|
2005-11-12 14:50:49 +00:00
|
|
|
EDMA_RSP_Q_BASE_LO_MASK = 0xffffff00U,
|
|
|
|
};
|
|
|
|
|
2005-11-13 03:14:02 +00:00
|
|
|
enum chip_type {
|
|
|
|
chip_504x,
|
|
|
|
chip_508x,
|
|
|
|
chip_5080,
|
|
|
|
chip_604x,
|
|
|
|
chip_608x,
|
2006-01-31 17:18:41 +00:00
|
|
|
chip_6042,
|
|
|
|
chip_7042,
|
2008-02-01 23:08:03 +00:00
|
|
|
chip_soc,
|
2005-11-13 03:14:02 +00:00
|
|
|
};
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
/* Command ReQuest Block: 32B */
|
|
|
|
struct mv_crqb {
|
2006-05-22 23:02:03 +00:00
|
|
|
__le32 sg_addr;
|
|
|
|
__le32 sg_addr_hi;
|
|
|
|
__le16 ctrl_flags;
|
|
|
|
__le16 ata_cmd[11];
|
2005-09-30 05:36:00 +00:00
|
|
|
};
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2006-01-31 17:18:41 +00:00
|
|
|
struct mv_crqb_iie {
|
2006-05-22 23:02:03 +00:00
|
|
|
__le32 addr;
|
|
|
|
__le32 addr_hi;
|
|
|
|
__le32 flags;
|
|
|
|
__le32 len;
|
|
|
|
__le32 ata_cmd[4];
|
2006-01-31 17:18:41 +00:00
|
|
|
};
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
/* Command ResPonse Block: 8B */
|
|
|
|
struct mv_crpb {
|
2006-05-22 23:02:03 +00:00
|
|
|
__le16 id;
|
|
|
|
__le16 flags;
|
|
|
|
__le32 tmstmp;
|
2005-09-01 22:26:17 +00:00
|
|
|
};
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
/* EDMA Physical Region Descriptor (ePRD); A.K.A. SG */
|
|
|
|
struct mv_sg {
|
2006-05-22 23:02:03 +00:00
|
|
|
__le32 addr;
|
|
|
|
__le32 flags_size;
|
|
|
|
__le32 addr_hi;
|
|
|
|
__le32 reserved;
|
2005-09-30 05:36:00 +00:00
|
|
|
};
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-02-25 20:13:03 +00:00
|
|
|
/*
|
|
|
|
* We keep a local cache of a few frequently accessed port
|
|
|
|
* registers here, to avoid having to read them (very slow)
|
|
|
|
* when switching between EDMA and non-EDMA modes.
|
|
|
|
*/
|
|
|
|
struct mv_cached_regs {
|
|
|
|
u32 fiscfg;
|
|
|
|
u32 ltmode;
|
|
|
|
u32 haltcond;
|
2009-02-25 20:14:48 +00:00
|
|
|
u32 unknown_rsvd;
|
2009-02-25 20:13:03 +00:00
|
|
|
};
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
struct mv_port_priv {
|
|
|
|
struct mv_crqb *crqb;
|
|
|
|
dma_addr_t crqb_dma;
|
|
|
|
struct mv_crpb *crpb;
|
|
|
|
dma_addr_t crpb_dma;
|
2008-01-29 18:24:00 +00:00
|
|
|
struct mv_sg *sg_tbl[MV_MAX_Q_DEPTH];
|
|
|
|
dma_addr_t sg_tbl_dma[MV_MAX_Q_DEPTH];
|
2007-07-12 18:34:26 +00:00
|
|
|
|
|
|
|
unsigned int req_idx;
|
|
|
|
unsigned int resp_idx;
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
u32 pp_flags;
|
2009-02-25 20:13:03 +00:00
|
|
|
struct mv_cached_regs cached;
|
2008-05-02 06:15:37 +00:00
|
|
|
unsigned int delayed_eh_pmp_map;
|
2005-09-30 05:36:00 +00:00
|
|
|
};
|
|
|
|
|
2005-11-12 17:48:15 +00:00
|
|
|
struct mv_port_signal {
|
|
|
|
u32 amps;
|
|
|
|
u32 pre;
|
|
|
|
};
|
|
|
|
|
2007-12-01 18:07:22 +00:00
|
|
|
struct mv_host_priv {
|
|
|
|
u32 hp_flags;
|
2008-05-17 17:38:00 +00:00
|
|
|
u32 main_irq_mask;
|
2007-12-01 18:07:22 +00:00
|
|
|
struct mv_port_signal signal[8];
|
|
|
|
const struct mv_hw_ops *ops;
|
2008-02-01 23:08:03 +00:00
|
|
|
int n_ports;
|
|
|
|
void __iomem *base;
|
2008-04-25 15:24:24 +00:00
|
|
|
void __iomem *main_irq_cause_addr;
|
|
|
|
void __iomem *main_irq_mask_addr;
|
2009-04-06 20:43:45 +00:00
|
|
|
u32 irq_cause_offset;
|
|
|
|
u32 irq_mask_offset;
|
2007-12-01 18:07:22 +00:00
|
|
|
u32 unmask_all_irqs;
|
2009-12-06 16:26:18 +00:00
|
|
|
|
|
|
|
#if defined(CONFIG_HAVE_CLK)
|
|
|
|
struct clk *clk;
|
|
|
|
#endif
|
2008-01-26 23:32:45 +00:00
|
|
|
/*
|
|
|
|
* These consistent DMA memory pools give us guaranteed
|
|
|
|
* alignment for hardware-accessed data structures,
|
|
|
|
* and less memory waste in accomplishing the alignment.
|
|
|
|
*/
|
|
|
|
struct dma_pool *crqb_pool;
|
|
|
|
struct dma_pool *crpb_pool;
|
|
|
|
struct dma_pool *sg_tbl_pool;
|
2007-12-01 18:07:22 +00:00
|
|
|
};
|
|
|
|
|
2005-11-13 02:13:17 +00:00
|
|
|
struct mv_hw_ops {
|
2005-11-13 04:05:14 +00:00
|
|
|
void (*phy_errata)(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int port);
|
2005-11-13 02:13:17 +00:00
|
|
|
void (*enable_leds)(struct mv_host_priv *hpriv, void __iomem *mmio);
|
|
|
|
void (*read_preamp)(struct mv_host_priv *hpriv, int idx,
|
|
|
|
void __iomem *mmio);
|
2005-11-13 22:47:51 +00:00
|
|
|
int (*reset_hc)(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int n_hc);
|
2005-11-13 03:14:02 +00:00
|
|
|
void (*reset_flash)(struct mv_host_priv *hpriv, void __iomem *mmio);
|
2008-01-30 22:50:45 +00:00
|
|
|
void (*reset_bus)(struct ata_host *host, void __iomem *mmio);
|
2005-11-13 02:13:17 +00:00
|
|
|
};
|
|
|
|
|
2008-07-31 08:02:40 +00:00
|
|
|
static int mv_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val);
|
|
|
|
static int mv_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val);
|
|
|
|
static int mv5_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val);
|
|
|
|
static int mv5_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val);
|
2005-09-30 05:36:00 +00:00
|
|
|
static int mv_port_start(struct ata_port *ap);
|
|
|
|
static void mv_port_stop(struct ata_port *ap);
|
2008-05-02 06:10:02 +00:00
|
|
|
static int mv_qc_defer(struct ata_queued_cmd *qc);
|
2005-09-30 05:36:00 +00:00
|
|
|
static void mv_qc_prep(struct ata_queued_cmd *qc);
|
2006-01-31 17:18:41 +00:00
|
|
|
static void mv_qc_prep_iie(struct ata_queued_cmd *qc);
|
2006-01-23 04:09:36 +00:00
|
|
|
static unsigned int mv_qc_issue(struct ata_queued_cmd *qc);
|
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 03:22:50 +00:00
|
|
|
static int mv_hardreset(struct ata_link *link, unsigned int *class,
|
|
|
|
unsigned long deadline);
|
2007-07-12 18:34:26 +00:00
|
|
|
static void mv_eh_freeze(struct ata_port *ap);
|
|
|
|
static void mv_eh_thaw(struct ata_port *ap);
|
2008-01-26 23:32:29 +00:00
|
|
|
static void mv6_dev_config(struct ata_device *dev);
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-11-13 04:05:14 +00:00
|
|
|
static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int port);
|
2005-11-13 02:13:17 +00:00
|
|
|
static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
|
|
|
|
static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
|
|
|
|
void __iomem *mmio);
|
2005-11-13 22:47:51 +00:00
|
|
|
static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int n_hc);
|
2005-11-13 03:14:02 +00:00
|
|
|
static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
|
2008-01-30 22:50:45 +00:00
|
|
|
static void mv5_reset_bus(struct ata_host *host, void __iomem *mmio);
|
2005-11-13 02:13:17 +00:00
|
|
|
|
2005-11-13 04:05:14 +00:00
|
|
|
static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int port);
|
2005-11-13 02:13:17 +00:00
|
|
|
static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
|
|
|
|
static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
|
|
|
|
void __iomem *mmio);
|
2005-11-13 22:47:51 +00:00
|
|
|
static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int n_hc);
|
2005-11-13 03:14:02 +00:00
|
|
|
static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
|
2008-02-01 23:08:03 +00:00
|
|
|
static void mv_soc_enable_leds(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio);
|
|
|
|
static void mv_soc_read_preamp(struct mv_host_priv *hpriv, int idx,
|
|
|
|
void __iomem *mmio);
|
|
|
|
static int mv_soc_reset_hc(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio, unsigned int n_hc);
|
|
|
|
static void mv_soc_reset_flash(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio);
|
|
|
|
static void mv_soc_reset_bus(struct ata_host *host, void __iomem *mmio);
|
2009-05-04 18:58:50 +00:00
|
|
|
static void mv_soc_65n_phy_errata(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio, unsigned int port);
|
2008-01-30 22:50:45 +00:00
|
|
|
static void mv_reset_pci_bus(struct ata_host *host, void __iomem *mmio);
|
2008-03-31 23:33:56 +00:00
|
|
|
static void mv_reset_channel(struct mv_host_priv *hpriv, void __iomem *mmio,
|
2005-11-13 22:47:51 +00:00
|
|
|
unsigned int port_no);
|
2008-03-31 23:33:56 +00:00
|
|
|
static int mv_stop_edma(struct ata_port *ap);
|
2008-03-31 23:34:40 +00:00
|
|
|
static int mv_stop_edma_engine(void __iomem *port_mmio);
|
2009-01-30 23:47:51 +00:00
|
|
|
static void mv_edma_cfg(struct ata_port *ap, int want_ncq, int want_edma);
|
2005-11-13 02:13:17 +00:00
|
|
|
|
2008-04-16 18:59:07 +00:00
|
|
|
static void mv_pmp_select(struct ata_port *ap, int pmp);
|
|
|
|
static int mv_pmp_hardreset(struct ata_link *link, unsigned int *class,
|
|
|
|
unsigned long deadline);
|
|
|
|
static int mv_softreset(struct ata_link *link, unsigned int *class,
|
|
|
|
unsigned long deadline);
|
2008-05-02 06:15:37 +00:00
|
|
|
static void mv_pmp_error_handler(struct ata_port *ap);
|
2008-05-02 06:16:20 +00:00
|
|
|
static void mv_process_crpb_entries(struct ata_port *ap,
|
|
|
|
struct mv_port_priv *pp);
|
2005-11-13 02:13:17 +00:00
|
|
|
|
2009-01-30 23:51:54 +00:00
|
|
|
static void mv_sff_irq_clear(struct ata_port *ap);
|
|
|
|
static int mv_check_atapi_dma(struct ata_queued_cmd *qc);
|
|
|
|
static void mv_bmdma_setup(struct ata_queued_cmd *qc);
|
|
|
|
static void mv_bmdma_start(struct ata_queued_cmd *qc);
|
|
|
|
static void mv_bmdma_stop(struct ata_queued_cmd *qc);
|
|
|
|
static u8 mv_bmdma_status(struct ata_port *ap);
|
2009-02-25 20:17:43 +00:00
|
|
|
static u8 mv_sff_check_status(struct ata_port *ap);
|
2009-01-30 23:51:54 +00:00
|
|
|
|
2008-01-29 18:24:00 +00:00
|
|
|
/* .sg_tablesize is (MV_MAX_SG_CT / 2) in the structures below
|
|
|
|
* because we have to allow room for worst case splitting of
|
|
|
|
* PRDs for 64K boundaries in mv_fill_sg().
|
|
|
|
*/
|
2007-07-11 22:30:50 +00:00
|
|
|
static struct scsi_host_template mv5_sht = {
|
2008-03-25 03:22:49 +00:00
|
|
|
ATA_BASE_SHT(DRV_NAME),
|
2007-10-09 17:51:57 +00:00
|
|
|
.sg_tablesize = MV_MAX_SG_CT / 2,
|
2007-07-11 22:30:50 +00:00
|
|
|
.dma_boundary = MV_DMA_BOUNDARY,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct scsi_host_template mv6_sht = {
|
2008-03-25 03:22:49 +00:00
|
|
|
ATA_NCQ_SHT(DRV_NAME),
|
2008-01-26 23:33:18 +00:00
|
|
|
.can_queue = MV_MAX_Q_DEPTH - 1,
|
2007-10-09 17:51:57 +00:00
|
|
|
.sg_tablesize = MV_MAX_SG_CT / 2,
|
2005-09-01 22:26:17 +00:00
|
|
|
.dma_boundary = MV_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 03:22:49 +00:00
|
|
|
static struct ata_port_operations mv5_ops = {
|
|
|
|
.inherits = &ata_sff_port_ops,
|
2005-11-13 22:47:51 +00:00
|
|
|
|
2009-03-24 10:23:46 +00:00
|
|
|
.lost_interrupt = ATA_OP_NULL,
|
|
|
|
|
2008-05-02 06:10:02 +00:00
|
|
|
.qc_defer = mv_qc_defer,
|
2005-11-13 22:47:51 +00:00
|
|
|
.qc_prep = mv_qc_prep,
|
|
|
|
.qc_issue = mv_qc_issue,
|
|
|
|
|
2007-07-12 18:34:26 +00:00
|
|
|
.freeze = mv_eh_freeze,
|
|
|
|
.thaw = mv_eh_thaw,
|
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 03:22:50 +00:00
|
|
|
.hardreset = mv_hardreset,
|
|
|
|
.error_handler = ata_std_error_handler, /* avoid SFF EH */
|
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 03:22:49 +00:00
|
|
|
.post_internal_cmd = ATA_OP_NULL,
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
.scr_read = mv5_scr_read,
|
|
|
|
.scr_write = mv5_scr_write,
|
|
|
|
|
|
|
|
.port_start = mv_port_start,
|
|
|
|
.port_stop = mv_port_stop,
|
|
|
|
};
|
|
|
|
|
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 03:22:49 +00:00
|
|
|
static struct ata_port_operations mv6_ops = {
|
|
|
|
.inherits = &mv5_ops,
|
2008-01-26 23:32:29 +00:00
|
|
|
.dev_config = mv6_dev_config,
|
2005-09-01 22:26:17 +00:00
|
|
|
.scr_read = mv_scr_read,
|
|
|
|
.scr_write = mv_scr_write,
|
|
|
|
|
2008-04-16 18:59:07 +00:00
|
|
|
.pmp_hardreset = mv_pmp_hardreset,
|
|
|
|
.pmp_softreset = mv_softreset,
|
|
|
|
.softreset = mv_softreset,
|
2008-05-02 06:15:37 +00:00
|
|
|
.error_handler = mv_pmp_error_handler,
|
2009-01-30 23:51:54 +00:00
|
|
|
|
2009-03-10 22:51:04 +00:00
|
|
|
.sff_check_status = mv_sff_check_status,
|
2009-01-30 23:51:54 +00:00
|
|
|
.sff_irq_clear = mv_sff_irq_clear,
|
|
|
|
.check_atapi_dma = mv_check_atapi_dma,
|
|
|
|
.bmdma_setup = mv_bmdma_setup,
|
|
|
|
.bmdma_start = mv_bmdma_start,
|
|
|
|
.bmdma_stop = mv_bmdma_stop,
|
|
|
|
.bmdma_status = mv_bmdma_status,
|
2005-09-01 22:26:17 +00: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 03:22:49 +00:00
|
|
|
static struct ata_port_operations mv_iie_ops = {
|
|
|
|
.inherits = &mv6_ops,
|
|
|
|
.dev_config = ATA_OP_NULL,
|
2006-01-31 17:18:41 +00:00
|
|
|
.qc_prep = mv_qc_prep_iie,
|
|
|
|
};
|
|
|
|
|
2005-11-28 09:06:23 +00:00
|
|
|
static const struct ata_port_info mv_port_info[] = {
|
2005-09-01 22:26:17 +00:00
|
|
|
{ /* chip_504x */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_I_FLAGS,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2007-07-09 16:16:50 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2005-11-13 22:47:51 +00:00
|
|
|
.port_ops = &mv5_ops,
|
2005-09-01 22:26:17 +00:00
|
|
|
},
|
|
|
|
{ /* chip_508x */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_I_FLAGS | MV_FLAG_DUAL_HC,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2007-07-09 16:16:50 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2005-11-13 22:47:51 +00:00
|
|
|
.port_ops = &mv5_ops,
|
2005-09-01 22:26:17 +00:00
|
|
|
},
|
2005-11-13 02:13:17 +00:00
|
|
|
{ /* chip_5080 */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_I_FLAGS | MV_FLAG_DUAL_HC,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2007-07-09 16:16:50 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2005-11-13 22:47:51 +00:00
|
|
|
.port_ops = &mv5_ops,
|
2005-11-13 02:13:17 +00:00
|
|
|
},
|
2005-09-01 22:26:17 +00:00
|
|
|
{ /* chip_604x */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_II_FLAGS,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2007-07-09 16:16:50 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2005-11-13 22:47:51 +00:00
|
|
|
.port_ops = &mv6_ops,
|
2005-09-01 22:26:17 +00:00
|
|
|
},
|
|
|
|
{ /* chip_608x */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_II_FLAGS | MV_FLAG_DUAL_HC,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2007-07-09 16:16:50 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2005-11-13 22:47:51 +00:00
|
|
|
.port_ops = &mv6_ops,
|
2005-09-01 22:26:17 +00:00
|
|
|
},
|
2006-01-31 17:18:41 +00:00
|
|
|
{ /* chip_6042 */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_IIE_FLAGS,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2007-07-09 16:16:50 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2006-01-31 17:18:41 +00:00
|
|
|
.port_ops = &mv_iie_ops,
|
|
|
|
},
|
|
|
|
{ /* chip_7042 */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_IIE_FLAGS,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2007-07-09 16:16:50 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
2006-01-31 17:18:41 +00:00
|
|
|
.port_ops = &mv_iie_ops,
|
|
|
|
},
|
2008-02-01 23:08:03 +00:00
|
|
|
{ /* chip_soc */
|
2009-01-30 23:46:39 +00:00
|
|
|
.flags = MV_GEN_IIE_FLAGS,
|
2009-04-06 19:22:21 +00:00
|
|
|
.pio_mask = ATA_PIO4,
|
2008-04-16 18:56:51 +00:00
|
|
|
.udma_mask = ATA_UDMA6,
|
|
|
|
.port_ops = &mv_iie_ops,
|
2008-02-01 23:08:03 +00:00
|
|
|
},
|
2005-09-01 22:26:17 +00:00
|
|
|
};
|
|
|
|
|
2005-11-10 16:04:11 +00:00
|
|
|
static const struct pci_device_id mv_pci_tbl[] = {
|
2006-09-29 00:21:59 +00:00
|
|
|
{ PCI_VDEVICE(MARVELL, 0x5040), chip_504x },
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x5041), chip_504x },
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x5080), chip_5080 },
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x5081), chip_508x },
|
2008-09-04 22:21:07 +00:00
|
|
|
/* RocketRAID 1720/174x have different identifiers */
|
|
|
|
{ PCI_VDEVICE(TTI, 0x1720), chip_6042 },
|
2009-01-27 21:33:13 +00:00
|
|
|
{ PCI_VDEVICE(TTI, 0x1740), chip_6042 },
|
|
|
|
{ PCI_VDEVICE(TTI, 0x1742), chip_6042 },
|
2006-09-29 00:21:59 +00:00
|
|
|
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x6040), chip_604x },
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x6041), chip_604x },
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x6042), chip_6042 },
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x6080), chip_608x },
|
|
|
|
{ PCI_VDEVICE(MARVELL, 0x6081), chip_608x },
|
|
|
|
|
|
|
|
{ PCI_VDEVICE(ADAPTEC2, 0x0241), chip_604x },
|
|
|
|
|
2007-07-02 15:09:29 +00:00
|
|
|
/* Adaptec 1430SA */
|
|
|
|
{ PCI_VDEVICE(ADAPTEC2, 0x0243), chip_7042 },
|
|
|
|
|
2007-12-01 18:07:22 +00:00
|
|
|
/* Marvell 7042 support */
|
2007-03-06 10:38:10 +00:00
|
|
|
{ PCI_VDEVICE(MARVELL, 0x7042), chip_7042 },
|
|
|
|
|
2007-12-01 18:07:22 +00:00
|
|
|
/* Highpoint RocketRAID PCIe series */
|
|
|
|
{ PCI_VDEVICE(TTI, 0x2300), chip_7042 },
|
|
|
|
{ PCI_VDEVICE(TTI, 0x2310), chip_7042 },
|
|
|
|
|
2006-09-29 00:21:59 +00:00
|
|
|
{ } /* terminate list */
|
2005-09-01 22:26:17 +00:00
|
|
|
};
|
|
|
|
|
2005-11-13 02:13:17 +00:00
|
|
|
static const struct mv_hw_ops mv5xxx_ops = {
|
|
|
|
.phy_errata = mv5_phy_errata,
|
|
|
|
.enable_leds = mv5_enable_leds,
|
|
|
|
.read_preamp = mv5_read_preamp,
|
|
|
|
.reset_hc = mv5_reset_hc,
|
2005-11-13 03:14:02 +00:00
|
|
|
.reset_flash = mv5_reset_flash,
|
|
|
|
.reset_bus = mv5_reset_bus,
|
2005-11-13 02:13:17 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct mv_hw_ops mv6xxx_ops = {
|
|
|
|
.phy_errata = mv6_phy_errata,
|
|
|
|
.enable_leds = mv6_enable_leds,
|
|
|
|
.read_preamp = mv6_read_preamp,
|
|
|
|
.reset_hc = mv6_reset_hc,
|
2005-11-13 03:14:02 +00:00
|
|
|
.reset_flash = mv6_reset_flash,
|
|
|
|
.reset_bus = mv_reset_pci_bus,
|
2005-11-13 02:13:17 +00:00
|
|
|
};
|
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
static const struct mv_hw_ops mv_soc_ops = {
|
|
|
|
.phy_errata = mv6_phy_errata,
|
|
|
|
.enable_leds = mv_soc_enable_leds,
|
|
|
|
.read_preamp = mv_soc_read_preamp,
|
|
|
|
.reset_hc = mv_soc_reset_hc,
|
|
|
|
.reset_flash = mv_soc_reset_flash,
|
|
|
|
.reset_bus = mv_soc_reset_bus,
|
|
|
|
};
|
|
|
|
|
2009-05-04 18:58:50 +00:00
|
|
|
static const struct mv_hw_ops mv_soc_65n_ops = {
|
|
|
|
.phy_errata = mv_soc_65n_phy_errata,
|
|
|
|
.enable_leds = mv_soc_enable_leds,
|
|
|
|
.reset_hc = mv_soc_reset_hc,
|
|
|
|
.reset_flash = mv_soc_reset_flash,
|
|
|
|
.reset_bus = mv_soc_reset_bus,
|
|
|
|
};
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
/*
|
|
|
|
* Functions
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline void writelfl(unsigned long data, void __iomem *addr)
|
|
|
|
{
|
|
|
|
writel(data, addr);
|
|
|
|
(void) readl(addr); /* flush to avoid PCI posted write */
|
|
|
|
}
|
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
static inline unsigned int mv_hc_from_port(unsigned int port)
|
|
|
|
{
|
|
|
|
return port >> MV_PORT_HC_SHIFT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int mv_hardport_from_port(unsigned int port)
|
|
|
|
{
|
|
|
|
return port & MV_PORT_MASK;
|
|
|
|
}
|
|
|
|
|
2008-04-19 19:05:50 +00:00
|
|
|
/*
|
|
|
|
* Consolidate some rather tricky bit shift calculations.
|
|
|
|
* This is hot-path stuff, so not a function.
|
|
|
|
* Simple code, with two return values, so macro rather than inline.
|
|
|
|
*
|
|
|
|
* port is the sole input, in range 0..7.
|
2008-04-25 15:24:24 +00:00
|
|
|
* shift is one output, for use with main_irq_cause / main_irq_mask registers.
|
|
|
|
* hardport is the other output, in range 0..3.
|
2008-04-19 19:05:50 +00:00
|
|
|
*
|
|
|
|
* Note that port and hardport may be the same variable in some cases.
|
|
|
|
*/
|
|
|
|
#define MV_PORT_TO_SHIFT_AND_HARDPORT(port, shift, hardport) \
|
|
|
|
{ \
|
|
|
|
shift = mv_hc_from_port(port) * HC_SHIFT; \
|
|
|
|
hardport = mv_hardport_from_port(port); \
|
|
|
|
shift += hardport * 2; \
|
|
|
|
}
|
|
|
|
|
2008-04-19 18:43:42 +00:00
|
|
|
static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
|
|
|
|
{
|
2009-04-06 20:43:45 +00:00
|
|
|
return (base + SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
|
2008-04-19 18:43:42 +00:00
|
|
|
}
|
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
static inline void __iomem *mv_hc_base_from_port(void __iomem *base,
|
|
|
|
unsigned int port)
|
|
|
|
{
|
|
|
|
return mv_hc_base(base, mv_hc_from_port(port));
|
|
|
|
}
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
static inline void __iomem *mv_port_base(void __iomem *base, unsigned int port)
|
|
|
|
{
|
2005-11-13 22:47:51 +00:00
|
|
|
return mv_hc_base_from_port(base, port) +
|
2005-11-12 17:32:50 +00:00
|
|
|
MV_SATAHC_ARBTR_REG_SZ +
|
2005-11-13 22:47:51 +00:00
|
|
|
(mv_hardport_from_port(port) * MV_PORT_REG_SZ);
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-03-31 23:33:56 +00:00
|
|
|
static void __iomem *mv5_phy_base(void __iomem *mmio, unsigned int port)
|
|
|
|
{
|
|
|
|
void __iomem *hc_mmio = mv_hc_base_from_port(mmio, port);
|
|
|
|
unsigned long ofs = (mv_hardport_from_port(port) + 1) * 0x100UL;
|
|
|
|
|
|
|
|
return hc_mmio + ofs;
|
|
|
|
}
|
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
static inline void __iomem *mv_host_base(struct ata_host *host)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
return hpriv->base;
|
|
|
|
}
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
static inline void __iomem *mv_ap_base(struct ata_port *ap)
|
|
|
|
{
|
2008-02-01 23:08:03 +00:00
|
|
|
return mv_port_base(mv_host_base(ap->host), ap->port_no);
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2006-08-24 07:19:22 +00:00
|
|
|
static inline int mv_get_hc_count(unsigned long port_flags)
|
2005-09-30 05:36:00 +00:00
|
|
|
{
|
2006-08-24 07:19:22 +00:00
|
|
|
return ((port_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
|
|
|
|
2009-02-25 20:13:03 +00:00
|
|
|
/**
|
|
|
|
* mv_save_cached_regs - (re-)initialize cached port registers
|
|
|
|
* @ap: the port whose registers we are caching
|
|
|
|
*
|
|
|
|
* Initialize the local cache of port registers,
|
|
|
|
* so that reading them over and over again can
|
|
|
|
* be avoided on the hotter paths of this driver.
|
|
|
|
* This saves a few microseconds each time we switch
|
|
|
|
* to/from EDMA mode to perform (eg.) a drive cache flush.
|
|
|
|
*/
|
|
|
|
static void mv_save_cached_regs(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
pp->cached.fiscfg = readl(port_mmio + FISCFG);
|
|
|
|
pp->cached.ltmode = readl(port_mmio + LTMODE);
|
|
|
|
pp->cached.haltcond = readl(port_mmio + EDMA_HALTCOND);
|
|
|
|
pp->cached.unknown_rsvd = readl(port_mmio + EDMA_UNKNOWN_RSVD);
|
2009-02-25 20:13:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_write_cached_reg - write to a cached port register
|
|
|
|
* @addr: hardware address of the register
|
|
|
|
* @old: pointer to cached value of the register
|
|
|
|
* @new: new value for the register
|
|
|
|
*
|
|
|
|
* Write a new value to a cached register,
|
|
|
|
* but only if the value is different from before.
|
|
|
|
*/
|
|
|
|
static inline void mv_write_cached_reg(void __iomem *addr, u32 *old, u32 new)
|
|
|
|
{
|
|
|
|
if (new != *old) {
|
2009-04-06 19:26:24 +00:00
|
|
|
unsigned long laddr;
|
2009-02-25 20:13:03 +00:00
|
|
|
*old = new;
|
2009-04-06 19:26:24 +00:00
|
|
|
/*
|
|
|
|
* Workaround for 88SX60x1-B2 FEr SATA#13:
|
|
|
|
* Read-after-write is needed to prevent generating 64-bit
|
|
|
|
* write cycles on the PCI bus for SATA interface registers
|
|
|
|
* at offsets ending in 0x4 or 0xc.
|
|
|
|
*
|
|
|
|
* Looks like a lot of fuss, but it avoids an unnecessary
|
|
|
|
* +1 usec read-after-write delay for unaffected registers.
|
|
|
|
*/
|
|
|
|
laddr = (long)addr & 0xffff;
|
|
|
|
if (laddr >= 0x300 && laddr <= 0x33c) {
|
|
|
|
laddr &= 0x000f;
|
|
|
|
if (laddr == 0x4 || laddr == 0xc) {
|
|
|
|
writelfl(new, addr); /* read after write */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
writel(new, addr); /* unaffected by the errata */
|
2009-02-25 20:13:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-11 22:30:50 +00:00
|
|
|
static void mv_set_edma_ptrs(void __iomem *port_mmio,
|
|
|
|
struct mv_host_priv *hpriv,
|
|
|
|
struct mv_port_priv *pp)
|
|
|
|
{
|
2007-07-12 18:34:26 +00:00
|
|
|
u32 index;
|
|
|
|
|
2007-07-11 22:30:50 +00:00
|
|
|
/*
|
|
|
|
* initialize request queue
|
|
|
|
*/
|
2008-04-19 19:06:40 +00:00
|
|
|
pp->req_idx &= MV_MAX_Q_DEPTH_MASK; /* paranoia */
|
|
|
|
index = pp->req_idx << EDMA_REQ_Q_PTR_SHIFT;
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2007-07-11 22:30:50 +00:00
|
|
|
WARN_ON(pp->crqb_dma & 0x3ff);
|
2009-04-06 20:43:45 +00:00
|
|
|
writel((pp->crqb_dma >> 16) >> 16, port_mmio + EDMA_REQ_Q_BASE_HI);
|
2007-07-12 18:34:26 +00:00
|
|
|
writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | index,
|
2009-04-06 20:43:45 +00:00
|
|
|
port_mmio + EDMA_REQ_Q_IN_PTR);
|
|
|
|
writelfl(index, port_mmio + EDMA_REQ_Q_OUT_PTR);
|
2007-07-11 22:30:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* initialize response queue
|
|
|
|
*/
|
2008-04-19 19:06:40 +00:00
|
|
|
pp->resp_idx &= MV_MAX_Q_DEPTH_MASK; /* paranoia */
|
|
|
|
index = pp->resp_idx << EDMA_RSP_Q_PTR_SHIFT;
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2007-07-11 22:30:50 +00:00
|
|
|
WARN_ON(pp->crpb_dma & 0xff);
|
2009-04-06 20:43:45 +00:00
|
|
|
writel((pp->crpb_dma >> 16) >> 16, port_mmio + EDMA_RSP_Q_BASE_HI);
|
|
|
|
writelfl(index, port_mmio + EDMA_RSP_Q_IN_PTR);
|
2007-07-12 18:34:26 +00:00
|
|
|
writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) | index,
|
2009-04-06 20:43:45 +00:00
|
|
|
port_mmio + EDMA_RSP_Q_OUT_PTR);
|
2007-07-11 22:30:50 +00:00
|
|
|
}
|
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
static void mv_write_main_irq_mask(u32 mask, struct mv_host_priv *hpriv)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* When writing to the main_irq_mask in hardware,
|
|
|
|
* we must ensure exclusivity between the interrupt coalescing bits
|
|
|
|
* and the corresponding individual port DONE_IRQ bits.
|
|
|
|
*
|
|
|
|
* Note that this register is really an "IRQ enable" register,
|
|
|
|
* not an "IRQ mask" register as Marvell's naming might suggest.
|
|
|
|
*/
|
|
|
|
if (mask & (ALL_PORTS_COAL_DONE | PORTS_0_3_COAL_DONE))
|
|
|
|
mask &= ~DONE_IRQ_0_3;
|
|
|
|
if (mask & (ALL_PORTS_COAL_DONE | PORTS_4_7_COAL_DONE))
|
|
|
|
mask &= ~DONE_IRQ_4_7;
|
|
|
|
writelfl(mask, hpriv->main_irq_mask_addr);
|
|
|
|
}
|
|
|
|
|
2008-05-17 17:35:21 +00:00
|
|
|
static void mv_set_main_irq_mask(struct ata_host *host,
|
|
|
|
u32 disable_bits, u32 enable_bits)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
u32 old_mask, new_mask;
|
|
|
|
|
2008-05-17 17:38:00 +00:00
|
|
|
old_mask = hpriv->main_irq_mask;
|
2008-05-17 17:35:21 +00:00
|
|
|
new_mask = (old_mask & ~disable_bits) | enable_bits;
|
2008-05-17 17:38:00 +00:00
|
|
|
if (new_mask != old_mask) {
|
|
|
|
hpriv->main_irq_mask = new_mask;
|
2009-03-11 02:01:17 +00:00
|
|
|
mv_write_main_irq_mask(new_mask, hpriv);
|
2008-05-17 17:38:00 +00:00
|
|
|
}
|
2008-05-17 17:35:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_enable_port_irqs(struct ata_port *ap,
|
|
|
|
unsigned int port_bits)
|
|
|
|
{
|
|
|
|
unsigned int shift, hardport, port = ap->port_no;
|
|
|
|
u32 disable_bits, enable_bits;
|
|
|
|
|
|
|
|
MV_PORT_TO_SHIFT_AND_HARDPORT(port, shift, hardport);
|
|
|
|
|
|
|
|
disable_bits = (DONE_IRQ | ERR_IRQ) << shift;
|
|
|
|
enable_bits = port_bits << shift;
|
|
|
|
mv_set_main_irq_mask(ap->host, disable_bits, enable_bits);
|
|
|
|
}
|
|
|
|
|
2009-01-30 23:47:51 +00:00
|
|
|
static void mv_clear_and_enable_port_irqs(struct ata_port *ap,
|
|
|
|
void __iomem *port_mmio,
|
|
|
|
unsigned int port_irqs)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
|
|
|
int hardport = mv_hardport_from_port(ap->port_no);
|
|
|
|
void __iomem *hc_mmio = mv_hc_base_from_port(
|
|
|
|
mv_host_base(ap->host), ap->port_no);
|
|
|
|
u32 hc_irq_cause;
|
|
|
|
|
|
|
|
/* clear EDMA event indicators, if any */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE);
|
2009-01-30 23:47:51 +00:00
|
|
|
|
|
|
|
/* clear pending irq events */
|
|
|
|
hc_irq_cause = ~((DEV_IRQ | DMA_IRQ) << hardport);
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE);
|
2009-01-30 23:47:51 +00:00
|
|
|
|
|
|
|
/* clear FIS IRQ Cause */
|
|
|
|
if (IS_GEN_IIE(hpriv))
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(0, port_mmio + FIS_IRQ_CAUSE);
|
2009-01-30 23:47:51 +00:00
|
|
|
|
|
|
|
mv_enable_port_irqs(ap, port_irqs);
|
|
|
|
}
|
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
static void mv_set_irq_coalescing(struct ata_host *host,
|
|
|
|
unsigned int count, unsigned int usecs)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
void __iomem *mmio = hpriv->base, *hc_mmio;
|
|
|
|
u32 coal_enable = 0;
|
|
|
|
unsigned long flags;
|
2009-03-11 04:56:00 +00:00
|
|
|
unsigned int clks, is_dual_hc = hpriv->n_ports > MV_PORTS_PER_HC;
|
2009-03-11 02:01:17 +00:00
|
|
|
const u32 coal_disable = PORTS_0_3_COAL_DONE | PORTS_4_7_COAL_DONE |
|
|
|
|
ALL_PORTS_COAL_DONE;
|
|
|
|
|
|
|
|
/* Disable IRQ coalescing if either threshold is zero */
|
|
|
|
if (!usecs || !count) {
|
|
|
|
clks = count = 0;
|
|
|
|
} else {
|
|
|
|
/* Respect maximum limits of the hardware */
|
|
|
|
clks = usecs * COAL_CLOCKS_PER_USEC;
|
|
|
|
if (clks > MAX_COAL_TIME_THRESHOLD)
|
|
|
|
clks = MAX_COAL_TIME_THRESHOLD;
|
|
|
|
if (count > MAX_COAL_IO_COUNT)
|
|
|
|
count = MAX_COAL_IO_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2009-03-11 04:56:00 +00:00
|
|
|
mv_set_main_irq_mask(host, coal_disable, 0);
|
2009-03-11 02:01:17 +00:00
|
|
|
|
2009-03-11 04:56:00 +00:00
|
|
|
if (is_dual_hc && !IS_GEN_I(hpriv)) {
|
2009-03-11 02:01:17 +00:00
|
|
|
/*
|
2009-03-11 04:56:00 +00:00
|
|
|
* GEN_II/GEN_IIE with dual host controllers:
|
|
|
|
* one set of global thresholds for the entire chip.
|
2009-03-11 02:01:17 +00:00
|
|
|
*/
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(clks, mmio + IRQ_COAL_TIME_THRESHOLD);
|
|
|
|
writel(count, mmio + IRQ_COAL_IO_THRESHOLD);
|
2009-03-11 02:01:17 +00:00
|
|
|
/* clear leftover coal IRQ bit */
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(~ALL_PORTS_COAL_IRQ, mmio + IRQ_COAL_CAUSE);
|
2009-03-11 04:56:00 +00:00
|
|
|
if (count)
|
|
|
|
coal_enable = ALL_PORTS_COAL_DONE;
|
|
|
|
clks = count = 0; /* force clearing of regular regs below */
|
2009-03-11 02:01:17 +00:00
|
|
|
}
|
2009-03-11 04:56:00 +00:00
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
/*
|
|
|
|
* All chips: independent thresholds for each HC on the chip.
|
|
|
|
*/
|
|
|
|
hc_mmio = mv_hc_base_from_port(mmio, 0);
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(clks, hc_mmio + HC_IRQ_COAL_TIME_THRESHOLD);
|
|
|
|
writel(count, hc_mmio + HC_IRQ_COAL_IO_THRESHOLD);
|
|
|
|
writel(~HC_COAL_IRQ, hc_mmio + HC_IRQ_CAUSE);
|
2009-03-11 04:56:00 +00:00
|
|
|
if (count)
|
|
|
|
coal_enable |= PORTS_0_3_COAL_DONE;
|
|
|
|
if (is_dual_hc) {
|
2009-03-11 02:01:17 +00:00
|
|
|
hc_mmio = mv_hc_base_from_port(mmio, MV_PORTS_PER_HC);
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(clks, hc_mmio + HC_IRQ_COAL_TIME_THRESHOLD);
|
|
|
|
writel(count, hc_mmio + HC_IRQ_COAL_IO_THRESHOLD);
|
|
|
|
writel(~HC_COAL_IRQ, hc_mmio + HC_IRQ_CAUSE);
|
2009-03-11 04:56:00 +00:00
|
|
|
if (count)
|
|
|
|
coal_enable |= PORTS_4_7_COAL_DONE;
|
2009-03-11 02:01:17 +00:00
|
|
|
}
|
|
|
|
|
2009-03-11 04:56:00 +00:00
|
|
|
mv_set_main_irq_mask(host, 0, coal_enable);
|
2009-03-11 02:01:17 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
2009-01-30 23:47:51 +00:00
|
|
|
* mv_start_edma - Enable eDMA engine
|
2005-10-05 21:08:53 +00:00
|
|
|
* @base: port base address
|
|
|
|
* @pp: port private data
|
|
|
|
*
|
2006-02-11 10:11:13 +00:00
|
|
|
* Verify the local cache of the eDMA state is accurate with a
|
|
|
|
* WARN_ON.
|
2005-10-05 21:08:53 +00:00
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2009-01-30 23:47:51 +00:00
|
|
|
static void mv_start_edma(struct ata_port *ap, void __iomem *port_mmio,
|
2008-01-26 23:31:33 +00:00
|
|
|
struct mv_port_priv *pp, u8 protocol)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2008-01-26 23:31:33 +00:00
|
|
|
int want_ncq = (protocol == ATA_PROT_NCQ);
|
|
|
|
|
|
|
|
if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
|
|
|
|
int using_ncq = ((pp->pp_flags & MV_PP_FLAG_NCQ_EN) != 0);
|
|
|
|
if (want_ncq != using_ncq)
|
2008-03-31 23:34:40 +00:00
|
|
|
mv_stop_edma(ap);
|
2008-01-26 23:31:33 +00:00
|
|
|
}
|
2007-07-11 22:30:50 +00:00
|
|
|
if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN)) {
|
2008-01-26 23:31:16 +00:00
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
|
|
|
|
2009-01-30 23:47:51 +00:00
|
|
|
mv_edma_cfg(ap, want_ncq, 1);
|
2008-01-26 23:31:16 +00:00
|
|
|
|
2008-01-26 23:31:00 +00:00
|
|
|
mv_set_edma_ptrs(port_mmio, hpriv, pp);
|
2009-01-30 23:47:51 +00:00
|
|
|
mv_clear_and_enable_port_irqs(ap, port_mmio, DONE_IRQ|ERR_IRQ);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(EDMA_EN, port_mmio + EDMA_CMD);
|
2005-10-05 21:08:42 +00:00
|
|
|
pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
|
|
|
|
}
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-05-02 06:09:14 +00:00
|
|
|
static void mv_wait_for_edma_empty_idle(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
const u32 empty_idle = (EDMA_STATUS_CACHE_EMPTY | EDMA_STATUS_IDLE);
|
|
|
|
const int per_loop = 5, timeout = (15 * 1000 / per_loop);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for the EDMA engine to finish transactions in progress.
|
2008-05-02 18:02:28 +00:00
|
|
|
* No idea what a good "timeout" value might be, but measurements
|
|
|
|
* indicate that it often requires hundreds of microseconds
|
|
|
|
* with two drives in-use. So we use the 15msec value above
|
|
|
|
* as a rough guess at what even more drives might require.
|
2008-05-02 06:09:14 +00:00
|
|
|
*/
|
|
|
|
for (i = 0; i < timeout; ++i) {
|
2009-04-06 20:43:45 +00:00
|
|
|
u32 edma_stat = readl(port_mmio + EDMA_STATUS);
|
2008-05-02 06:09:14 +00:00
|
|
|
if ((edma_stat & empty_idle) == empty_idle)
|
|
|
|
break;
|
|
|
|
udelay(per_loop);
|
|
|
|
}
|
|
|
|
/* ata_port_printk(ap, KERN_INFO, "%s: %u+ usecs\n", __func__, i); */
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
2008-03-31 23:33:56 +00:00
|
|
|
* mv_stop_edma_engine - Disable eDMA engine
|
2008-03-31 23:34:40 +00:00
|
|
|
* @port_mmio: io base address
|
2005-10-05 21:08:53 +00:00
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2008-03-31 23:34:40 +00:00
|
|
|
static int mv_stop_edma_engine(void __iomem *port_mmio)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2008-03-31 23:34:40 +00:00
|
|
|
int i;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2008-03-31 23:34:40 +00:00
|
|
|
/* Disable eDMA. The disable bit auto clears. */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(EDMA_DS, port_mmio + EDMA_CMD);
|
2005-11-12 17:32:50 +00:00
|
|
|
|
2008-03-31 23:34:40 +00:00
|
|
|
/* Wait for the chip to confirm eDMA is off. */
|
|
|
|
for (i = 10000; i > 0; i--) {
|
2009-04-06 20:43:45 +00:00
|
|
|
u32 reg = readl(port_mmio + EDMA_CMD);
|
2007-07-12 18:30:19 +00:00
|
|
|
if (!(reg & EDMA_EN))
|
2008-03-31 23:34:40 +00:00
|
|
|
return 0;
|
|
|
|
udelay(10);
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
2008-03-31 23:34:40 +00:00
|
|
|
return -EIO;
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-03-31 23:33:56 +00:00
|
|
|
static int mv_stop_edma(struct ata_port *ap)
|
2007-07-13 21:06:45 +00:00
|
|
|
{
|
2008-03-31 23:34:40 +00:00
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
2009-01-30 23:52:58 +00:00
|
|
|
int err = 0;
|
2007-07-13 21:06:45 +00:00
|
|
|
|
2008-03-31 23:34:40 +00:00
|
|
|
if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN))
|
|
|
|
return 0;
|
|
|
|
pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
|
2008-05-02 06:09:14 +00:00
|
|
|
mv_wait_for_edma_empty_idle(ap);
|
2008-03-31 23:34:40 +00:00
|
|
|
if (mv_stop_edma_engine(port_mmio)) {
|
|
|
|
ata_port_printk(ap, KERN_ERR, "Unable to stop eDMA\n");
|
2009-01-30 23:52:58 +00:00
|
|
|
err = -EIO;
|
2008-03-31 23:34:40 +00:00
|
|
|
}
|
2009-01-30 23:52:58 +00:00
|
|
|
mv_edma_cfg(ap, 0, 0);
|
|
|
|
return err;
|
2007-07-13 21:06:45 +00:00
|
|
|
}
|
|
|
|
|
2005-10-05 21:19:47 +00:00
|
|
|
#ifdef ATA_DEBUG
|
2005-09-30 05:36:00 +00:00
|
|
|
static void mv_dump_mem(void __iomem *start, unsigned bytes)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2005-09-30 05:36:00 +00:00
|
|
|
int b, w;
|
|
|
|
for (b = 0; b < bytes; ) {
|
|
|
|
DPRINTK("%p: ", start + b);
|
|
|
|
for (w = 0; b < bytes && w < 4; w++) {
|
2007-10-19 10:42:56 +00:00
|
|
|
printk("%08x ", readl(start + b));
|
2005-09-30 05:36:00 +00:00
|
|
|
b += sizeof(u32);
|
|
|
|
}
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
}
|
2005-10-05 21:19:47 +00:00
|
|
|
#endif
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
static void mv_dump_pci_cfg(struct pci_dev *pdev, unsigned bytes)
|
|
|
|
{
|
|
|
|
#ifdef ATA_DEBUG
|
|
|
|
int b, w;
|
|
|
|
u32 dw;
|
|
|
|
for (b = 0; b < bytes; ) {
|
|
|
|
DPRINTK("%02x: ", b);
|
|
|
|
for (w = 0; b < bytes && w < 4; w++) {
|
2007-10-19 10:42:56 +00:00
|
|
|
(void) pci_read_config_dword(pdev, b, &dw);
|
|
|
|
printk("%08x ", dw);
|
2005-09-30 05:36:00 +00:00
|
|
|
b += sizeof(u32);
|
|
|
|
}
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
static void mv_dump_all_regs(void __iomem *mmio_base, int port,
|
|
|
|
struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
#ifdef ATA_DEBUG
|
2005-11-12 17:32:50 +00:00
|
|
|
void __iomem *hc_base = mv_hc_base(mmio_base,
|
2005-09-30 05:36:00 +00:00
|
|
|
port >> MV_PORT_HC_SHIFT);
|
|
|
|
void __iomem *port_base;
|
|
|
|
int start_port, num_ports, p, start_hc, num_hcs, hc;
|
|
|
|
|
|
|
|
if (0 > port) {
|
|
|
|
start_hc = start_port = 0;
|
|
|
|
num_ports = 8; /* shld be benign for 4 port devs */
|
|
|
|
num_hcs = 2;
|
|
|
|
} else {
|
|
|
|
start_hc = port >> MV_PORT_HC_SHIFT;
|
|
|
|
start_port = port;
|
|
|
|
num_ports = num_hcs = 1;
|
|
|
|
}
|
2005-11-12 17:32:50 +00:00
|
|
|
DPRINTK("All registers for port(s) %u-%u:\n", start_port,
|
2005-09-30 05:36:00 +00:00
|
|
|
num_ports > 1 ? num_ports - 1 : start_port);
|
|
|
|
|
|
|
|
if (NULL != pdev) {
|
|
|
|
DPRINTK("PCI config space regs:\n");
|
|
|
|
mv_dump_pci_cfg(pdev, 0x68);
|
|
|
|
}
|
|
|
|
DPRINTK("PCI regs:\n");
|
|
|
|
mv_dump_mem(mmio_base+0xc00, 0x3c);
|
|
|
|
mv_dump_mem(mmio_base+0xd00, 0x34);
|
|
|
|
mv_dump_mem(mmio_base+0xf00, 0x4);
|
|
|
|
mv_dump_mem(mmio_base+0x1d00, 0x6c);
|
|
|
|
for (hc = start_hc; hc < start_hc + num_hcs; hc++) {
|
2006-04-11 06:20:22 +00:00
|
|
|
hc_base = mv_hc_base(mmio_base, hc);
|
2005-09-30 05:36:00 +00:00
|
|
|
DPRINTK("HC regs (HC %i):\n", hc);
|
|
|
|
mv_dump_mem(hc_base, 0x1c);
|
|
|
|
}
|
|
|
|
for (p = start_port; p < start_port + num_ports; p++) {
|
|
|
|
port_base = mv_port_base(mmio_base, p);
|
2007-10-19 10:42:56 +00:00
|
|
|
DPRINTK("EDMA regs (port %i):\n", p);
|
2005-09-30 05:36:00 +00:00
|
|
|
mv_dump_mem(port_base, 0x54);
|
2007-10-19 10:42:56 +00:00
|
|
|
DPRINTK("SATA regs (port %i):\n", p);
|
2005-09-30 05:36:00 +00:00
|
|
|
mv_dump_mem(port_base+0x300, 0x60);
|
|
|
|
}
|
|
|
|
#endif
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int mv_scr_offset(unsigned int sc_reg_in)
|
|
|
|
{
|
|
|
|
unsigned int ofs;
|
|
|
|
|
|
|
|
switch (sc_reg_in) {
|
|
|
|
case SCR_STATUS:
|
|
|
|
case SCR_CONTROL:
|
|
|
|
case SCR_ERROR:
|
2009-04-06 20:43:45 +00:00
|
|
|
ofs = SATA_STATUS + (sc_reg_in * sizeof(u32));
|
2005-09-01 22:26:17 +00:00
|
|
|
break;
|
|
|
|
case SCR_ACTIVE:
|
2009-04-06 20:43:45 +00:00
|
|
|
ofs = SATA_ACTIVE; /* active is not with the others */
|
2005-09-01 22:26:17 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ofs = 0xffffffffU;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ofs;
|
|
|
|
}
|
|
|
|
|
2008-07-31 08:02:40 +00:00
|
|
|
static int mv_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
|
|
|
unsigned int ofs = mv_scr_offset(sc_reg_in);
|
|
|
|
|
2007-07-16 05:29:40 +00:00
|
|
|
if (ofs != 0xffffffffU) {
|
2008-07-31 08:02:40 +00:00
|
|
|
*val = readl(mv_ap_base(link->ap) + ofs);
|
2007-07-16 05:29:40 +00:00
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -EINVAL;
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-07-31 08:02:40 +00:00
|
|
|
static int mv_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
|
|
|
unsigned int ofs = mv_scr_offset(sc_reg_in);
|
|
|
|
|
2007-07-16 05:29:40 +00:00
|
|
|
if (ofs != 0xffffffffU) {
|
2009-04-06 19:24:57 +00:00
|
|
|
void __iomem *addr = mv_ap_base(link->ap) + ofs;
|
|
|
|
if (sc_reg_in == SCR_CONTROL) {
|
|
|
|
/*
|
|
|
|
* Workaround for 88SX60x1 FEr SATA#26:
|
|
|
|
*
|
|
|
|
* COMRESETs have to take care not to accidently
|
|
|
|
* put the drive to sleep when writing SCR_CONTROL.
|
|
|
|
* Setting bits 12..15 prevents this problem.
|
|
|
|
*
|
|
|
|
* So if we see an outbound COMMRESET, set those bits.
|
|
|
|
* Ditto for the followup write that clears the reset.
|
|
|
|
*
|
|
|
|
* The proprietary driver does this for
|
|
|
|
* all chip versions, and so do we.
|
|
|
|
*/
|
|
|
|
if ((val & 0xf) == 1 || (readl(addr) & 0xf) == 1)
|
|
|
|
val |= 0xf000;
|
|
|
|
}
|
|
|
|
writelfl(val, addr);
|
2007-07-16 05:29:40 +00:00
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -EINVAL;
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-01-26 23:32:29 +00:00
|
|
|
static void mv6_dev_config(struct ata_device *adev)
|
|
|
|
{
|
|
|
|
/*
|
2008-04-16 18:59:07 +00:00
|
|
|
* Deal with Gen-II ("mv6") hardware quirks/restrictions:
|
|
|
|
*
|
|
|
|
* Gen-II does not support NCQ over a port multiplier
|
|
|
|
* (no FIS-based switching).
|
2008-01-26 23:32:29 +00:00
|
|
|
*/
|
2008-04-16 18:59:07 +00:00
|
|
|
if (adev->flags & ATA_DFLAG_NCQ) {
|
2008-04-19 18:43:42 +00:00
|
|
|
if (sata_pmp_attached(adev->link->ap)) {
|
2008-04-16 18:59:07 +00:00
|
|
|
adev->flags &= ~ATA_DFLAG_NCQ;
|
2008-04-19 18:43:42 +00:00
|
|
|
ata_dev_printk(adev, KERN_INFO,
|
|
|
|
"NCQ disabled for command-based switching\n");
|
|
|
|
}
|
2008-04-16 18:59:07 +00:00
|
|
|
}
|
2008-01-26 23:32:29 +00:00
|
|
|
}
|
|
|
|
|
2008-05-02 06:10:02 +00:00
|
|
|
static int mv_qc_defer(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_link *link = qc->dev->link;
|
|
|
|
struct ata_port *ap = link->ap;
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
|
2008-05-02 06:15:37 +00:00
|
|
|
/*
|
|
|
|
* Don't allow new commands if we're in a delayed EH state
|
|
|
|
* for NCQ and/or FIS-based switching.
|
|
|
|
*/
|
|
|
|
if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH)
|
|
|
|
return ATA_DEFER_PORT;
|
2009-10-12 22:44:00 +00:00
|
|
|
|
|
|
|
/* PIO commands need exclusive link: no other commands [DMA or PIO]
|
|
|
|
* can run concurrently.
|
|
|
|
* set excl_link when we want to send a PIO command in DMA mode
|
|
|
|
* or a non-NCQ command in NCQ mode.
|
|
|
|
* When we receive a command from that link, and there are no
|
|
|
|
* outstanding commands, mark a flag to clear excl_link and let
|
|
|
|
* the command go through.
|
|
|
|
*/
|
|
|
|
if (unlikely(ap->excl_link)) {
|
|
|
|
if (link == ap->excl_link) {
|
|
|
|
if (ap->nr_active_links)
|
|
|
|
return ATA_DEFER_PORT;
|
|
|
|
qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
|
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return ATA_DEFER_PORT;
|
|
|
|
}
|
|
|
|
|
2008-05-02 06:10:02 +00:00
|
|
|
/*
|
|
|
|
* If the port is completely idle, then allow the new qc.
|
|
|
|
*/
|
|
|
|
if (ap->nr_active_links == 0)
|
|
|
|
return 0;
|
|
|
|
|
2008-08-13 11:24:16 +00:00
|
|
|
/*
|
|
|
|
* The port is operating in host queuing mode (EDMA) with NCQ
|
|
|
|
* enabled, allow multiple NCQ commands. EDMA also allows
|
|
|
|
* queueing multiple DMA commands but libata core currently
|
|
|
|
* doesn't allow it.
|
|
|
|
*/
|
|
|
|
if ((pp->pp_flags & MV_PP_FLAG_EDMA_EN) &&
|
2009-10-12 22:44:00 +00:00
|
|
|
(pp->pp_flags & MV_PP_FLAG_NCQ_EN)) {
|
|
|
|
if (ata_is_ncq(qc->tf.protocol))
|
|
|
|
return 0;
|
|
|
|
else {
|
|
|
|
ap->excl_link = link;
|
|
|
|
return ATA_DEFER_PORT;
|
|
|
|
}
|
|
|
|
}
|
2008-08-13 11:24:16 +00:00
|
|
|
|
2008-05-02 06:10:02 +00:00
|
|
|
return ATA_DEFER_PORT;
|
|
|
|
}
|
|
|
|
|
2009-02-25 20:13:03 +00:00
|
|
|
static void mv_config_fbs(struct ata_port *ap, int want_ncq, int want_fbs)
|
2008-04-16 18:59:07 +00:00
|
|
|
{
|
2009-02-25 20:13:03 +00:00
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
void __iomem *port_mmio;
|
2008-05-02 06:11:45 +00:00
|
|
|
|
2009-02-25 20:13:03 +00:00
|
|
|
u32 fiscfg, *old_fiscfg = &pp->cached.fiscfg;
|
|
|
|
u32 ltmode, *old_ltmode = &pp->cached.ltmode;
|
|
|
|
u32 haltcond, *old_haltcond = &pp->cached.haltcond;
|
2008-05-02 06:11:45 +00:00
|
|
|
|
2009-02-25 20:13:03 +00:00
|
|
|
ltmode = *old_ltmode & ~LTMODE_BIT8;
|
|
|
|
haltcond = *old_haltcond | EDMA_ERR_DEV;
|
2008-05-02 06:11:45 +00:00
|
|
|
|
|
|
|
if (want_fbs) {
|
2009-02-25 20:13:03 +00:00
|
|
|
fiscfg = *old_fiscfg | FISCFG_SINGLE_SYNC;
|
|
|
|
ltmode = *old_ltmode | LTMODE_BIT8;
|
2008-05-02 06:16:20 +00:00
|
|
|
if (want_ncq)
|
2009-02-25 20:13:03 +00:00
|
|
|
haltcond &= ~EDMA_ERR_DEV;
|
2008-05-02 06:16:20 +00:00
|
|
|
else
|
2009-02-25 20:13:03 +00:00
|
|
|
fiscfg |= FISCFG_WAIT_DEV_ERR;
|
|
|
|
} else {
|
|
|
|
fiscfg = *old_fiscfg & ~(FISCFG_SINGLE_SYNC | FISCFG_WAIT_DEV_ERR);
|
2008-04-16 18:59:07 +00:00
|
|
|
}
|
2008-05-02 06:11:45 +00:00
|
|
|
|
2009-02-25 20:13:03 +00:00
|
|
|
port_mmio = mv_ap_base(ap);
|
2009-04-06 20:43:45 +00:00
|
|
|
mv_write_cached_reg(port_mmio + FISCFG, old_fiscfg, fiscfg);
|
|
|
|
mv_write_cached_reg(port_mmio + LTMODE, old_ltmode, ltmode);
|
|
|
|
mv_write_cached_reg(port_mmio + EDMA_HALTCOND, old_haltcond, haltcond);
|
2008-01-26 23:32:29 +00:00
|
|
|
}
|
|
|
|
|
2008-05-02 06:10:56 +00:00
|
|
|
static void mv_60x1_errata_sata25(struct ata_port *ap, int want_ncq)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
|
|
|
u32 old, new;
|
|
|
|
|
|
|
|
/* workaround for 88SX60x1 FEr SATA#25 (part 1) */
|
2009-04-06 20:43:45 +00:00
|
|
|
old = readl(hpriv->base + GPIO_PORT_CTL);
|
2008-05-02 06:10:56 +00:00
|
|
|
if (want_ncq)
|
|
|
|
new = old | (1 << 22);
|
|
|
|
else
|
|
|
|
new = old & ~(1 << 22);
|
|
|
|
if (new != old)
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(new, hpriv->base + GPIO_PORT_CTL);
|
2008-05-02 06:10:56 +00:00
|
|
|
}
|
|
|
|
|
2009-02-25 20:14:48 +00:00
|
|
|
/**
|
2009-03-10 22:51:04 +00:00
|
|
|
* mv_bmdma_enable - set a magic bit on GEN_IIE to allow bmdma
|
|
|
|
* @ap: Port being initialized
|
2009-02-25 20:14:48 +00:00
|
|
|
*
|
|
|
|
* There are two DMA modes on these chips: basic DMA, and EDMA.
|
|
|
|
*
|
|
|
|
* Bit-0 of the "EDMA RESERVED" register enables/disables use
|
|
|
|
* of basic DMA on the GEN_IIE versions of the chips.
|
|
|
|
*
|
|
|
|
* This bit survives EDMA resets, and must be set for basic DMA
|
|
|
|
* to function, and should be cleared when EDMA is active.
|
|
|
|
*/
|
|
|
|
static void mv_bmdma_enable_iie(struct ata_port *ap, int enable_bmdma)
|
|
|
|
{
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
u32 new, *old = &pp->cached.unknown_rsvd;
|
|
|
|
|
|
|
|
if (enable_bmdma)
|
|
|
|
new = *old | 1;
|
|
|
|
else
|
|
|
|
new = *old & ~1;
|
2009-04-06 20:43:45 +00:00
|
|
|
mv_write_cached_reg(mv_ap_base(ap) + EDMA_UNKNOWN_RSVD, old, new);
|
2009-02-25 20:14:48 +00:00
|
|
|
}
|
|
|
|
|
2009-03-15 15:33:19 +00:00
|
|
|
/*
|
|
|
|
* SOC chips have an issue whereby the HDD LEDs don't always blink
|
|
|
|
* during I/O when NCQ is enabled. Enabling a special "LED blink" mode
|
|
|
|
* of the SOC takes care of it, generating a steady blink rate when
|
|
|
|
* any drive on the chip is active.
|
|
|
|
*
|
|
|
|
* Unfortunately, the blink mode is a global hardware setting for the SOC,
|
|
|
|
* so we must use it whenever at least one port on the SOC has NCQ enabled.
|
|
|
|
*
|
|
|
|
* We turn "LED blink" off when NCQ is not in use anywhere, because the normal
|
|
|
|
* LED operation works then, and provides better (more accurate) feedback.
|
|
|
|
*
|
|
|
|
* Note that this code assumes that an SOC never has more than one HC onboard.
|
|
|
|
*/
|
|
|
|
static void mv_soc_led_blink_enable(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct ata_host *host = ap->host;
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
void __iomem *hc_mmio;
|
|
|
|
u32 led_ctrl;
|
|
|
|
|
|
|
|
if (hpriv->hp_flags & MV_HP_QUIRK_LED_BLINK_EN)
|
|
|
|
return;
|
|
|
|
hpriv->hp_flags |= MV_HP_QUIRK_LED_BLINK_EN;
|
|
|
|
hc_mmio = mv_hc_base_from_port(mv_host_base(host), ap->port_no);
|
2009-04-06 20:43:45 +00:00
|
|
|
led_ctrl = readl(hc_mmio + SOC_LED_CTRL);
|
|
|
|
writel(led_ctrl | SOC_LED_CTRL_BLINK, hc_mmio + SOC_LED_CTRL);
|
2009-03-15 15:33:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_soc_led_blink_disable(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct ata_host *host = ap->host;
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
void __iomem *hc_mmio;
|
|
|
|
u32 led_ctrl;
|
|
|
|
unsigned int port;
|
|
|
|
|
|
|
|
if (!(hpriv->hp_flags & MV_HP_QUIRK_LED_BLINK_EN))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* disable led-blink only if no ports are using NCQ */
|
|
|
|
for (port = 0; port < hpriv->n_ports; port++) {
|
|
|
|
struct ata_port *this_ap = host->ports[port];
|
|
|
|
struct mv_port_priv *pp = this_ap->private_data;
|
|
|
|
|
|
|
|
if (pp->pp_flags & MV_PP_FLAG_NCQ_EN)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
hpriv->hp_flags &= ~MV_HP_QUIRK_LED_BLINK_EN;
|
|
|
|
hc_mmio = mv_hc_base_from_port(mv_host_base(host), ap->port_no);
|
2009-04-06 20:43:45 +00:00
|
|
|
led_ctrl = readl(hc_mmio + SOC_LED_CTRL);
|
|
|
|
writel(led_ctrl & ~SOC_LED_CTRL_BLINK, hc_mmio + SOC_LED_CTRL);
|
2009-03-15 15:33:19 +00:00
|
|
|
}
|
|
|
|
|
2009-01-30 23:47:51 +00:00
|
|
|
static void mv_edma_cfg(struct ata_port *ap, int want_ncq, int want_edma)
|
2006-01-31 17:18:41 +00:00
|
|
|
{
|
2008-01-26 23:31:16 +00:00
|
|
|
u32 cfg;
|
2008-03-31 23:33:56 +00:00
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
2006-01-31 17:18:41 +00:00
|
|
|
|
|
|
|
/* set up non-NCQ EDMA configuration */
|
2008-01-26 23:31:16 +00:00
|
|
|
cfg = EDMA_CFG_Q_DEPTH; /* always 0x1f for *all* chips */
|
2009-02-25 20:17:43 +00:00
|
|
|
pp->pp_flags &=
|
|
|
|
~(MV_PP_FLAG_FBS_EN | MV_PP_FLAG_NCQ_EN | MV_PP_FLAG_FAKE_ATA_BUSY);
|
2006-01-31 17:18:41 +00:00
|
|
|
|
2008-01-26 23:31:16 +00:00
|
|
|
if (IS_GEN_I(hpriv))
|
2006-01-31 17:18:41 +00:00
|
|
|
cfg |= (1 << 8); /* enab config burst size mask */
|
|
|
|
|
2008-05-02 06:10:56 +00:00
|
|
|
else if (IS_GEN_II(hpriv)) {
|
2006-01-31 17:18:41 +00:00
|
|
|
cfg |= EDMA_CFG_RD_BRST_EXT | EDMA_CFG_WR_BUFF_LEN;
|
2008-05-02 06:10:56 +00:00
|
|
|
mv_60x1_errata_sata25(ap, want_ncq);
|
2006-01-31 17:18:41 +00:00
|
|
|
|
2008-05-02 06:10:56 +00:00
|
|
|
} else if (IS_GEN_IIE(hpriv)) {
|
2008-05-02 06:11:45 +00:00
|
|
|
int want_fbs = sata_pmp_attached(ap);
|
|
|
|
/*
|
|
|
|
* Possible future enhancement:
|
|
|
|
*
|
|
|
|
* The chip can use FBS with non-NCQ, if we allow it,
|
|
|
|
* But first we need to have the error handling in place
|
|
|
|
* for this mode (datasheet section 7.3.15.4.2.3).
|
|
|
|
* So disallow non-NCQ FBS for now.
|
|
|
|
*/
|
|
|
|
want_fbs &= want_ncq;
|
|
|
|
|
2009-02-25 20:13:03 +00:00
|
|
|
mv_config_fbs(ap, want_ncq, want_fbs);
|
2008-05-02 06:11:45 +00:00
|
|
|
|
|
|
|
if (want_fbs) {
|
|
|
|
pp->pp_flags |= MV_PP_FLAG_FBS_EN;
|
|
|
|
cfg |= EDMA_CFG_EDMA_FBS; /* FIS-based switching */
|
|
|
|
}
|
|
|
|
|
2007-02-25 07:53:41 +00:00
|
|
|
cfg |= (1 << 23); /* do not mask PM field in rx'd FIS */
|
2009-01-30 23:47:51 +00:00
|
|
|
if (want_edma) {
|
|
|
|
cfg |= (1 << 22); /* enab 4-entry host queue cache */
|
|
|
|
if (!IS_SOC(hpriv))
|
|
|
|
cfg |= (1 << 18); /* enab early completion */
|
|
|
|
}
|
2008-05-02 06:08:32 +00:00
|
|
|
if (hpriv->hp_flags & MV_HP_CUT_THROUGH)
|
|
|
|
cfg |= (1 << 17); /* enab cut-thru (dis stor&forwrd) */
|
2009-02-25 20:14:48 +00:00
|
|
|
mv_bmdma_enable_iie(ap, !want_edma);
|
2009-03-15 15:33:19 +00:00
|
|
|
|
|
|
|
if (IS_SOC(hpriv)) {
|
|
|
|
if (want_ncq)
|
|
|
|
mv_soc_led_blink_enable(ap);
|
|
|
|
else
|
|
|
|
mv_soc_led_blink_disable(ap);
|
|
|
|
}
|
2006-01-31 17:18:41 +00:00
|
|
|
}
|
|
|
|
|
2008-01-26 23:31:33 +00:00
|
|
|
if (want_ncq) {
|
|
|
|
cfg |= EDMA_CFG_NCQ;
|
|
|
|
pp->pp_flags |= MV_PP_FLAG_NCQ_EN;
|
2009-01-30 23:47:51 +00:00
|
|
|
}
|
2008-01-26 23:31:33 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(cfg, port_mmio + EDMA_CFG);
|
2006-01-31 17:18:41 +00:00
|
|
|
}
|
|
|
|
|
2008-01-26 23:32:45 +00:00
|
|
|
static void mv_port_free_dma_mem(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
2008-01-29 18:24:00 +00:00
|
|
|
int tag;
|
2008-01-26 23:32:45 +00:00
|
|
|
|
|
|
|
if (pp->crqb) {
|
|
|
|
dma_pool_free(hpriv->crqb_pool, pp->crqb, pp->crqb_dma);
|
|
|
|
pp->crqb = NULL;
|
|
|
|
}
|
|
|
|
if (pp->crpb) {
|
|
|
|
dma_pool_free(hpriv->crpb_pool, pp->crpb, pp->crpb_dma);
|
|
|
|
pp->crpb = NULL;
|
|
|
|
}
|
2008-01-29 18:24:00 +00:00
|
|
|
/*
|
|
|
|
* For GEN_I, there's no NCQ, so we have only a single sg_tbl.
|
|
|
|
* For later hardware, we have one unique sg_tbl per NCQ tag.
|
|
|
|
*/
|
|
|
|
for (tag = 0; tag < MV_MAX_Q_DEPTH; ++tag) {
|
|
|
|
if (pp->sg_tbl[tag]) {
|
|
|
|
if (tag == 0 || !IS_GEN_I(hpriv))
|
|
|
|
dma_pool_free(hpriv->sg_tbl_pool,
|
|
|
|
pp->sg_tbl[tag],
|
|
|
|
pp->sg_tbl_dma[tag]);
|
|
|
|
pp->sg_tbl[tag] = NULL;
|
|
|
|
}
|
2008-01-26 23:32:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_port_start - Port specific init/start routine.
|
|
|
|
* @ap: ATA channel to manipulate
|
|
|
|
*
|
|
|
|
* Allocate and point to DMA memory, init port private memory,
|
|
|
|
* zero indices.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2005-09-30 05:36:00 +00:00
|
|
|
static int mv_port_start(struct ata_port *ap)
|
|
|
|
{
|
2006-08-24 07:19:22 +00:00
|
|
|
struct device *dev = ap->host->dev;
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
2005-09-30 05:36:00 +00:00
|
|
|
struct mv_port_priv *pp;
|
2009-04-06 16:30:43 +00:00
|
|
|
unsigned long flags;
|
2008-02-19 10:36:56 +00:00
|
|
|
int tag;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2007-01-20 07:00:28 +00:00
|
|
|
pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
|
2005-11-05 03:08:00 +00:00
|
|
|
if (!pp)
|
2007-01-20 07:00:28 +00:00
|
|
|
return -ENOMEM;
|
2008-01-26 23:32:45 +00:00
|
|
|
ap->private_data = pp;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2008-01-26 23:32:45 +00:00
|
|
|
pp->crqb = dma_pool_alloc(hpriv->crqb_pool, GFP_KERNEL, &pp->crqb_dma);
|
|
|
|
if (!pp->crqb)
|
|
|
|
return -ENOMEM;
|
|
|
|
memset(pp->crqb, 0, MV_CRQB_Q_SZ);
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2008-01-26 23:32:45 +00:00
|
|
|
pp->crpb = dma_pool_alloc(hpriv->crpb_pool, GFP_KERNEL, &pp->crpb_dma);
|
|
|
|
if (!pp->crpb)
|
|
|
|
goto out_port_free_dma_mem;
|
|
|
|
memset(pp->crpb, 0, MV_CRPB_Q_SZ);
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2008-06-18 16:11:16 +00:00
|
|
|
/* 6041/6081 Rev. "C0" (and newer) are okay with async notify */
|
|
|
|
if (hpriv->hp_flags & MV_HP_ERRATA_60X1C0)
|
|
|
|
ap->flags |= ATA_FLAG_AN;
|
2008-01-29 18:24:00 +00:00
|
|
|
/*
|
|
|
|
* For GEN_I, there's no NCQ, so we only allocate a single sg_tbl.
|
|
|
|
* For later hardware, we need one unique sg_tbl per NCQ tag.
|
|
|
|
*/
|
|
|
|
for (tag = 0; tag < MV_MAX_Q_DEPTH; ++tag) {
|
|
|
|
if (tag == 0 || !IS_GEN_I(hpriv)) {
|
|
|
|
pp->sg_tbl[tag] = dma_pool_alloc(hpriv->sg_tbl_pool,
|
|
|
|
GFP_KERNEL, &pp->sg_tbl_dma[tag]);
|
|
|
|
if (!pp->sg_tbl[tag])
|
|
|
|
goto out_port_free_dma_mem;
|
|
|
|
} else {
|
|
|
|
pp->sg_tbl[tag] = pp->sg_tbl[0];
|
|
|
|
pp->sg_tbl_dma[tag] = pp->sg_tbl_dma[0];
|
|
|
|
}
|
|
|
|
}
|
2009-04-06 16:30:43 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(ap->lock, flags);
|
2009-02-25 20:13:03 +00:00
|
|
|
mv_save_cached_regs(ap);
|
2009-01-30 23:52:58 +00:00
|
|
|
mv_edma_cfg(ap, 0, 0);
|
2009-04-06 16:30:43 +00:00
|
|
|
spin_unlock_irqrestore(ap->lock, flags);
|
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
return 0;
|
2008-01-26 23:32:45 +00:00
|
|
|
|
|
|
|
out_port_free_dma_mem:
|
|
|
|
mv_port_free_dma_mem(ap);
|
|
|
|
return -ENOMEM;
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_port_stop - Port specific cleanup/stop routine.
|
|
|
|
* @ap: ATA channel to manipulate
|
|
|
|
*
|
|
|
|
* Stop DMA, cleanup port memory.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
2006-08-24 07:19:22 +00:00
|
|
|
* This routine uses the host lock to protect the DMA stop.
|
2005-10-05 21:08:53 +00:00
|
|
|
*/
|
2005-09-30 05:36:00 +00:00
|
|
|
static void mv_port_stop(struct ata_port *ap)
|
|
|
|
{
|
2009-04-06 16:30:43 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(ap->lock, flags);
|
2008-03-31 23:33:56 +00:00
|
|
|
mv_stop_edma(ap);
|
2008-05-17 17:36:30 +00:00
|
|
|
mv_enable_port_irqs(ap, 0);
|
2009-04-06 16:30:43 +00:00
|
|
|
spin_unlock_irqrestore(ap->lock, flags);
|
2008-01-26 23:32:45 +00:00
|
|
|
mv_port_free_dma_mem(ap);
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_fill_sg - Fill out the Marvell ePRD (scatter gather) entries
|
|
|
|
* @qc: queued command whose SG list to source from
|
|
|
|
*
|
|
|
|
* Populate the SG list and mark the last entry.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2007-10-12 04:16:23 +00:00
|
|
|
static void mv_fill_sg(struct ata_queued_cmd *qc)
|
2005-09-30 05:36:00 +00:00
|
|
|
{
|
|
|
|
struct mv_port_priv *pp = qc->ap->private_data;
|
2005-10-19 02:14:54 +00:00
|
|
|
struct scatterlist *sg;
|
2007-10-18 20:21:18 +00:00
|
|
|
struct mv_sg *mv_sg, *last_sg = NULL;
|
2007-12-05 07:43:11 +00:00
|
|
|
unsigned int si;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2008-01-29 18:24:00 +00:00
|
|
|
mv_sg = pp->sg_tbl[qc->tag];
|
2007-12-05 07:43:11 +00:00
|
|
|
for_each_sg(qc->sg, sg, qc->n_elem, si) {
|
2007-02-26 06:26:06 +00:00
|
|
|
dma_addr_t addr = sg_dma_address(sg);
|
|
|
|
u32 sg_len = sg_dma_len(sg);
|
2005-11-17 15:59:48 +00:00
|
|
|
|
2007-10-03 01:45:27 +00:00
|
|
|
while (sg_len) {
|
|
|
|
u32 offset = addr & 0xffff;
|
|
|
|
u32 len = sg_len;
|
2005-11-17 15:59:48 +00:00
|
|
|
|
2009-02-01 21:50:32 +00:00
|
|
|
if (offset + len > 0x10000)
|
2007-10-03 01:45:27 +00:00
|
|
|
len = 0x10000 - offset;
|
|
|
|
|
|
|
|
mv_sg->addr = cpu_to_le32(addr & 0xffffffff);
|
|
|
|
mv_sg->addr_hi = cpu_to_le32((addr >> 16) >> 16);
|
2007-10-12 04:16:23 +00:00
|
|
|
mv_sg->flags_size = cpu_to_le32(len & 0xffff);
|
2009-02-01 21:50:32 +00:00
|
|
|
mv_sg->reserved = 0;
|
2007-10-03 01:45:27 +00:00
|
|
|
|
|
|
|
sg_len -= len;
|
|
|
|
addr += len;
|
|
|
|
|
2007-10-18 20:21:18 +00:00
|
|
|
last_sg = mv_sg;
|
2007-10-03 01:45:27 +00:00
|
|
|
mv_sg++;
|
|
|
|
}
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
2007-10-18 20:21:18 +00:00
|
|
|
|
|
|
|
if (likely(last_sg))
|
|
|
|
last_sg->flags_size |= cpu_to_le32(EPRD_FLAG_END_OF_TBL);
|
2009-02-01 21:50:32 +00:00
|
|
|
mb(); /* ensure data structure is visible to the chipset */
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
|
|
|
|
2007-10-26 04:03:37 +00:00
|
|
|
static void mv_crqb_pack_cmd(__le16 *cmdw, u8 data, u8 addr, unsigned last)
|
2005-09-30 05:36:00 +00:00
|
|
|
{
|
2006-05-19 20:40:15 +00:00
|
|
|
u16 tmp = data | (addr << CRQB_CMD_ADDR_SHIFT) | CRQB_CMD_CS |
|
2005-09-30 05:36:00 +00:00
|
|
|
(last ? CRQB_CMD_LAST : 0);
|
2006-05-19 20:40:15 +00:00
|
|
|
*cmdw = cpu_to_le16(tmp);
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
|
|
|
|
2009-01-30 23:51:54 +00:00
|
|
|
/**
|
|
|
|
* mv_sff_irq_clear - Clear hardware interrupt after DMA.
|
|
|
|
* @ap: Port associated with this ATA transaction.
|
|
|
|
*
|
|
|
|
* We need this only for ATAPI bmdma transactions,
|
|
|
|
* as otherwise we experience spurious interrupts
|
|
|
|
* after libata-sff handles the bmdma interrupts.
|
|
|
|
*/
|
|
|
|
static void mv_sff_irq_clear(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
mv_clear_and_enable_port_irqs(ap, mv_ap_base(ap), ERR_IRQ);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_check_atapi_dma - Filter ATAPI cmds which are unsuitable for DMA.
|
|
|
|
* @qc: queued command to check for chipset/DMA compatibility.
|
|
|
|
*
|
|
|
|
* The bmdma engines cannot handle speculative data sizes
|
|
|
|
* (bytecount under/over flow). So only allow DMA for
|
|
|
|
* data transfer commands with known data sizes.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static int mv_check_atapi_dma(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *scmd = qc->scsicmd;
|
|
|
|
|
|
|
|
if (scmd) {
|
|
|
|
switch (scmd->cmnd[0]) {
|
|
|
|
case READ_6:
|
|
|
|
case READ_10:
|
|
|
|
case READ_12:
|
|
|
|
case WRITE_6:
|
|
|
|
case WRITE_10:
|
|
|
|
case WRITE_12:
|
|
|
|
case GPCMD_READ_CD:
|
|
|
|
case GPCMD_SEND_DVD_STRUCTURE:
|
|
|
|
case GPCMD_SEND_CUE_SHEET:
|
|
|
|
return 0; /* DMA is safe */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -EOPNOTSUPP; /* use PIO instead */
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_bmdma_setup - Set up BMDMA transaction
|
|
|
|
* @qc: queued command to prepare DMA for.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static void mv_bmdma_setup(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
|
|
|
|
mv_fill_sg(qc);
|
|
|
|
|
|
|
|
/* clear all DMA cmd bits */
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0, port_mmio + BMDMA_CMD);
|
2009-01-30 23:51:54 +00:00
|
|
|
|
|
|
|
/* load PRD table addr. */
|
|
|
|
writel((pp->sg_tbl_dma[qc->tag] >> 16) >> 16,
|
2009-04-06 20:43:45 +00:00
|
|
|
port_mmio + BMDMA_PRD_HIGH);
|
2009-01-30 23:51:54 +00:00
|
|
|
writelfl(pp->sg_tbl_dma[qc->tag],
|
2009-04-06 20:43:45 +00:00
|
|
|
port_mmio + BMDMA_PRD_LOW);
|
2009-01-30 23:51:54 +00:00
|
|
|
|
|
|
|
/* issue r/w command */
|
|
|
|
ap->ops->sff_exec_command(ap, &qc->tf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_bmdma_start - Start a BMDMA transaction
|
|
|
|
* @qc: queued command to start DMA on.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static void mv_bmdma_start(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
|
|
|
|
u32 cmd = (rw ? 0 : ATA_DMA_WR) | ATA_DMA_START;
|
|
|
|
|
|
|
|
/* start host DMA transaction */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(cmd, port_mmio + BMDMA_CMD);
|
2009-01-30 23:51:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_bmdma_stop - Stop BMDMA transfer
|
|
|
|
* @qc: queued command to stop DMA on.
|
|
|
|
*
|
|
|
|
* Clears the ATA_DMA_START flag in the bmdma control register
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static void mv_bmdma_stop(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
u32 cmd;
|
|
|
|
|
|
|
|
/* clear start/stop bit */
|
2009-04-06 20:43:45 +00:00
|
|
|
cmd = readl(port_mmio + BMDMA_CMD);
|
2009-01-30 23:51:54 +00:00
|
|
|
cmd &= ~ATA_DMA_START;
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(cmd, port_mmio + BMDMA_CMD);
|
2009-01-30 23:51:54 +00:00
|
|
|
|
|
|
|
/* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
|
|
|
|
ata_sff_dma_pause(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_bmdma_status - Read BMDMA status
|
|
|
|
* @ap: port for which to retrieve DMA status.
|
|
|
|
*
|
|
|
|
* Read and return equivalent of the sff BMDMA status register.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static u8 mv_bmdma_status(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
u32 reg, status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Other bits are valid only if ATA_DMA_ACTIVE==0,
|
|
|
|
* and the ATA_DMA_INTR bit doesn't exist.
|
|
|
|
*/
|
2009-04-06 20:43:45 +00:00
|
|
|
reg = readl(port_mmio + BMDMA_STATUS);
|
2009-01-30 23:51:54 +00:00
|
|
|
if (reg & ATA_DMA_ACTIVE)
|
|
|
|
status = ATA_DMA_ACTIVE;
|
|
|
|
else
|
|
|
|
status = (reg & ATA_DMA_ERR) | ATA_DMA_INTR;
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2009-04-13 15:29:34 +00:00
|
|
|
static void mv_rw_multi_errata_sata24(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_taskfile *tf = &qc->tf;
|
|
|
|
/*
|
|
|
|
* Workaround for 88SX60x1 FEr SATA#24.
|
|
|
|
*
|
|
|
|
* Chip may corrupt WRITEs if multi_count >= 4kB.
|
|
|
|
* Note that READs are unaffected.
|
|
|
|
*
|
|
|
|
* It's not clear if this errata really means "4K bytes",
|
|
|
|
* or if it always happens for multi_count > 7
|
|
|
|
* regardless of device sector_size.
|
|
|
|
*
|
|
|
|
* So, for safety, any write with multi_count > 7
|
|
|
|
* gets converted here into a regular PIO write instead:
|
|
|
|
*/
|
|
|
|
if ((tf->flags & ATA_TFLAG_WRITE) && is_multi_taskfile(tf)) {
|
|
|
|
if (qc->dev->multi_count > 7) {
|
|
|
|
switch (tf->command) {
|
|
|
|
case ATA_CMD_WRITE_MULTI:
|
|
|
|
tf->command = ATA_CMD_PIO_WRITE;
|
|
|
|
break;
|
|
|
|
case ATA_CMD_WRITE_MULTI_FUA_EXT:
|
|
|
|
tf->flags &= ~ATA_TFLAG_FUA; /* ugh */
|
|
|
|
/* fall through */
|
|
|
|
case ATA_CMD_WRITE_MULTI_EXT:
|
|
|
|
tf->command = ATA_CMD_PIO_WRITE_EXT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_qc_prep - Host specific command preparation.
|
|
|
|
* @qc: queued command to prepare
|
|
|
|
*
|
|
|
|
* This routine simply redirects to the general purpose routine
|
|
|
|
* if command is not DMA. Else, it handles prep of the CRQB
|
|
|
|
* (command request block), does some sanity checking, and calls
|
|
|
|
* the SG load routine.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2005-09-30 05:36:00 +00:00
|
|
|
static void mv_qc_prep(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
2006-05-22 23:02:03 +00:00
|
|
|
__le16 *cw;
|
2009-04-13 15:27:18 +00:00
|
|
|
struct ata_taskfile *tf = &qc->tf;
|
2005-09-30 05:36:00 +00:00
|
|
|
u16 flags = 0;
|
2006-05-19 20:36:36 +00:00
|
|
|
unsigned in_index;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2009-04-13 15:29:34 +00:00
|
|
|
switch (tf->protocol) {
|
|
|
|
case ATA_PROT_DMA:
|
|
|
|
case ATA_PROT_NCQ:
|
|
|
|
break; /* continue below */
|
|
|
|
case ATA_PROT_PIO:
|
|
|
|
mv_rw_multi_errata_sata24(qc);
|
2005-09-30 05:36:00 +00:00
|
|
|
return;
|
2009-04-13 15:29:34 +00:00
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
/* Fill in command request block
|
|
|
|
*/
|
2009-04-13 15:27:18 +00:00
|
|
|
if (!(tf->flags & ATA_TFLAG_WRITE))
|
2005-09-30 05:36:00 +00:00
|
|
|
flags |= CRQB_FLAG_READ;
|
2006-02-11 10:11:13 +00:00
|
|
|
WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
|
2005-09-30 05:36:00 +00:00
|
|
|
flags |= qc->tag << CRQB_TAG_SHIFT;
|
2008-04-16 18:59:07 +00:00
|
|
|
flags |= (qc->dev->link->pmp & 0xf) << CRQB_PMP_SHIFT;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2007-07-12 18:34:26 +00:00
|
|
|
/* get current queue index from software */
|
2008-04-19 19:06:40 +00:00
|
|
|
in_index = pp->req_idx;
|
2006-05-19 20:36:36 +00:00
|
|
|
|
|
|
|
pp->crqb[in_index].sg_addr =
|
2008-01-29 18:24:00 +00:00
|
|
|
cpu_to_le32(pp->sg_tbl_dma[qc->tag] & 0xffffffff);
|
2006-05-19 20:36:36 +00:00
|
|
|
pp->crqb[in_index].sg_addr_hi =
|
2008-01-29 18:24:00 +00:00
|
|
|
cpu_to_le32((pp->sg_tbl_dma[qc->tag] >> 16) >> 16);
|
2006-05-19 20:36:36 +00:00
|
|
|
pp->crqb[in_index].ctrl_flags = cpu_to_le16(flags);
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2006-05-19 20:36:36 +00:00
|
|
|
cw = &pp->crqb[in_index].ata_cmd[0];
|
2005-09-30 05:36:00 +00:00
|
|
|
|
|
|
|
/* Sadly, the CRQB cannot accomodate all registers--there are
|
|
|
|
* only 11 bytes...so we must pick and choose required
|
|
|
|
* registers based on the command. So, we drop feature and
|
|
|
|
* hob_feature for [RW] DMA commands, but they are needed for
|
2009-01-19 23:06:28 +00:00
|
|
|
* NCQ. NCQ will drop hob_nsect, which is not needed there
|
|
|
|
* (nsect is used only for the tag; feat/hob_feat hold true nsect).
|
2005-09-01 22:26:17 +00:00
|
|
|
*/
|
2005-09-30 05:36:00 +00:00
|
|
|
switch (tf->command) {
|
|
|
|
case ATA_CMD_READ:
|
|
|
|
case ATA_CMD_READ_EXT:
|
|
|
|
case ATA_CMD_WRITE:
|
|
|
|
case ATA_CMD_WRITE_EXT:
|
2006-02-15 14:59:25 +00:00
|
|
|
case ATA_CMD_WRITE_FUA_EXT:
|
2005-09-30 05:36:00 +00:00
|
|
|
mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
|
|
|
|
break;
|
|
|
|
case ATA_CMD_FPDMA_READ:
|
|
|
|
case ATA_CMD_FPDMA_WRITE:
|
2005-11-12 17:32:50 +00:00
|
|
|
mv_crqb_pack_cmd(cw++, tf->hob_feature, ATA_REG_FEATURE, 0);
|
2005-09-30 05:36:00 +00:00
|
|
|
mv_crqb_pack_cmd(cw++, tf->feature, ATA_REG_FEATURE, 0);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* The only other commands EDMA supports in non-queued and
|
|
|
|
* non-NCQ mode are: [RW] STREAM DMA and W DMA FUA EXT, none
|
|
|
|
* of which are defined/used by Linux. If we get here, this
|
|
|
|
* driver needs work.
|
|
|
|
*
|
|
|
|
* FIXME: modify libata to give qc_prep a return value and
|
|
|
|
* return error here.
|
|
|
|
*/
|
|
|
|
BUG_ON(tf->command);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->nsect, ATA_REG_NSECT, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->hob_lbal, ATA_REG_LBAL, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->lbal, ATA_REG_LBAL, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->hob_lbam, ATA_REG_LBAM, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->lbam, ATA_REG_LBAM, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->hob_lbah, ATA_REG_LBAH, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->lbah, ATA_REG_LBAH, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->device, ATA_REG_DEVICE, 0);
|
|
|
|
mv_crqb_pack_cmd(cw++, tf->command, ATA_REG_CMD, 1); /* last */
|
|
|
|
|
2006-01-31 17:18:41 +00:00
|
|
|
if (!(qc->flags & ATA_QCFLAG_DMAMAP))
|
|
|
|
return;
|
|
|
|
mv_fill_sg(qc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_qc_prep_iie - Host specific command preparation.
|
|
|
|
* @qc: queued command to prepare
|
|
|
|
*
|
|
|
|
* This routine simply redirects to the general purpose routine
|
|
|
|
* if command is not DMA. Else, it handles prep of the CRQB
|
|
|
|
* (command request block), does some sanity checking, and calls
|
|
|
|
* the SG load routine.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
struct mv_crqb_iie *crqb;
|
2009-04-13 15:27:18 +00:00
|
|
|
struct ata_taskfile *tf = &qc->tf;
|
2006-05-19 20:36:36 +00:00
|
|
|
unsigned in_index;
|
2006-01-31 17:18:41 +00:00
|
|
|
u32 flags = 0;
|
|
|
|
|
2009-04-13 15:27:18 +00:00
|
|
|
if ((tf->protocol != ATA_PROT_DMA) &&
|
|
|
|
(tf->protocol != ATA_PROT_NCQ))
|
2006-01-31 17:18:41 +00:00
|
|
|
return;
|
|
|
|
|
2008-03-31 23:33:56 +00:00
|
|
|
/* Fill in Gen IIE command request block */
|
2009-04-13 15:27:18 +00:00
|
|
|
if (!(tf->flags & ATA_TFLAG_WRITE))
|
2006-01-31 17:18:41 +00:00
|
|
|
flags |= CRQB_FLAG_READ;
|
|
|
|
|
2006-02-11 10:11:13 +00:00
|
|
|
WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
|
2006-01-31 17:18:41 +00:00
|
|
|
flags |= qc->tag << CRQB_TAG_SHIFT;
|
2008-01-26 23:31:48 +00:00
|
|
|
flags |= qc->tag << CRQB_HOSTQ_SHIFT;
|
2008-04-16 18:59:07 +00:00
|
|
|
flags |= (qc->dev->link->pmp & 0xf) << CRQB_PMP_SHIFT;
|
2006-01-31 17:18:41 +00:00
|
|
|
|
2007-07-12 18:34:26 +00:00
|
|
|
/* get current queue index from software */
|
2008-04-19 19:06:40 +00:00
|
|
|
in_index = pp->req_idx;
|
2006-05-19 20:36:36 +00:00
|
|
|
|
|
|
|
crqb = (struct mv_crqb_iie *) &pp->crqb[in_index];
|
2008-01-29 18:24:00 +00:00
|
|
|
crqb->addr = cpu_to_le32(pp->sg_tbl_dma[qc->tag] & 0xffffffff);
|
|
|
|
crqb->addr_hi = cpu_to_le32((pp->sg_tbl_dma[qc->tag] >> 16) >> 16);
|
2006-01-31 17:18:41 +00:00
|
|
|
crqb->flags = cpu_to_le32(flags);
|
|
|
|
|
|
|
|
crqb->ata_cmd[0] = cpu_to_le32(
|
|
|
|
(tf->command << 16) |
|
|
|
|
(tf->feature << 24)
|
|
|
|
);
|
|
|
|
crqb->ata_cmd[1] = cpu_to_le32(
|
|
|
|
(tf->lbal << 0) |
|
|
|
|
(tf->lbam << 8) |
|
|
|
|
(tf->lbah << 16) |
|
|
|
|
(tf->device << 24)
|
|
|
|
);
|
|
|
|
crqb->ata_cmd[2] = cpu_to_le32(
|
|
|
|
(tf->hob_lbal << 0) |
|
|
|
|
(tf->hob_lbam << 8) |
|
|
|
|
(tf->hob_lbah << 16) |
|
|
|
|
(tf->hob_feature << 24)
|
|
|
|
);
|
|
|
|
crqb->ata_cmd[3] = cpu_to_le32(
|
|
|
|
(tf->nsect << 0) |
|
|
|
|
(tf->hob_nsect << 8)
|
|
|
|
);
|
|
|
|
|
|
|
|
if (!(qc->flags & ATA_QCFLAG_DMAMAP))
|
2005-09-30 05:36:00 +00:00
|
|
|
return;
|
|
|
|
mv_fill_sg(qc);
|
|
|
|
}
|
|
|
|
|
2009-02-25 20:17:43 +00:00
|
|
|
/**
|
|
|
|
* mv_sff_check_status - fetch device status, if valid
|
|
|
|
* @ap: ATA port to fetch status from
|
|
|
|
*
|
|
|
|
* When using command issue via mv_qc_issue_fis(),
|
|
|
|
* the initial ATA_BUSY state does not show up in the
|
|
|
|
* ATA status (shadow) register. This can confuse libata!
|
|
|
|
*
|
|
|
|
* So we have a hook here to fake ATA_BUSY for that situation,
|
|
|
|
* until the first time a BUSY, DRQ, or ERR bit is seen.
|
|
|
|
*
|
|
|
|
* The rest of the time, it simply returns the ATA status register.
|
|
|
|
*/
|
|
|
|
static u8 mv_sff_check_status(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
u8 stat = ioread8(ap->ioaddr.status_addr);
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
|
|
|
|
if (pp->pp_flags & MV_PP_FLAG_FAKE_ATA_BUSY) {
|
|
|
|
if (stat & (ATA_BUSY | ATA_DRQ | ATA_ERR))
|
|
|
|
pp->pp_flags &= ~MV_PP_FLAG_FAKE_ATA_BUSY;
|
|
|
|
else
|
|
|
|
stat = ATA_BUSY;
|
|
|
|
}
|
|
|
|
return stat;
|
|
|
|
}
|
|
|
|
|
2009-02-25 20:19:20 +00:00
|
|
|
/**
|
|
|
|
* mv_send_fis - Send a FIS, using the "Vendor-Unique FIS" register
|
|
|
|
* @fis: fis to be sent
|
|
|
|
* @nwords: number of 32-bit words in the fis
|
|
|
|
*/
|
|
|
|
static unsigned int mv_send_fis(struct ata_port *ap, u32 *fis, int nwords)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
u32 ifctl, old_ifctl, ifstat;
|
|
|
|
int i, timeout = 200, final_word = nwords - 1;
|
|
|
|
|
|
|
|
/* Initiate FIS transmission mode */
|
2009-04-06 20:43:45 +00:00
|
|
|
old_ifctl = readl(port_mmio + SATA_IFCTL);
|
2009-02-25 20:19:20 +00:00
|
|
|
ifctl = 0x100 | (old_ifctl & 0xf);
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(ifctl, port_mmio + SATA_IFCTL);
|
2009-02-25 20:19:20 +00:00
|
|
|
|
|
|
|
/* Send all words of the FIS except for the final word */
|
|
|
|
for (i = 0; i < final_word; ++i)
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(fis[i], port_mmio + VENDOR_UNIQUE_FIS);
|
2009-02-25 20:19:20 +00:00
|
|
|
|
|
|
|
/* Flag end-of-transmission, and then send the final word */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(ifctl | 0x200, port_mmio + SATA_IFCTL);
|
|
|
|
writelfl(fis[final_word], port_mmio + VENDOR_UNIQUE_FIS);
|
2009-02-25 20:19:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for FIS transmission to complete.
|
|
|
|
* This typically takes just a single iteration.
|
|
|
|
*/
|
|
|
|
do {
|
2009-04-06 20:43:45 +00:00
|
|
|
ifstat = readl(port_mmio + SATA_IFSTAT);
|
2009-02-25 20:19:20 +00:00
|
|
|
} while (!(ifstat & 0x1000) && --timeout);
|
|
|
|
|
|
|
|
/* Restore original port configuration */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(old_ifctl, port_mmio + SATA_IFCTL);
|
2009-02-25 20:19:20 +00:00
|
|
|
|
|
|
|
/* See if it worked */
|
|
|
|
if ((ifstat & 0x3000) != 0x1000) {
|
|
|
|
ata_port_printk(ap, KERN_WARNING,
|
|
|
|
"%s transmission error, ifstat=%08x\n",
|
|
|
|
__func__, ifstat);
|
|
|
|
return AC_ERR_OTHER;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv_qc_issue_fis - Issue a command directly as a FIS
|
|
|
|
* @qc: queued command to start
|
|
|
|
*
|
|
|
|
* Note that the ATA shadow registers are not updated
|
|
|
|
* after command issue, so the device will appear "READY"
|
|
|
|
* if polled, even while it is BUSY processing the command.
|
|
|
|
*
|
|
|
|
* So we use a status hook to fake ATA_BUSY until the drive changes state.
|
|
|
|
*
|
|
|
|
* Note: we don't get updated shadow regs on *completion*
|
|
|
|
* of non-data commands. So avoid sending them via this function,
|
|
|
|
* as they will appear to have completed immediately.
|
|
|
|
*
|
|
|
|
* GEN_IIE has special registers that we could get the result tf from,
|
|
|
|
* but earlier chipsets do not. For now, we ignore those registers.
|
|
|
|
*/
|
|
|
|
static unsigned int mv_qc_issue_fis(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
struct ata_link *link = qc->dev->link;
|
|
|
|
u32 fis[5];
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
ata_tf_to_fis(&qc->tf, link->pmp, 1, (void *)fis);
|
2009-11-08 19:30:57 +00:00
|
|
|
err = mv_send_fis(ap, fis, ARRAY_SIZE(fis));
|
2009-02-25 20:19:20 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
switch (qc->tf.protocol) {
|
|
|
|
case ATAPI_PROT_PIO:
|
|
|
|
pp->pp_flags |= MV_PP_FLAG_FAKE_ATA_BUSY;
|
|
|
|
/* fall through */
|
|
|
|
case ATAPI_PROT_NODATA:
|
|
|
|
ap->hsm_task_state = HSM_ST_FIRST;
|
|
|
|
break;
|
|
|
|
case ATA_PROT_PIO:
|
|
|
|
pp->pp_flags |= MV_PP_FLAG_FAKE_ATA_BUSY;
|
|
|
|
if (qc->tf.flags & ATA_TFLAG_WRITE)
|
|
|
|
ap->hsm_task_state = HSM_ST_FIRST;
|
|
|
|
else
|
|
|
|
ap->hsm_task_state = HSM_ST;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ap->hsm_task_state = HSM_ST_LAST;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qc->tf.flags & ATA_TFLAG_POLLING)
|
|
|
|
ata_pio_queue_task(ap, qc, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_qc_issue - Initiate a command to the host
|
|
|
|
* @qc: queued command to start
|
|
|
|
*
|
|
|
|
* This routine simply redirects to the general purpose routine
|
|
|
|
* if command is not DMA. Else, it sanity checks our local
|
|
|
|
* caches of the request producer/consumer indices then enables
|
|
|
|
* DMA and bumps the request producer index.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2006-01-23 04:09:36 +00:00
|
|
|
static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
|
2005-09-30 05:36:00 +00:00
|
|
|
{
|
2009-01-30 23:48:41 +00:00
|
|
|
static int limit_warnings = 10;
|
2007-07-11 22:30:50 +00:00
|
|
|
struct ata_port *ap = qc->ap;
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
2007-07-12 18:34:26 +00:00
|
|
|
u32 in_index;
|
2009-02-25 20:15:39 +00:00
|
|
|
unsigned int port_irqs;
|
2009-01-30 23:48:41 +00:00
|
|
|
|
2009-02-25 20:17:43 +00:00
|
|
|
pp->pp_flags &= ~MV_PP_FLAG_FAKE_ATA_BUSY; /* paranoia */
|
|
|
|
|
2009-01-30 23:48:41 +00:00
|
|
|
switch (qc->tf.protocol) {
|
|
|
|
case ATA_PROT_DMA:
|
|
|
|
case ATA_PROT_NCQ:
|
|
|
|
mv_start_edma(ap, port_mmio, pp, qc->tf.protocol);
|
|
|
|
pp->req_idx = (pp->req_idx + 1) & MV_MAX_Q_DEPTH_MASK;
|
|
|
|
in_index = pp->req_idx << EDMA_REQ_Q_PTR_SHIFT;
|
|
|
|
|
|
|
|
/* Write the request in pointer to kick the EDMA to life */
|
|
|
|
writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | in_index,
|
2009-04-06 20:43:45 +00:00
|
|
|
port_mmio + EDMA_REQ_Q_IN_PTR);
|
2009-01-30 23:48:41 +00:00
|
|
|
return 0;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2009-01-30 23:48:41 +00:00
|
|
|
case ATA_PROT_PIO:
|
2008-06-18 16:13:02 +00:00
|
|
|
/*
|
|
|
|
* Errata SATA#16, SATA#24: warn if multiple DRQs expected.
|
|
|
|
*
|
|
|
|
* Someday, we might implement special polling workarounds
|
|
|
|
* for these, but it all seems rather unnecessary since we
|
|
|
|
* normally use only DMA for commands which transfer more
|
|
|
|
* than a single block of data.
|
|
|
|
*
|
|
|
|
* Much of the time, this could just work regardless.
|
|
|
|
* So for now, just log the incident, and allow the attempt.
|
|
|
|
*/
|
2008-06-19 01:57:42 +00:00
|
|
|
if (limit_warnings > 0 && (qc->nbytes / qc->sect_size) > 1) {
|
2008-06-18 16:13:02 +00:00
|
|
|
--limit_warnings;
|
|
|
|
ata_link_printk(qc->dev->link, KERN_WARNING, DRV_NAME
|
|
|
|
": attempting PIO w/multiple DRQ: "
|
|
|
|
"this may fail due to h/w errata\n");
|
|
|
|
}
|
2009-01-30 23:48:41 +00:00
|
|
|
/* drop through */
|
2009-02-25 20:15:39 +00:00
|
|
|
case ATA_PROT_NODATA:
|
2009-01-30 23:48:41 +00:00
|
|
|
case ATAPI_PROT_PIO:
|
2009-02-25 20:15:39 +00:00
|
|
|
case ATAPI_PROT_NODATA:
|
|
|
|
if (ap->flags & ATA_FLAG_PIO_POLLING)
|
|
|
|
qc->tf.flags |= ATA_TFLAG_POLLING;
|
|
|
|
break;
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
2009-02-25 20:15:39 +00:00
|
|
|
|
|
|
|
if (qc->tf.flags & ATA_TFLAG_POLLING)
|
|
|
|
port_irqs = ERR_IRQ; /* mask device interrupt when polling */
|
|
|
|
else
|
|
|
|
port_irqs = ERR_IRQ | DONE_IRQ; /* unmask all interrupts */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're about to send a non-EDMA capable command to the
|
|
|
|
* port. Turn off EDMA so there won't be problems accessing
|
|
|
|
* shadow block, etc registers.
|
|
|
|
*/
|
|
|
|
mv_stop_edma(ap);
|
|
|
|
mv_clear_and_enable_port_irqs(ap, mv_ap_base(ap), port_irqs);
|
|
|
|
mv_pmp_select(ap, qc->dev->link->pmp);
|
2009-02-25 20:19:20 +00:00
|
|
|
|
|
|
|
if (qc->tf.command == ATA_CMD_READ_LOG_EXT) {
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
|
|
|
/*
|
|
|
|
* Workaround for 88SX60x1 FEr SATA#25 (part 2).
|
2009-03-10 22:51:04 +00:00
|
|
|
*
|
2009-02-25 20:19:20 +00:00
|
|
|
* After any NCQ error, the READ_LOG_EXT command
|
|
|
|
* from libata-eh *must* use mv_qc_issue_fis().
|
|
|
|
* Otherwise it might fail, due to chip errata.
|
|
|
|
*
|
|
|
|
* Rather than special-case it, we'll just *always*
|
|
|
|
* use this method here for READ_LOG_EXT, making for
|
|
|
|
* easier testing.
|
|
|
|
*/
|
|
|
|
if (IS_GEN_II(hpriv))
|
|
|
|
return mv_qc_issue_fis(qc);
|
|
|
|
}
|
2009-02-25 20:15:39 +00:00
|
|
|
return ata_sff_qc_issue(qc);
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
|
|
|
|
2008-04-19 18:53:07 +00:00
|
|
|
static struct ata_queued_cmd *mv_get_active_qc(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
struct ata_queued_cmd *qc;
|
|
|
|
|
|
|
|
if (pp->pp_flags & MV_PP_FLAG_NCQ_EN)
|
|
|
|
return NULL;
|
|
|
|
qc = ata_qc_from_tag(ap, ap->link.active_tag);
|
2009-01-30 23:49:29 +00:00
|
|
|
if (qc) {
|
|
|
|
if (qc->tf.flags & ATA_TFLAG_POLLING)
|
|
|
|
qc = NULL;
|
|
|
|
else if (!(qc->flags & ATA_QCFLAG_ACTIVE))
|
|
|
|
qc = NULL;
|
|
|
|
}
|
2008-04-19 18:53:07 +00:00
|
|
|
return qc;
|
|
|
|
}
|
|
|
|
|
2008-05-02 06:15:37 +00:00
|
|
|
static void mv_pmp_error_handler(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
unsigned int pmp, pmp_map;
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
|
|
|
|
if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH) {
|
|
|
|
/*
|
|
|
|
* Perform NCQ error analysis on failed PMPs
|
|
|
|
* before we freeze the port entirely.
|
|
|
|
*
|
|
|
|
* The failed PMPs are marked earlier by mv_pmp_eh_prep().
|
|
|
|
*/
|
|
|
|
pmp_map = pp->delayed_eh_pmp_map;
|
|
|
|
pp->pp_flags &= ~MV_PP_FLAG_DELAYED_EH;
|
|
|
|
for (pmp = 0; pmp_map != 0; pmp++) {
|
|
|
|
unsigned int this_pmp = (1 << pmp);
|
|
|
|
if (pmp_map & this_pmp) {
|
|
|
|
struct ata_link *link = &ap->pmp_link[pmp];
|
|
|
|
pmp_map &= ~this_pmp;
|
|
|
|
ata_eh_analyze_ncq_error(link);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ata_port_freeze(ap);
|
|
|
|
}
|
|
|
|
sata_pmp_error_handler(ap);
|
|
|
|
}
|
|
|
|
|
2008-05-02 06:16:20 +00:00
|
|
|
static unsigned int mv_get_err_pmp_map(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
return readl(port_mmio + SATA_TESTCTL) >> 16;
|
2008-05-02 06:16:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_pmp_eh_prep(struct ata_port *ap, unsigned int pmp_map)
|
|
|
|
{
|
|
|
|
struct ata_eh_info *ehi;
|
|
|
|
unsigned int pmp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize EH info for PMPs which saw device errors
|
|
|
|
*/
|
|
|
|
ehi = &ap->link.eh_info;
|
|
|
|
for (pmp = 0; pmp_map != 0; pmp++) {
|
|
|
|
unsigned int this_pmp = (1 << pmp);
|
|
|
|
if (pmp_map & this_pmp) {
|
|
|
|
struct ata_link *link = &ap->pmp_link[pmp];
|
|
|
|
|
|
|
|
pmp_map &= ~this_pmp;
|
|
|
|
ehi = &link->eh_info;
|
|
|
|
ata_ehi_clear_desc(ehi);
|
|
|
|
ata_ehi_push_desc(ehi, "dev err");
|
|
|
|
ehi->err_mask |= AC_ERR_DEV;
|
|
|
|
ehi->action |= ATA_EH_RESET;
|
|
|
|
ata_link_abort(link);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-19 13:01:24 +00:00
|
|
|
static int mv_req_q_empty(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
u32 in_ptr, out_ptr;
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
in_ptr = (readl(port_mmio + EDMA_REQ_Q_IN_PTR)
|
2008-05-19 13:01:24 +00:00
|
|
|
>> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
|
2009-04-06 20:43:45 +00:00
|
|
|
out_ptr = (readl(port_mmio + EDMA_REQ_Q_OUT_PTR)
|
2008-05-19 13:01:24 +00:00
|
|
|
>> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
|
|
|
|
return (in_ptr == out_ptr); /* 1 == queue_is_empty */
|
|
|
|
}
|
|
|
|
|
2008-05-02 06:16:20 +00:00
|
|
|
static int mv_handle_fbs_ncq_dev_err(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
int failed_links;
|
|
|
|
unsigned int old_map, new_map;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device error during FBS+NCQ operation:
|
|
|
|
*
|
|
|
|
* Set a port flag to prevent further I/O being enqueued.
|
|
|
|
* Leave the EDMA running to drain outstanding commands from this port.
|
|
|
|
* Perform the post-mortem/EH only when all responses are complete.
|
|
|
|
* Follow recovery sequence from 6042/7042 datasheet (7.3.15.4.2.2).
|
|
|
|
*/
|
|
|
|
if (!(pp->pp_flags & MV_PP_FLAG_DELAYED_EH)) {
|
|
|
|
pp->pp_flags |= MV_PP_FLAG_DELAYED_EH;
|
|
|
|
pp->delayed_eh_pmp_map = 0;
|
|
|
|
}
|
|
|
|
old_map = pp->delayed_eh_pmp_map;
|
|
|
|
new_map = old_map | mv_get_err_pmp_map(ap);
|
|
|
|
|
|
|
|
if (old_map != new_map) {
|
|
|
|
pp->delayed_eh_pmp_map = new_map;
|
|
|
|
mv_pmp_eh_prep(ap, new_map & ~old_map);
|
|
|
|
}
|
2008-05-02 18:02:28 +00:00
|
|
|
failed_links = hweight16(new_map);
|
2008-05-02 06:16:20 +00:00
|
|
|
|
|
|
|
ata_port_printk(ap, KERN_INFO, "%s: pmp_map=%04x qc_map=%04x "
|
|
|
|
"failed_links=%d nr_active_links=%d\n",
|
|
|
|
__func__, pp->delayed_eh_pmp_map,
|
|
|
|
ap->qc_active, failed_links,
|
|
|
|
ap->nr_active_links);
|
|
|
|
|
2008-05-19 13:01:24 +00:00
|
|
|
if (ap->nr_active_links <= failed_links && mv_req_q_empty(ap)) {
|
2008-05-02 06:16:20 +00:00
|
|
|
mv_process_crpb_entries(ap, pp);
|
|
|
|
mv_stop_edma(ap);
|
|
|
|
mv_eh_freeze(ap);
|
|
|
|
ata_port_printk(ap, KERN_INFO, "%s: done\n", __func__);
|
|
|
|
return 1; /* handled */
|
|
|
|
}
|
|
|
|
ata_port_printk(ap, KERN_INFO, "%s: waiting\n", __func__);
|
|
|
|
return 1; /* handled */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mv_handle_fbs_non_ncq_dev_err(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Possible future enhancement:
|
|
|
|
*
|
|
|
|
* FBS+non-NCQ operation is not yet implemented.
|
|
|
|
* See related notes in mv_edma_cfg().
|
|
|
|
*
|
|
|
|
* Device error during FBS+non-NCQ operation:
|
|
|
|
*
|
|
|
|
* We need to snapshot the shadow registers for each failed command.
|
|
|
|
* Follow recovery sequence from 6042/7042 datasheet (7.3.15.4.2.3).
|
|
|
|
*/
|
|
|
|
return 0; /* not handled */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mv_handle_dev_err(struct ata_port *ap, u32 edma_err_cause)
|
|
|
|
{
|
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
|
|
|
|
if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN))
|
|
|
|
return 0; /* EDMA was not active: not handled */
|
|
|
|
if (!(pp->pp_flags & MV_PP_FLAG_FBS_EN))
|
|
|
|
return 0; /* FBS was not active: not handled */
|
|
|
|
|
|
|
|
if (!(edma_err_cause & EDMA_ERR_DEV))
|
|
|
|
return 0; /* non DEV error: not handled */
|
|
|
|
edma_err_cause &= ~EDMA_ERR_IRQ_TRANSIENT;
|
|
|
|
if (edma_err_cause & ~(EDMA_ERR_DEV | EDMA_ERR_SELF_DIS))
|
|
|
|
return 0; /* other problems: not handled */
|
|
|
|
|
|
|
|
if (pp->pp_flags & MV_PP_FLAG_NCQ_EN) {
|
|
|
|
/*
|
|
|
|
* EDMA should NOT have self-disabled for this case.
|
|
|
|
* If it did, then something is wrong elsewhere,
|
|
|
|
* and we cannot handle it here.
|
|
|
|
*/
|
|
|
|
if (edma_err_cause & EDMA_ERR_SELF_DIS) {
|
|
|
|
ata_port_printk(ap, KERN_WARNING,
|
|
|
|
"%s: err_cause=0x%x pp_flags=0x%x\n",
|
|
|
|
__func__, edma_err_cause, pp->pp_flags);
|
|
|
|
return 0; /* not handled */
|
|
|
|
}
|
|
|
|
return mv_handle_fbs_ncq_dev_err(ap);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* EDMA should have self-disabled for this case.
|
|
|
|
* If it did not, then something is wrong elsewhere,
|
|
|
|
* and we cannot handle it here.
|
|
|
|
*/
|
|
|
|
if (!(edma_err_cause & EDMA_ERR_SELF_DIS)) {
|
|
|
|
ata_port_printk(ap, KERN_WARNING,
|
|
|
|
"%s: err_cause=0x%x pp_flags=0x%x\n",
|
|
|
|
__func__, edma_err_cause, pp->pp_flags);
|
|
|
|
return 0; /* not handled */
|
|
|
|
}
|
|
|
|
return mv_handle_fbs_non_ncq_dev_err(ap);
|
|
|
|
}
|
|
|
|
return 0; /* not handled */
|
|
|
|
}
|
|
|
|
|
2008-05-02 06:14:02 +00:00
|
|
|
static void mv_unexpected_intr(struct ata_port *ap, int edma_was_enabled)
|
2008-04-19 18:53:07 +00:00
|
|
|
{
|
|
|
|
struct ata_eh_info *ehi = &ap->link.eh_info;
|
2008-05-02 06:14:02 +00:00
|
|
|
char *when = "idle";
|
2008-04-19 18:53:07 +00:00
|
|
|
|
|
|
|
ata_ehi_clear_desc(ehi);
|
2009-07-26 14:05:13 +00:00
|
|
|
if (ap->flags & ATA_FLAG_DISABLED) {
|
2008-05-02 06:14:02 +00:00
|
|
|
when = "disabled";
|
|
|
|
} else if (edma_was_enabled) {
|
|
|
|
when = "EDMA enabled";
|
2008-04-19 18:53:07 +00:00
|
|
|
} else {
|
|
|
|
struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
|
|
|
|
if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
|
2008-05-02 06:14:02 +00:00
|
|
|
when = "polling";
|
2008-04-19 18:53:07 +00:00
|
|
|
}
|
2008-05-02 06:14:02 +00:00
|
|
|
ata_ehi_push_desc(ehi, "unexpected device interrupt while %s", when);
|
2008-04-19 18:53:07 +00:00
|
|
|
ehi->err_mask |= AC_ERR_OTHER;
|
|
|
|
ehi->action |= ATA_EH_RESET;
|
|
|
|
ata_port_freeze(ap);
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_err_intr - Handle error interrupts on the port
|
|
|
|
* @ap: ATA channel to manipulate
|
|
|
|
*
|
2008-04-19 19:07:49 +00:00
|
|
|
* Most cases require a full reset of the chip's state machine,
|
|
|
|
* which also performs a COMRESET.
|
|
|
|
* Also, if the port disabled DMA, update our cached copy to match.
|
2005-10-05 21:08:53 +00:00
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2008-05-02 06:12:34 +00:00
|
|
|
static void mv_err_intr(struct ata_port *ap)
|
2005-09-30 05:36:00 +00:00
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
2007-07-12 18:34:26 +00:00
|
|
|
u32 edma_err_cause, eh_freeze_mask, serr = 0;
|
2008-05-14 13:19:30 +00:00
|
|
|
u32 fis_cause = 0;
|
2007-07-12 18:34:26 +00:00
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
|
|
|
unsigned int action = 0, err_mask = 0;
|
2007-08-06 09:36:22 +00:00
|
|
|
struct ata_eh_info *ehi = &ap->link.eh_info;
|
2008-05-02 06:12:34 +00:00
|
|
|
struct ata_queued_cmd *qc;
|
|
|
|
int abort = 0;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2008-04-19 19:07:49 +00:00
|
|
|
/*
|
2008-05-02 06:12:34 +00:00
|
|
|
* Read and clear the SError and err_cause bits.
|
2008-05-14 13:19:30 +00:00
|
|
|
* For GenIIe, if EDMA_ERR_TRANS_IRQ_7 is set, we also must read/clear
|
|
|
|
* the FIS_IRQ_CAUSE register before clearing edma_err_cause.
|
2008-04-19 19:07:49 +00:00
|
|
|
*/
|
2008-05-02 06:12:34 +00:00
|
|
|
sata_scr_read(&ap->link, SCR_ERROR, &serr);
|
|
|
|
sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE);
|
2008-05-14 13:19:30 +00:00
|
|
|
if (IS_GEN_IIE(hpriv) && (edma_err_cause & EDMA_ERR_TRANS_IRQ_7)) {
|
2009-04-06 20:43:45 +00:00
|
|
|
fis_cause = readl(port_mmio + FIS_IRQ_CAUSE);
|
|
|
|
writelfl(~fis_cause, port_mmio + FIS_IRQ_CAUSE);
|
2008-05-14 13:19:30 +00:00
|
|
|
}
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(~edma_err_cause, port_mmio + EDMA_ERR_IRQ_CAUSE);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-05-02 06:16:20 +00:00
|
|
|
if (edma_err_cause & EDMA_ERR_DEV) {
|
|
|
|
/*
|
|
|
|
* Device errors during FIS-based switching operation
|
|
|
|
* require special handling.
|
|
|
|
*/
|
|
|
|
if (mv_handle_dev_err(ap, edma_err_cause))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-05-02 06:12:34 +00:00
|
|
|
qc = mv_get_active_qc(ap);
|
|
|
|
ata_ehi_clear_desc(ehi);
|
|
|
|
ata_ehi_push_desc(ehi, "edma_err_cause=%08x pp_flags=%08x",
|
|
|
|
edma_err_cause, pp->pp_flags);
|
2008-05-14 13:19:30 +00:00
|
|
|
|
2008-05-14 13:24:39 +00:00
|
|
|
if (IS_GEN_IIE(hpriv) && (edma_err_cause & EDMA_ERR_TRANS_IRQ_7)) {
|
2008-05-14 13:19:30 +00:00
|
|
|
ata_ehi_push_desc(ehi, "fis_cause=%08x", fis_cause);
|
2009-04-06 20:43:45 +00:00
|
|
|
if (fis_cause & FIS_IRQ_CAUSE_AN) {
|
2008-05-14 13:24:39 +00:00
|
|
|
u32 ec = edma_err_cause &
|
|
|
|
~(EDMA_ERR_TRANS_IRQ_7 | EDMA_ERR_IRQ_TRANSIENT);
|
|
|
|
sata_async_notification(ap);
|
|
|
|
if (!ec)
|
|
|
|
return; /* Just an AN; no need for the nukes */
|
|
|
|
ata_ehi_push_desc(ehi, "SDB notify");
|
|
|
|
}
|
|
|
|
}
|
2007-07-12 18:34:26 +00:00
|
|
|
/*
|
2008-04-19 18:43:42 +00:00
|
|
|
* All generations share these EDMA error cause bits:
|
2007-07-12 18:34:26 +00:00
|
|
|
*/
|
2008-05-02 06:12:34 +00:00
|
|
|
if (edma_err_cause & EDMA_ERR_DEV) {
|
2007-07-12 18:34:26 +00:00
|
|
|
err_mask |= AC_ERR_DEV;
|
2008-05-02 06:12:34 +00:00
|
|
|
action |= ATA_EH_RESET;
|
|
|
|
ata_ehi_push_desc(ehi, "dev error");
|
|
|
|
}
|
2007-07-12 18:34:26 +00:00
|
|
|
if (edma_err_cause & (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR |
|
2007-07-13 19:20:15 +00:00
|
|
|
EDMA_ERR_CRQB_PAR | EDMA_ERR_CRPB_PAR |
|
2007-07-12 18:34:26 +00:00
|
|
|
EDMA_ERR_INTRL_PAR)) {
|
|
|
|
err_mask |= AC_ERR_ATA_BUS;
|
libata: prefer hardreset
When both soft and hard resets are available, libata preferred
softreset till now. The logic behind it was to be softer to devices;
however, this doesn't really help much. Rationales for the change:
* BIOS may freeze lock certain things during boot and softreset can't
unlock those. This by itself is okay but during operation PHY event
or other error conditions can trigger hardreset and the device may
end up with different configuration.
For example, after a hardreset, previously unlockable HPA can be
unlocked resulting in different device size and thus revalidation
failure. Similar condition can occur during or after resume.
* Certain ATAPI devices require hardreset to recover after certain
error conditions. On PATA, this is done by issuing the DEVICE RESET
command. On SATA, COMRESET has equivalent effect. The problem is
that DEVICE RESET needs its own execution protocol.
For SFF controllers with bare TF access, it can be easily
implemented but more advanced controllers (e.g. ahci and sata_sil24)
require specialized implementations. Simply using hardreset solves
the problem nicely.
* COMRESET initialization sequence is the norm in SATA land and many
SATA devices don't work properly if only SRST is used. For example,
some PMPs behave this way and libata works around by always issuing
hardreset if the host supports PMP.
Like the above example, libata has developed a number of mechanisms
aiming to promote softreset to hardreset if softreset is not going
to work. This approach is time consuming and error prone.
Also, note that, dependingon how you read the specs, it could be
argued that PMP fan-out ports require COMRESET to start operation.
In fact, all the PMPs on the market except one don't work properly
if COMRESET is not issued to fan-out ports after PMP reset.
* COMRESET is an integral part of SATA connection and any working
device should be able to handle COMRESET properly. After all, it's
the way to signal hardreset during reboot. This is the most used
and recommended (at least by the ahci spec) method of resetting
devices.
So, this patch makes libata prefer hardreset over softreset by making
the following changes.
* Rename ATA_EH_RESET_MASK to ATA_EH_RESET and use it whereever
ATA_EH_{SOFT|HARD}RESET used to be used. ATA_EH_{SOFT|HARD}RESET is
now only used to tell prereset whether soft or hard reset will be
issued.
* Strip out now unneeded promote-to-hardreset logics from
ata_eh_reset(), ata_std_prereset(), sata_pmp_std_prereset() and
other places.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-01-23 15:05:14 +00:00
|
|
|
action |= ATA_EH_RESET;
|
2007-07-16 05:29:39 +00:00
|
|
|
ata_ehi_push_desc(ehi, "parity error");
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
if (edma_err_cause & (EDMA_ERR_DEV_DCON | EDMA_ERR_DEV_CON)) {
|
|
|
|
ata_ehi_hotplugged(ehi);
|
|
|
|
ata_ehi_push_desc(ehi, edma_err_cause & EDMA_ERR_DEV_DCON ?
|
2007-07-16 05:29:39 +00:00
|
|
|
"dev disconnect" : "dev connect");
|
libata: prefer hardreset
When both soft and hard resets are available, libata preferred
softreset till now. The logic behind it was to be softer to devices;
however, this doesn't really help much. Rationales for the change:
* BIOS may freeze lock certain things during boot and softreset can't
unlock those. This by itself is okay but during operation PHY event
or other error conditions can trigger hardreset and the device may
end up with different configuration.
For example, after a hardreset, previously unlockable HPA can be
unlocked resulting in different device size and thus revalidation
failure. Similar condition can occur during or after resume.
* Certain ATAPI devices require hardreset to recover after certain
error conditions. On PATA, this is done by issuing the DEVICE RESET
command. On SATA, COMRESET has equivalent effect. The problem is
that DEVICE RESET needs its own execution protocol.
For SFF controllers with bare TF access, it can be easily
implemented but more advanced controllers (e.g. ahci and sata_sil24)
require specialized implementations. Simply using hardreset solves
the problem nicely.
* COMRESET initialization sequence is the norm in SATA land and many
SATA devices don't work properly if only SRST is used. For example,
some PMPs behave this way and libata works around by always issuing
hardreset if the host supports PMP.
Like the above example, libata has developed a number of mechanisms
aiming to promote softreset to hardreset if softreset is not going
to work. This approach is time consuming and error prone.
Also, note that, dependingon how you read the specs, it could be
argued that PMP fan-out ports require COMRESET to start operation.
In fact, all the PMPs on the market except one don't work properly
if COMRESET is not issued to fan-out ports after PMP reset.
* COMRESET is an integral part of SATA connection and any working
device should be able to handle COMRESET properly. After all, it's
the way to signal hardreset during reboot. This is the most used
and recommended (at least by the ahci spec) method of resetting
devices.
So, this patch makes libata prefer hardreset over softreset by making
the following changes.
* Rename ATA_EH_RESET_MASK to ATA_EH_RESET and use it whereever
ATA_EH_{SOFT|HARD}RESET used to be used. ATA_EH_{SOFT|HARD}RESET is
now only used to tell prereset whether soft or hard reset will be
issued.
* Strip out now unneeded promote-to-hardreset logics from
ata_eh_reset(), ata_std_prereset(), sata_pmp_std_prereset() and
other places.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-01-23 15:05:14 +00:00
|
|
|
action |= ATA_EH_RESET;
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
2008-04-19 18:43:42 +00:00
|
|
|
/*
|
|
|
|
* Gen-I has a different SELF_DIS bit,
|
|
|
|
* different FREEZE bits, and no SERR bit:
|
|
|
|
*/
|
2007-07-12 19:51:22 +00:00
|
|
|
if (IS_GEN_I(hpriv)) {
|
2007-07-12 18:34:26 +00:00
|
|
|
eh_freeze_mask = EDMA_EH_FREEZE_5;
|
|
|
|
if (edma_err_cause & EDMA_ERR_SELF_DIS_5) {
|
|
|
|
pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
|
2007-07-16 05:29:39 +00:00
|
|
|
ata_ehi_push_desc(ehi, "EDMA self-disable");
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
eh_freeze_mask = EDMA_EH_FREEZE;
|
|
|
|
if (edma_err_cause & EDMA_ERR_SELF_DIS) {
|
|
|
|
pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
|
2007-07-16 05:29:39 +00:00
|
|
|
ata_ehi_push_desc(ehi, "EDMA self-disable");
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
if (edma_err_cause & EDMA_ERR_SERR) {
|
2008-04-19 19:07:49 +00:00
|
|
|
ata_ehi_push_desc(ehi, "SError=%08x", serr);
|
|
|
|
err_mask |= AC_ERR_ATA_BUS;
|
libata: prefer hardreset
When both soft and hard resets are available, libata preferred
softreset till now. The logic behind it was to be softer to devices;
however, this doesn't really help much. Rationales for the change:
* BIOS may freeze lock certain things during boot and softreset can't
unlock those. This by itself is okay but during operation PHY event
or other error conditions can trigger hardreset and the device may
end up with different configuration.
For example, after a hardreset, previously unlockable HPA can be
unlocked resulting in different device size and thus revalidation
failure. Similar condition can occur during or after resume.
* Certain ATAPI devices require hardreset to recover after certain
error conditions. On PATA, this is done by issuing the DEVICE RESET
command. On SATA, COMRESET has equivalent effect. The problem is
that DEVICE RESET needs its own execution protocol.
For SFF controllers with bare TF access, it can be easily
implemented but more advanced controllers (e.g. ahci and sata_sil24)
require specialized implementations. Simply using hardreset solves
the problem nicely.
* COMRESET initialization sequence is the norm in SATA land and many
SATA devices don't work properly if only SRST is used. For example,
some PMPs behave this way and libata works around by always issuing
hardreset if the host supports PMP.
Like the above example, libata has developed a number of mechanisms
aiming to promote softreset to hardreset if softreset is not going
to work. This approach is time consuming and error prone.
Also, note that, dependingon how you read the specs, it could be
argued that PMP fan-out ports require COMRESET to start operation.
In fact, all the PMPs on the market except one don't work properly
if COMRESET is not issued to fan-out ports after PMP reset.
* COMRESET is an integral part of SATA connection and any working
device should be able to handle COMRESET properly. After all, it's
the way to signal hardreset during reboot. This is the most used
and recommended (at least by the ahci spec) method of resetting
devices.
So, this patch makes libata prefer hardreset over softreset by making
the following changes.
* Rename ATA_EH_RESET_MASK to ATA_EH_RESET and use it whereever
ATA_EH_{SOFT|HARD}RESET used to be used. ATA_EH_{SOFT|HARD}RESET is
now only used to tell prereset whether soft or hard reset will be
issued.
* Strip out now unneeded promote-to-hardreset logics from
ata_eh_reset(), ata_std_prereset(), sata_pmp_std_prereset() and
other places.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-01-23 15:05:14 +00:00
|
|
|
action |= ATA_EH_RESET;
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
2005-10-05 21:08:42 +00:00
|
|
|
}
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2007-07-12 18:34:26 +00:00
|
|
|
if (!err_mask) {
|
|
|
|
err_mask = AC_ERR_OTHER;
|
libata: prefer hardreset
When both soft and hard resets are available, libata preferred
softreset till now. The logic behind it was to be softer to devices;
however, this doesn't really help much. Rationales for the change:
* BIOS may freeze lock certain things during boot and softreset can't
unlock those. This by itself is okay but during operation PHY event
or other error conditions can trigger hardreset and the device may
end up with different configuration.
For example, after a hardreset, previously unlockable HPA can be
unlocked resulting in different device size and thus revalidation
failure. Similar condition can occur during or after resume.
* Certain ATAPI devices require hardreset to recover after certain
error conditions. On PATA, this is done by issuing the DEVICE RESET
command. On SATA, COMRESET has equivalent effect. The problem is
that DEVICE RESET needs its own execution protocol.
For SFF controllers with bare TF access, it can be easily
implemented but more advanced controllers (e.g. ahci and sata_sil24)
require specialized implementations. Simply using hardreset solves
the problem nicely.
* COMRESET initialization sequence is the norm in SATA land and many
SATA devices don't work properly if only SRST is used. For example,
some PMPs behave this way and libata works around by always issuing
hardreset if the host supports PMP.
Like the above example, libata has developed a number of mechanisms
aiming to promote softreset to hardreset if softreset is not going
to work. This approach is time consuming and error prone.
Also, note that, dependingon how you read the specs, it could be
argued that PMP fan-out ports require COMRESET to start operation.
In fact, all the PMPs on the market except one don't work properly
if COMRESET is not issued to fan-out ports after PMP reset.
* COMRESET is an integral part of SATA connection and any working
device should be able to handle COMRESET properly. After all, it's
the way to signal hardreset during reboot. This is the most used
and recommended (at least by the ahci spec) method of resetting
devices.
So, this patch makes libata prefer hardreset over softreset by making
the following changes.
* Rename ATA_EH_RESET_MASK to ATA_EH_RESET and use it whereever
ATA_EH_{SOFT|HARD}RESET used to be used. ATA_EH_{SOFT|HARD}RESET is
now only used to tell prereset whether soft or hard reset will be
issued.
* Strip out now unneeded promote-to-hardreset logics from
ata_eh_reset(), ata_std_prereset(), sata_pmp_std_prereset() and
other places.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-01-23 15:05:14 +00:00
|
|
|
action |= ATA_EH_RESET;
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ehi->serror |= serr;
|
|
|
|
ehi->action |= action;
|
|
|
|
|
|
|
|
if (qc)
|
|
|
|
qc->err_mask |= err_mask;
|
|
|
|
else
|
|
|
|
ehi->err_mask |= err_mask;
|
|
|
|
|
2008-05-02 06:12:34 +00:00
|
|
|
if (err_mask == AC_ERR_DEV) {
|
|
|
|
/*
|
|
|
|
* Cannot do ata_port_freeze() here,
|
|
|
|
* because it would kill PIO access,
|
|
|
|
* which is needed for further diagnosis.
|
|
|
|
*/
|
|
|
|
mv_eh_freeze(ap);
|
|
|
|
abort = 1;
|
|
|
|
} else if (edma_err_cause & eh_freeze_mask) {
|
|
|
|
/*
|
|
|
|
* Note to self: ata_port_freeze() calls ata_port_abort()
|
|
|
|
*/
|
2007-07-12 18:34:26 +00:00
|
|
|
ata_port_freeze(ap);
|
2008-05-02 06:12:34 +00:00
|
|
|
} else {
|
|
|
|
abort = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (abort) {
|
|
|
|
if (qc)
|
|
|
|
ata_link_abort(qc->dev->link);
|
|
|
|
else
|
|
|
|
ata_port_abort(ap);
|
|
|
|
}
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
2008-04-19 19:06:40 +00:00
|
|
|
static void mv_process_crpb_response(struct ata_port *ap,
|
|
|
|
struct mv_crpb *response, unsigned int tag, int ncq_enabled)
|
|
|
|
{
|
|
|
|
struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
|
|
|
|
|
|
|
|
if (qc) {
|
|
|
|
u8 ata_status;
|
|
|
|
u16 edma_status = le16_to_cpu(response->flags);
|
|
|
|
/*
|
|
|
|
* edma_status from a response queue entry:
|
2009-04-06 20:43:45 +00:00
|
|
|
* LSB is from EDMA_ERR_IRQ_CAUSE (non-NCQ only).
|
2008-04-19 19:06:40 +00:00
|
|
|
* MSB is saved ATA status from command completion.
|
|
|
|
*/
|
|
|
|
if (!ncq_enabled) {
|
|
|
|
u8 err_cause = edma_status & 0xff & ~EDMA_ERR_DEV;
|
|
|
|
if (err_cause) {
|
|
|
|
/*
|
|
|
|
* Error will be seen/handled by mv_err_intr().
|
|
|
|
* So do nothing at all here.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ata_status = edma_status >> CRPB_FLAG_STATUS_SHIFT;
|
2008-05-02 06:12:34 +00:00
|
|
|
if (!ac_err_mask(ata_status))
|
|
|
|
ata_qc_complete(qc);
|
|
|
|
/* else: leave it for mv_err_intr() */
|
2008-04-19 19:06:40 +00:00
|
|
|
} else {
|
|
|
|
ata_port_printk(ap, KERN_ERR, "%s: no qc for tag=%d\n",
|
|
|
|
__func__, tag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_process_crpb_entries(struct ata_port *ap, struct mv_port_priv *pp)
|
2007-07-12 18:34:26 +00:00
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
2008-04-19 19:06:40 +00:00
|
|
|
u32 in_index;
|
2007-07-12 18:34:26 +00:00
|
|
|
bool work_done = false;
|
2008-04-19 19:06:40 +00:00
|
|
|
int ncq_enabled = (pp->pp_flags & MV_PP_FLAG_NCQ_EN);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-04-19 19:06:40 +00:00
|
|
|
/* Get the hardware queue position index */
|
2009-04-06 20:43:45 +00:00
|
|
|
in_index = (readl(port_mmio + EDMA_RSP_Q_IN_PTR)
|
2007-07-12 18:34:26 +00:00
|
|
|
>> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
|
|
|
|
|
2008-04-19 19:06:40 +00:00
|
|
|
/* Process new responses from since the last time we looked */
|
|
|
|
while (in_index != pp->resp_idx) {
|
2007-07-13 19:20:15 +00:00
|
|
|
unsigned int tag;
|
2008-04-19 19:06:40 +00:00
|
|
|
struct mv_crpb *response = &pp->crpb[pp->resp_idx];
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-04-19 19:06:40 +00:00
|
|
|
pp->resp_idx = (pp->resp_idx + 1) & MV_MAX_Q_DEPTH_MASK;
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-04-19 19:06:40 +00:00
|
|
|
if (IS_GEN_I(hpriv)) {
|
|
|
|
/* 50xx: no NCQ, only one command active at a time */
|
2007-08-06 09:36:22 +00:00
|
|
|
tag = ap->link.active_tag;
|
2008-04-19 19:06:40 +00:00
|
|
|
} else {
|
|
|
|
/* Gen II/IIE: get command tag from CRPB entry */
|
|
|
|
tag = le16_to_cpu(response->id) & 0x1f;
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
2008-04-19 19:06:40 +00:00
|
|
|
mv_process_crpb_response(ap, response, tag, ncq_enabled);
|
2007-07-12 18:34:26 +00:00
|
|
|
work_done = true;
|
|
|
|
}
|
|
|
|
|
2008-04-19 18:43:42 +00:00
|
|
|
/* Update the software queue position index in hardware */
|
2007-07-12 18:34:26 +00:00
|
|
|
if (work_done)
|
|
|
|
writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) |
|
2008-04-19 19:06:40 +00:00
|
|
|
(pp->resp_idx << EDMA_RSP_Q_PTR_SHIFT),
|
2009-04-06 20:43:45 +00:00
|
|
|
port_mmio + EDMA_RSP_Q_OUT_PTR);
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-05-02 06:14:02 +00:00
|
|
|
static void mv_port_intr(struct ata_port *ap, u32 port_cause)
|
|
|
|
{
|
|
|
|
struct mv_port_priv *pp;
|
|
|
|
int edma_was_enabled;
|
|
|
|
|
|
|
|
if (!ap || (ap->flags & ATA_FLAG_DISABLED)) {
|
|
|
|
mv_unexpected_intr(ap, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Grab a snapshot of the EDMA_EN flag setting,
|
|
|
|
* so that we have a consistent view for this port,
|
|
|
|
* even if something we call of our routines changes it.
|
|
|
|
*/
|
|
|
|
pp = ap->private_data;
|
|
|
|
edma_was_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
|
|
|
|
/*
|
|
|
|
* Process completed CRPB response(s) before other events.
|
|
|
|
*/
|
|
|
|
if (edma_was_enabled && (port_cause & DONE_IRQ)) {
|
|
|
|
mv_process_crpb_entries(ap, pp);
|
2008-05-02 06:16:20 +00:00
|
|
|
if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH)
|
|
|
|
mv_handle_fbs_ncq_dev_err(ap);
|
2008-05-02 06:14:02 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Handle chip-reported errors, or continue on to handle PIO.
|
|
|
|
*/
|
|
|
|
if (unlikely(port_cause & ERR_IRQ)) {
|
|
|
|
mv_err_intr(ap);
|
|
|
|
} else if (!edma_was_enabled) {
|
|
|
|
struct ata_queued_cmd *qc = mv_get_active_qc(ap);
|
|
|
|
if (qc)
|
|
|
|
ata_sff_host_intr(ap, qc);
|
|
|
|
else
|
|
|
|
mv_unexpected_intr(ap, edma_was_enabled);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_host_intr - Handle all interrupts on the given host controller
|
2006-08-24 07:19:22 +00:00
|
|
|
* @host: host specific structure
|
2008-04-25 15:24:24 +00:00
|
|
|
* @main_irq_cause: Main interrupt cause register for the chip.
|
2005-10-05 21:08:53 +00:00
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2008-04-25 15:24:24 +00:00
|
|
|
static int mv_host_intr(struct ata_host *host, u32 main_irq_cause)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2008-02-01 23:08:03 +00:00
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
2008-05-02 06:13:27 +00:00
|
|
|
void __iomem *mmio = hpriv->base, *hc_mmio;
|
2008-04-19 19:07:18 +00:00
|
|
|
unsigned int handled = 0, port;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-03-11 02:01:17 +00:00
|
|
|
/* If asserted, clear the "all ports" IRQ coalescing bit */
|
|
|
|
if (main_irq_cause & ALL_PORTS_COAL_DONE)
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(~ALL_PORTS_COAL_IRQ, mmio + IRQ_COAL_CAUSE);
|
2009-03-11 02:01:17 +00:00
|
|
|
|
2008-04-19 19:07:18 +00:00
|
|
|
for (port = 0; port < hpriv->n_ports; port++) {
|
2006-08-24 07:19:22 +00:00
|
|
|
struct ata_port *ap = host->ports[port];
|
2008-05-02 06:13:27 +00:00
|
|
|
unsigned int p, shift, hardport, port_cause;
|
|
|
|
|
2008-04-19 19:07:18 +00:00
|
|
|
MV_PORT_TO_SHIFT_AND_HARDPORT(port, shift, hardport);
|
|
|
|
/*
|
2008-05-02 06:13:27 +00:00
|
|
|
* Each hc within the host has its own hc_irq_cause register,
|
|
|
|
* where the interrupting ports bits get ack'd.
|
2008-04-19 19:07:18 +00:00
|
|
|
*/
|
2008-05-02 06:13:27 +00:00
|
|
|
if (hardport == 0) { /* first port on this hc ? */
|
|
|
|
u32 hc_cause = (main_irq_cause >> shift) & HC0_IRQ_PEND;
|
|
|
|
u32 port_mask, ack_irqs;
|
|
|
|
/*
|
|
|
|
* Skip this entire hc if nothing pending for any ports
|
|
|
|
*/
|
|
|
|
if (!hc_cause) {
|
|
|
|
port += MV_PORTS_PER_HC - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We don't need/want to read the hc_irq_cause register,
|
|
|
|
* because doing so hurts performance, and
|
|
|
|
* main_irq_cause already gives us everything we need.
|
|
|
|
*
|
|
|
|
* But we do have to *write* to the hc_irq_cause to ack
|
|
|
|
* the ports that we are handling this time through.
|
|
|
|
*
|
|
|
|
* This requires that we create a bitmap for those
|
|
|
|
* ports which interrupted us, and use that bitmap
|
|
|
|
* to ack (only) those ports via hc_irq_cause.
|
|
|
|
*/
|
|
|
|
ack_irqs = 0;
|
2009-03-11 02:01:17 +00:00
|
|
|
if (hc_cause & PORTS_0_3_COAL_DONE)
|
|
|
|
ack_irqs = HC_COAL_IRQ;
|
2008-05-02 06:13:27 +00:00
|
|
|
for (p = 0; p < MV_PORTS_PER_HC; ++p) {
|
|
|
|
if ((port + p) >= hpriv->n_ports)
|
|
|
|
break;
|
|
|
|
port_mask = (DONE_IRQ | ERR_IRQ) << (p * 2);
|
|
|
|
if (hc_cause & port_mask)
|
|
|
|
ack_irqs |= (DMA_IRQ | DEV_IRQ) << p;
|
|
|
|
}
|
2008-04-19 19:07:18 +00:00
|
|
|
hc_mmio = mv_hc_base_from_port(mmio, port);
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(~ack_irqs, hc_mmio + HC_IRQ_CAUSE);
|
2008-04-19 19:07:18 +00:00
|
|
|
handled = 1;
|
|
|
|
}
|
2008-04-19 18:53:07 +00:00
|
|
|
/*
|
2008-05-02 06:14:02 +00:00
|
|
|
* Handle interrupts signalled for this port:
|
2008-04-19 18:53:07 +00:00
|
|
|
*/
|
2008-05-02 06:14:02 +00:00
|
|
|
port_cause = (main_irq_cause >> shift) & (DONE_IRQ | ERR_IRQ);
|
|
|
|
if (port_cause)
|
|
|
|
mv_port_intr(ap, port_cause);
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
2008-04-19 19:07:18 +00:00
|
|
|
return handled;
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-04-19 19:07:18 +00:00
|
|
|
static int mv_pci_error(struct ata_host *host, void __iomem *mmio)
|
2007-07-12 18:34:26 +00:00
|
|
|
{
|
2007-12-01 18:07:22 +00:00
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
2007-07-12 18:34:26 +00:00
|
|
|
struct ata_port *ap;
|
|
|
|
struct ata_queued_cmd *qc;
|
|
|
|
struct ata_eh_info *ehi;
|
|
|
|
unsigned int i, err_mask, printed = 0;
|
|
|
|
u32 err_cause;
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
err_cause = readl(mmio + hpriv->irq_cause_offset);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
|
|
|
dev_printk(KERN_ERR, host->dev, "PCI ERROR; PCI IRQ cause=0x%08x\n",
|
|
|
|
err_cause);
|
|
|
|
|
|
|
|
DPRINTK("All regs @ PCI error\n");
|
|
|
|
mv_dump_all_regs(mmio, -1, to_pci_dev(host->dev));
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(0, mmio + hpriv->irq_cause_offset);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
|
|
|
for (i = 0; i < host->n_ports; i++) {
|
|
|
|
ap = host->ports[i];
|
2007-08-06 09:36:23 +00:00
|
|
|
if (!ata_link_offline(&ap->link)) {
|
2007-08-06 09:36:22 +00:00
|
|
|
ehi = &ap->link.eh_info;
|
2007-07-12 18:34:26 +00:00
|
|
|
ata_ehi_clear_desc(ehi);
|
|
|
|
if (!printed++)
|
|
|
|
ata_ehi_push_desc(ehi,
|
|
|
|
"PCI err cause 0x%08x", err_cause);
|
|
|
|
err_mask = AC_ERR_HOST_BUS;
|
libata: prefer hardreset
When both soft and hard resets are available, libata preferred
softreset till now. The logic behind it was to be softer to devices;
however, this doesn't really help much. Rationales for the change:
* BIOS may freeze lock certain things during boot and softreset can't
unlock those. This by itself is okay but during operation PHY event
or other error conditions can trigger hardreset and the device may
end up with different configuration.
For example, after a hardreset, previously unlockable HPA can be
unlocked resulting in different device size and thus revalidation
failure. Similar condition can occur during or after resume.
* Certain ATAPI devices require hardreset to recover after certain
error conditions. On PATA, this is done by issuing the DEVICE RESET
command. On SATA, COMRESET has equivalent effect. The problem is
that DEVICE RESET needs its own execution protocol.
For SFF controllers with bare TF access, it can be easily
implemented but more advanced controllers (e.g. ahci and sata_sil24)
require specialized implementations. Simply using hardreset solves
the problem nicely.
* COMRESET initialization sequence is the norm in SATA land and many
SATA devices don't work properly if only SRST is used. For example,
some PMPs behave this way and libata works around by always issuing
hardreset if the host supports PMP.
Like the above example, libata has developed a number of mechanisms
aiming to promote softreset to hardreset if softreset is not going
to work. This approach is time consuming and error prone.
Also, note that, dependingon how you read the specs, it could be
argued that PMP fan-out ports require COMRESET to start operation.
In fact, all the PMPs on the market except one don't work properly
if COMRESET is not issued to fan-out ports after PMP reset.
* COMRESET is an integral part of SATA connection and any working
device should be able to handle COMRESET properly. After all, it's
the way to signal hardreset during reboot. This is the most used
and recommended (at least by the ahci spec) method of resetting
devices.
So, this patch makes libata prefer hardreset over softreset by making
the following changes.
* Rename ATA_EH_RESET_MASK to ATA_EH_RESET and use it whereever
ATA_EH_{SOFT|HARD}RESET used to be used. ATA_EH_{SOFT|HARD}RESET is
now only used to tell prereset whether soft or hard reset will be
issued.
* Strip out now unneeded promote-to-hardreset logics from
ata_eh_reset(), ata_std_prereset(), sata_pmp_std_prereset() and
other places.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-01-23 15:05:14 +00:00
|
|
|
ehi->action = ATA_EH_RESET;
|
2007-08-06 09:36:22 +00:00
|
|
|
qc = ata_qc_from_tag(ap, ap->link.active_tag);
|
2007-07-12 18:34:26 +00:00
|
|
|
if (qc)
|
|
|
|
qc->err_mask |= err_mask;
|
|
|
|
else
|
|
|
|
ehi->err_mask |= err_mask;
|
|
|
|
|
|
|
|
ata_port_freeze(ap);
|
|
|
|
}
|
|
|
|
}
|
2008-04-19 19:07:18 +00:00
|
|
|
return 1; /* handled */
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
2007-07-11 22:30:50 +00:00
|
|
|
* mv_interrupt - Main interrupt event handler
|
2005-10-05 21:08:53 +00:00
|
|
|
* @irq: unused
|
|
|
|
* @dev_instance: private data; in this case the host structure
|
|
|
|
*
|
|
|
|
* Read the read only register to determine if any host
|
|
|
|
* controllers have pending interrupts. If so, call lower level
|
|
|
|
* routine to handle. Also check for PCI errors which are only
|
|
|
|
* reported here.
|
|
|
|
*
|
2005-11-12 17:32:50 +00:00
|
|
|
* LOCKING:
|
2006-08-24 07:19:22 +00:00
|
|
|
* This routine holds the host lock while processing pending
|
2005-10-05 21:08:53 +00:00
|
|
|
* interrupts.
|
|
|
|
*/
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t mv_interrupt(int irq, void *dev_instance)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2006-08-24 07:19:22 +00:00
|
|
|
struct ata_host *host = dev_instance;
|
2008-02-01 23:08:03 +00:00
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
2008-04-19 19:07:18 +00:00
|
|
|
unsigned int handled = 0;
|
2009-01-21 15:31:29 +00:00
|
|
|
int using_msi = hpriv->hp_flags & MV_HP_FLAG_MSI;
|
2008-05-17 17:38:00 +00:00
|
|
|
u32 main_irq_cause, pending_irqs;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2008-01-26 23:30:37 +00:00
|
|
|
spin_lock(&host->lock);
|
2009-01-21 15:31:29 +00:00
|
|
|
|
|
|
|
/* for MSI: block new interrupts while in here */
|
|
|
|
if (using_msi)
|
2009-03-11 02:01:17 +00:00
|
|
|
mv_write_main_irq_mask(0, hpriv);
|
2009-01-21 15:31:29 +00:00
|
|
|
|
2008-04-25 15:24:24 +00:00
|
|
|
main_irq_cause = readl(hpriv->main_irq_cause_addr);
|
2008-05-17 17:38:00 +00:00
|
|
|
pending_irqs = main_irq_cause & hpriv->main_irq_mask;
|
2008-04-19 18:43:42 +00:00
|
|
|
/*
|
|
|
|
* Deal with cases where we either have nothing pending, or have read
|
|
|
|
* a bogus register value which can indicate HW removal or PCI fault.
|
2005-09-01 22:26:17 +00:00
|
|
|
*/
|
2008-05-17 17:37:07 +00:00
|
|
|
if (pending_irqs && main_irq_cause != 0xffffffffU) {
|
2008-05-27 21:54:48 +00:00
|
|
|
if (unlikely((pending_irqs & PCI_ERR) && !IS_SOC(hpriv)))
|
2008-04-19 19:07:18 +00:00
|
|
|
handled = mv_pci_error(host, hpriv->base);
|
|
|
|
else
|
2008-05-17 17:37:07 +00:00
|
|
|
handled = mv_host_intr(host, pending_irqs);
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
2009-01-21 15:31:29 +00:00
|
|
|
|
|
|
|
/* for MSI: unmask; interrupt cause bits will retrigger now */
|
|
|
|
if (using_msi)
|
2009-03-11 02:01:17 +00:00
|
|
|
mv_write_main_irq_mask(hpriv->main_irq_mask, hpriv);
|
2009-01-21 15:31:29 +00:00
|
|
|
|
2009-03-10 20:28:51 +00:00
|
|
|
spin_unlock(&host->lock);
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
return IRQ_RETVAL(handled);
|
|
|
|
}
|
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
static unsigned int mv5_scr_offset(unsigned int sc_reg_in)
|
|
|
|
{
|
|
|
|
unsigned int ofs;
|
|
|
|
|
|
|
|
switch (sc_reg_in) {
|
|
|
|
case SCR_STATUS:
|
|
|
|
case SCR_ERROR:
|
|
|
|
case SCR_CONTROL:
|
|
|
|
ofs = sc_reg_in * sizeof(u32);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ofs = 0xffffffffU;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ofs;
|
|
|
|
}
|
|
|
|
|
2008-07-31 08:02:40 +00:00
|
|
|
static int mv5_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val)
|
2005-11-13 22:47:51 +00:00
|
|
|
{
|
2008-07-31 08:02:40 +00:00
|
|
|
struct mv_host_priv *hpriv = link->ap->host->private_data;
|
2008-02-01 23:08:03 +00:00
|
|
|
void __iomem *mmio = hpriv->base;
|
2008-07-31 08:02:40 +00:00
|
|
|
void __iomem *addr = mv5_phy_base(mmio, link->ap->port_no);
|
2005-11-13 22:47:51 +00:00
|
|
|
unsigned int ofs = mv5_scr_offset(sc_reg_in);
|
|
|
|
|
2007-07-16 05:29:40 +00:00
|
|
|
if (ofs != 0xffffffffU) {
|
|
|
|
*val = readl(addr + ofs);
|
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -EINVAL;
|
2005-11-13 22:47:51 +00:00
|
|
|
}
|
|
|
|
|
2008-07-31 08:02:40 +00:00
|
|
|
static int mv5_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val)
|
2005-11-13 22:47:51 +00:00
|
|
|
{
|
2008-07-31 08:02:40 +00:00
|
|
|
struct mv_host_priv *hpriv = link->ap->host->private_data;
|
2008-02-01 23:08:03 +00:00
|
|
|
void __iomem *mmio = hpriv->base;
|
2008-07-31 08:02:40 +00:00
|
|
|
void __iomem *addr = mv5_phy_base(mmio, link->ap->port_no);
|
2005-11-13 22:47:51 +00:00
|
|
|
unsigned int ofs = mv5_scr_offset(sc_reg_in);
|
|
|
|
|
2007-07-16 05:29:40 +00:00
|
|
|
if (ofs != 0xffffffffU) {
|
2007-02-01 06:06:36 +00:00
|
|
|
writelfl(val, addr + ofs);
|
2007-07-16 05:29:40 +00:00
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -EINVAL;
|
2005-11-13 22:47:51 +00:00
|
|
|
}
|
|
|
|
|
2008-01-30 22:50:45 +00:00
|
|
|
static void mv5_reset_bus(struct ata_host *host, void __iomem *mmio)
|
2005-11-13 03:14:02 +00:00
|
|
|
{
|
2008-01-30 22:50:45 +00:00
|
|
|
struct pci_dev *pdev = to_pci_dev(host->dev);
|
2005-11-13 03:14:02 +00:00
|
|
|
int early_5080;
|
|
|
|
|
2007-06-08 22:46:36 +00:00
|
|
|
early_5080 = (pdev->device == 0x5080) && (pdev->revision == 0);
|
2005-11-13 03:14:02 +00:00
|
|
|
|
|
|
|
if (!early_5080) {
|
|
|
|
u32 tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
|
|
|
|
tmp |= (1 << 0);
|
|
|
|
writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
|
|
|
|
}
|
|
|
|
|
2008-01-30 22:50:45 +00:00
|
|
|
mv_reset_pci_bus(host, mmio);
|
2005-11-13 03:14:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
|
|
|
|
{
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0x0fcfffff, mmio + FLASH_CTL);
|
2005-11-13 03:14:02 +00:00
|
|
|
}
|
|
|
|
|
2005-11-13 02:13:17 +00:00
|
|
|
static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
|
2005-11-13 00:08:48 +00:00
|
|
|
void __iomem *mmio)
|
|
|
|
{
|
2005-11-13 22:47:51 +00:00
|
|
|
void __iomem *phy_mmio = mv5_phy_base(mmio, idx);
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
tmp = readl(phy_mmio + MV5_PHY_MODE);
|
|
|
|
|
|
|
|
hpriv->signal[idx].pre = tmp & 0x1800; /* bits 12:11 */
|
|
|
|
hpriv->signal[idx].amps = tmp & 0xe0; /* bits 7:5 */
|
2005-11-13 00:08:48 +00:00
|
|
|
}
|
|
|
|
|
2005-11-13 02:13:17 +00:00
|
|
|
static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
|
2005-11-13 00:08:48 +00:00
|
|
|
{
|
2005-11-13 03:14:02 +00:00
|
|
|
u32 tmp;
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0, mmio + GPIO_PORT_CTL);
|
2005-11-13 03:14:02 +00:00
|
|
|
|
|
|
|
/* FIXME: handle MV_HP_ERRATA_50XXB2 errata */
|
|
|
|
|
|
|
|
tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
|
|
|
|
tmp |= ~(1 << 0);
|
|
|
|
writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
|
2005-11-13 00:08:48 +00:00
|
|
|
}
|
|
|
|
|
2005-11-13 04:05:14 +00:00
|
|
|
static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int port)
|
2005-11-12 17:48:15 +00:00
|
|
|
{
|
2005-11-13 22:47:51 +00:00
|
|
|
void __iomem *phy_mmio = mv5_phy_base(mmio, port);
|
|
|
|
const u32 mask = (1<<12) | (1<<11) | (1<<7) | (1<<6) | (1<<5);
|
|
|
|
u32 tmp;
|
|
|
|
int fix_apm_sq = (hpriv->hp_flags & MV_HP_ERRATA_50XXB0);
|
|
|
|
|
|
|
|
if (fix_apm_sq) {
|
2009-04-06 20:43:45 +00:00
|
|
|
tmp = readl(phy_mmio + MV5_LTMODE);
|
2005-11-13 22:47:51 +00:00
|
|
|
tmp |= (1 << 19);
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(tmp, phy_mmio + MV5_LTMODE);
|
2005-11-13 22:47:51 +00:00
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
tmp = readl(phy_mmio + MV5_PHY_CTL);
|
2005-11-13 22:47:51 +00:00
|
|
|
tmp &= ~0x3;
|
|
|
|
tmp |= 0x1;
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(tmp, phy_mmio + MV5_PHY_CTL);
|
2005-11-13 22:47:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tmp = readl(phy_mmio + MV5_PHY_MODE);
|
|
|
|
tmp &= ~mask;
|
|
|
|
tmp |= hpriv->signal[port].pre;
|
|
|
|
tmp |= hpriv->signal[port].amps;
|
|
|
|
writel(tmp, phy_mmio + MV5_PHY_MODE);
|
2005-11-12 17:48:15 +00:00
|
|
|
}
|
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
|
|
|
|
#undef ZERO
|
|
|
|
#define ZERO(reg) writel(0, port_mmio + (reg))
|
|
|
|
static void mv5_reset_hc_port(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int port)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_port_base(mmio, port);
|
|
|
|
|
2008-03-31 23:33:56 +00:00
|
|
|
mv_reset_channel(hpriv, mmio, port);
|
2005-11-13 22:47:51 +00:00
|
|
|
|
|
|
|
ZERO(0x028); /* command */
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0x11f, port_mmio + EDMA_CFG);
|
2005-11-13 22:47:51 +00:00
|
|
|
ZERO(0x004); /* timer */
|
|
|
|
ZERO(0x008); /* irq err cause */
|
|
|
|
ZERO(0x00c); /* irq err mask */
|
|
|
|
ZERO(0x010); /* rq bah */
|
|
|
|
ZERO(0x014); /* rq inp */
|
|
|
|
ZERO(0x018); /* rq outp */
|
|
|
|
ZERO(0x01c); /* respq bah */
|
|
|
|
ZERO(0x024); /* respq outp */
|
|
|
|
ZERO(0x020); /* respq inp */
|
|
|
|
ZERO(0x02c); /* test control */
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
|
2005-11-13 22:47:51 +00:00
|
|
|
}
|
|
|
|
#undef ZERO
|
|
|
|
|
|
|
|
#define ZERO(reg) writel(0, hc_mmio + (reg))
|
|
|
|
static void mv5_reset_one_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int hc)
|
2005-11-13 02:13:17 +00:00
|
|
|
{
|
2005-11-13 22:47:51 +00:00
|
|
|
void __iomem *hc_mmio = mv_hc_base(mmio, hc);
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
ZERO(0x00c);
|
|
|
|
ZERO(0x010);
|
|
|
|
ZERO(0x014);
|
|
|
|
ZERO(0x018);
|
|
|
|
|
|
|
|
tmp = readl(hc_mmio + 0x20);
|
|
|
|
tmp &= 0x1c1c1c1c;
|
|
|
|
tmp |= 0x03030303;
|
|
|
|
writel(tmp, hc_mmio + 0x20);
|
|
|
|
}
|
|
|
|
#undef ZERO
|
|
|
|
|
|
|
|
static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int n_hc)
|
|
|
|
{
|
|
|
|
unsigned int hc, port;
|
|
|
|
|
|
|
|
for (hc = 0; hc < n_hc; hc++) {
|
|
|
|
for (port = 0; port < MV_PORTS_PER_HC; port++)
|
|
|
|
mv5_reset_hc_port(hpriv, mmio,
|
|
|
|
(hc * MV_PORTS_PER_HC) + port);
|
|
|
|
|
|
|
|
mv5_reset_one_hc(hpriv, mmio, hc);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2005-11-13 02:13:17 +00:00
|
|
|
}
|
|
|
|
|
2005-11-13 03:17:49 +00:00
|
|
|
#undef ZERO
|
|
|
|
#define ZERO(reg) writel(0, mmio + (reg))
|
2008-01-30 22:50:45 +00:00
|
|
|
static void mv_reset_pci_bus(struct ata_host *host, void __iomem *mmio)
|
2005-11-13 03:17:49 +00:00
|
|
|
{
|
2007-12-01 18:07:22 +00:00
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
2005-11-13 03:17:49 +00:00
|
|
|
u32 tmp;
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
tmp = readl(mmio + MV_PCI_MODE);
|
2005-11-13 03:17:49 +00:00
|
|
|
tmp &= 0xff00ffff;
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(tmp, mmio + MV_PCI_MODE);
|
2005-11-13 03:17:49 +00:00
|
|
|
|
|
|
|
ZERO(MV_PCI_DISC_TIMER);
|
|
|
|
ZERO(MV_PCI_MSI_TRIGGER);
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0x000100ff, mmio + MV_PCI_XBAR_TMOUT);
|
2005-11-13 03:17:49 +00:00
|
|
|
ZERO(MV_PCI_SERR_MASK);
|
2009-04-06 20:43:45 +00:00
|
|
|
ZERO(hpriv->irq_cause_offset);
|
|
|
|
ZERO(hpriv->irq_mask_offset);
|
2005-11-13 03:17:49 +00:00
|
|
|
ZERO(MV_PCI_ERR_LOW_ADDRESS);
|
|
|
|
ZERO(MV_PCI_ERR_HIGH_ADDRESS);
|
|
|
|
ZERO(MV_PCI_ERR_ATTRIBUTE);
|
|
|
|
ZERO(MV_PCI_ERR_COMMAND);
|
|
|
|
}
|
|
|
|
#undef ZERO
|
|
|
|
|
|
|
|
static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
|
|
|
|
{
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
mv5_reset_flash(hpriv, mmio);
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
tmp = readl(mmio + GPIO_PORT_CTL);
|
2005-11-13 03:17:49 +00:00
|
|
|
tmp &= 0x3;
|
|
|
|
tmp |= (1 << 5) | (1 << 6);
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(tmp, mmio + GPIO_PORT_CTL);
|
2005-11-13 03:17:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mv6_reset_hc - Perform the 6xxx global soft reset
|
|
|
|
* @mmio: base address of the HBA
|
|
|
|
*
|
|
|
|
* This routine only applies to 6xxx parts.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2005-11-13 22:47:51 +00:00
|
|
|
static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
|
|
|
|
unsigned int n_hc)
|
2005-11-13 03:17:49 +00:00
|
|
|
{
|
2009-04-06 20:43:45 +00:00
|
|
|
void __iomem *reg = mmio + PCI_MAIN_CMD_STS;
|
2005-11-13 03:17:49 +00:00
|
|
|
int i, rc = 0;
|
|
|
|
u32 t;
|
|
|
|
|
|
|
|
/* Following procedure defined in PCI "main command and status
|
|
|
|
* register" table.
|
|
|
|
*/
|
|
|
|
t = readl(reg);
|
|
|
|
writel(t | STOP_PCI_MASTER, reg);
|
|
|
|
|
|
|
|
for (i = 0; i < 1000; i++) {
|
|
|
|
udelay(1);
|
|
|
|
t = readl(reg);
|
2007-10-19 10:42:56 +00:00
|
|
|
if (PCI_MASTER_EMPTY & t)
|
2005-11-13 03:17:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!(PCI_MASTER_EMPTY & t)) {
|
|
|
|
printk(KERN_ERR DRV_NAME ": PCI master won't flush\n");
|
|
|
|
rc = 1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set reset */
|
|
|
|
i = 5;
|
|
|
|
do {
|
|
|
|
writel(t | GLOB_SFT_RST, reg);
|
|
|
|
t = readl(reg);
|
|
|
|
udelay(1);
|
|
|
|
} while (!(GLOB_SFT_RST & t) && (i-- > 0));
|
|
|
|
|
|
|
|
if (!(GLOB_SFT_RST & t)) {
|
|
|
|
printk(KERN_ERR DRV_NAME ": can't set global reset\n");
|
|
|
|
rc = 1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clear reset and *reenable the PCI master* (not mentioned in spec) */
|
|
|
|
i = 5;
|
|
|
|
do {
|
|
|
|
writel(t & ~(GLOB_SFT_RST | STOP_PCI_MASTER), reg);
|
|
|
|
t = readl(reg);
|
|
|
|
udelay(1);
|
|
|
|
} while ((GLOB_SFT_RST & t) && (i-- > 0));
|
|
|
|
|
|
|
|
if (GLOB_SFT_RST & t) {
|
|
|
|
printk(KERN_ERR DRV_NAME ": can't clear global reset\n");
|
|
|
|
rc = 1;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-11-13 02:13:17 +00:00
|
|
|
static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
|
2005-11-13 00:08:48 +00:00
|
|
|
void __iomem *mmio)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio;
|
|
|
|
u32 tmp;
|
|
|
|
|
2009-04-06 20:43:45 +00:00
|
|
|
tmp = readl(mmio + RESET_CFG);
|
2005-11-13 00:08:48 +00:00
|
|
|
if ((tmp & (1 << 0)) == 0) {
|
2005-11-13 02:13:17 +00:00
|
|
|
hpriv->signal[idx].amps = 0x7 << 8;
|
2005-11-13 00:08:48 +00:00
|
|
|
hpriv->signal[idx].pre = 0x1 << 5;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
port_mmio = mv_port_base(mmio, idx);
|
|
|
|
tmp = readl(port_mmio + PHY_MODE2);
|
|
|
|
|
|
|
|
hpriv->signal[idx].amps = tmp & 0x700; /* bits 10:8 */
|
|
|
|
hpriv->signal[idx].pre = tmp & 0xe0; /* bits 7:5 */
|
|
|
|
}
|
|
|
|
|
2005-11-13 02:13:17 +00:00
|
|
|
static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
|
2005-11-13 00:08:48 +00:00
|
|
|
{
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0x00000060, mmio + GPIO_PORT_CTL);
|
2005-11-13 00:08:48 +00:00
|
|
|
}
|
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
|
2005-11-13 04:05:14 +00:00
|
|
|
unsigned int port)
|
2005-11-12 17:48:15 +00:00
|
|
|
{
|
2005-11-13 22:47:51 +00:00
|
|
|
void __iomem *port_mmio = mv_port_base(mmio, port);
|
|
|
|
|
2005-11-12 17:48:15 +00:00
|
|
|
u32 hp_flags = hpriv->hp_flags;
|
2005-11-13 02:13:17 +00:00
|
|
|
int fix_phy_mode2 =
|
|
|
|
hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
|
2005-11-12 17:48:15 +00:00
|
|
|
int fix_phy_mode4 =
|
2005-11-13 02:13:17 +00:00
|
|
|
hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
|
2008-05-27 21:56:31 +00:00
|
|
|
u32 m2, m3;
|
2005-11-13 02:13:17 +00:00
|
|
|
|
|
|
|
if (fix_phy_mode2) {
|
|
|
|
m2 = readl(port_mmio + PHY_MODE2);
|
|
|
|
m2 &= ~(1 << 16);
|
|
|
|
m2 |= (1 << 31);
|
|
|
|
writel(m2, port_mmio + PHY_MODE2);
|
|
|
|
|
|
|
|
udelay(200);
|
|
|
|
|
|
|
|
m2 = readl(port_mmio + PHY_MODE2);
|
|
|
|
m2 &= ~((1 << 16) | (1 << 31));
|
|
|
|
writel(m2, port_mmio + PHY_MODE2);
|
|
|
|
|
|
|
|
udelay(200);
|
|
|
|
}
|
|
|
|
|
2008-05-27 21:56:31 +00:00
|
|
|
/*
|
|
|
|
* Gen-II/IIe PHY_MODE3 errata RM#2:
|
|
|
|
* Achieves better receiver noise performance than the h/w default:
|
|
|
|
*/
|
|
|
|
m3 = readl(port_mmio + PHY_MODE3);
|
|
|
|
m3 = (m3 & 0x1f) | (0x5555601 << 5);
|
2005-11-12 17:48:15 +00:00
|
|
|
|
2008-05-28 17:41:52 +00:00
|
|
|
/* Guideline 88F5182 (GL# SATA-S11) */
|
|
|
|
if (IS_SOC(hpriv))
|
|
|
|
m3 &= ~0x1c;
|
|
|
|
|
2005-11-12 17:48:15 +00:00
|
|
|
if (fix_phy_mode4) {
|
2008-05-31 20:46:34 +00:00
|
|
|
u32 m4 = readl(port_mmio + PHY_MODE4);
|
|
|
|
/*
|
|
|
|
* Enforce reserved-bit restrictions on GenIIe devices only.
|
|
|
|
* For earlier chipsets, force only the internal config field
|
|
|
|
* (workaround for errata FEr SATA#10 part 1).
|
|
|
|
*/
|
2008-05-27 21:56:31 +00:00
|
|
|
if (IS_GEN_IIE(hpriv))
|
2008-05-31 20:46:34 +00:00
|
|
|
m4 = (m4 & ~PHY_MODE4_RSVD_ZEROS) | PHY_MODE4_RSVD_ONES;
|
|
|
|
else
|
|
|
|
m4 = (m4 & ~PHY_MODE4_CFG_MASK) | PHY_MODE4_CFG_VALUE;
|
2008-05-27 21:56:31 +00:00
|
|
|
writel(m4, port_mmio + PHY_MODE4);
|
2005-11-12 17:48:15 +00:00
|
|
|
}
|
2008-05-28 16:01:12 +00:00
|
|
|
/*
|
|
|
|
* Workaround for 60x1-B2 errata SATA#13:
|
|
|
|
* Any write to PHY_MODE4 (above) may corrupt PHY_MODE3,
|
|
|
|
* so we must always rewrite PHY_MODE3 after PHY_MODE4.
|
2009-04-06 19:25:39 +00:00
|
|
|
* Or ensure we use writelfl() when writing PHY_MODE4.
|
2008-05-28 16:01:12 +00:00
|
|
|
*/
|
|
|
|
writel(m3, port_mmio + PHY_MODE3);
|
2005-11-12 17:48:15 +00:00
|
|
|
|
|
|
|
/* Revert values of pre-emphasis and signal amps to the saved ones */
|
|
|
|
m2 = readl(port_mmio + PHY_MODE2);
|
|
|
|
|
|
|
|
m2 &= ~MV_M2_PREAMP_MASK;
|
2005-11-13 04:05:14 +00:00
|
|
|
m2 |= hpriv->signal[port].amps;
|
|
|
|
m2 |= hpriv->signal[port].pre;
|
2005-11-13 02:13:17 +00:00
|
|
|
m2 &= ~(1 << 16);
|
2005-11-12 17:48:15 +00:00
|
|
|
|
2006-01-31 17:18:41 +00:00
|
|
|
/* according to mvSata 3.6.1, some IIE values are fixed */
|
|
|
|
if (IS_GEN_IIE(hpriv)) {
|
|
|
|
m2 &= ~0xC30FF01F;
|
|
|
|
m2 |= 0x0000900F;
|
|
|
|
}
|
|
|
|
|
2005-11-12 17:48:15 +00:00
|
|
|
writel(m2, port_mmio + PHY_MODE2);
|
|
|
|
}
|
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
/* TODO: use the generic LED interface to configure the SATA Presence */
|
|
|
|
/* & Acitivy LEDs on the board */
|
|
|
|
static void mv_soc_enable_leds(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_soc_read_preamp(struct mv_host_priv *hpriv, int idx,
|
|
|
|
void __iomem *mmio)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio;
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
port_mmio = mv_port_base(mmio, idx);
|
|
|
|
tmp = readl(port_mmio + PHY_MODE2);
|
|
|
|
|
|
|
|
hpriv->signal[idx].amps = tmp & 0x700; /* bits 10:8 */
|
|
|
|
hpriv->signal[idx].pre = tmp & 0xe0; /* bits 7:5 */
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef ZERO
|
|
|
|
#define ZERO(reg) writel(0, port_mmio + (reg))
|
|
|
|
static void mv_soc_reset_hc_port(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio, unsigned int port)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_port_base(mmio, port);
|
|
|
|
|
2008-03-31 23:33:56 +00:00
|
|
|
mv_reset_channel(hpriv, mmio, port);
|
2008-02-01 23:08:03 +00:00
|
|
|
|
|
|
|
ZERO(0x028); /* command */
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0x101f, port_mmio + EDMA_CFG);
|
2008-02-01 23:08:03 +00:00
|
|
|
ZERO(0x004); /* timer */
|
|
|
|
ZERO(0x008); /* irq err cause */
|
|
|
|
ZERO(0x00c); /* irq err mask */
|
|
|
|
ZERO(0x010); /* rq bah */
|
|
|
|
ZERO(0x014); /* rq inp */
|
|
|
|
ZERO(0x018); /* rq outp */
|
|
|
|
ZERO(0x01c); /* respq bah */
|
|
|
|
ZERO(0x024); /* respq outp */
|
|
|
|
ZERO(0x020); /* respq inp */
|
|
|
|
ZERO(0x02c); /* test control */
|
2009-12-06 16:26:17 +00:00
|
|
|
writel(0x800, port_mmio + EDMA_IORDY_TMOUT);
|
2008-02-01 23:08:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#undef ZERO
|
|
|
|
|
|
|
|
#define ZERO(reg) writel(0, hc_mmio + (reg))
|
|
|
|
static void mv_soc_reset_one_hc(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio)
|
|
|
|
{
|
|
|
|
void __iomem *hc_mmio = mv_hc_base(mmio, 0);
|
|
|
|
|
|
|
|
ZERO(0x00c);
|
|
|
|
ZERO(0x010);
|
|
|
|
ZERO(0x014);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef ZERO
|
|
|
|
|
|
|
|
static int mv_soc_reset_hc(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio, unsigned int n_hc)
|
|
|
|
{
|
|
|
|
unsigned int port;
|
|
|
|
|
|
|
|
for (port = 0; port < hpriv->n_ports; port++)
|
|
|
|
mv_soc_reset_hc_port(hpriv, mmio, port);
|
|
|
|
|
|
|
|
mv_soc_reset_one_hc(hpriv, mmio);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_soc_reset_flash(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_soc_reset_bus(struct ata_host *host, void __iomem *mmio)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-05-04 18:58:50 +00:00
|
|
|
static void mv_soc_65n_phy_errata(struct mv_host_priv *hpriv,
|
|
|
|
void __iomem *mmio, unsigned int port)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_port_base(mmio, port);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
reg = readl(port_mmio + PHY_MODE3);
|
|
|
|
reg &= ~(0x3 << 27); /* SELMUPF (bits 28:27) to 1 */
|
|
|
|
reg |= (0x1 << 27);
|
|
|
|
reg &= ~(0x3 << 29); /* SELMUPI (bits 30:29) to 1 */
|
|
|
|
reg |= (0x1 << 29);
|
|
|
|
writel(reg, port_mmio + PHY_MODE3);
|
|
|
|
|
|
|
|
reg = readl(port_mmio + PHY_MODE4);
|
|
|
|
reg &= ~0x1; /* SATU_OD8 (bit 0) to 0, reserved bit 16 must be set */
|
|
|
|
reg |= (0x1 << 16);
|
|
|
|
writel(reg, port_mmio + PHY_MODE4);
|
|
|
|
|
|
|
|
reg = readl(port_mmio + PHY_MODE9_GEN2);
|
|
|
|
reg &= ~0xf; /* TXAMP[3:0] (bits 3:0) to 8 */
|
|
|
|
reg |= 0x8;
|
|
|
|
reg &= ~(0x1 << 14); /* TXAMP[4] (bit 14) to 0 */
|
|
|
|
writel(reg, port_mmio + PHY_MODE9_GEN2);
|
|
|
|
|
|
|
|
reg = readl(port_mmio + PHY_MODE9_GEN1);
|
|
|
|
reg &= ~0xf; /* TXAMP[3:0] (bits 3:0) to 8 */
|
|
|
|
reg |= 0x8;
|
|
|
|
reg &= ~(0x1 << 14); /* TXAMP[4] (bit 14) to 0 */
|
|
|
|
writel(reg, port_mmio + PHY_MODE9_GEN1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* soc_is_65 - check if the soc is 65 nano device
|
|
|
|
*
|
|
|
|
* Detect the type of the SoC, this is done by reading the PHYCFG_OFS
|
|
|
|
* register, this register should contain non-zero value and it exists only
|
|
|
|
* in the 65 nano devices, when reading it from older devices we get 0.
|
|
|
|
*/
|
|
|
|
static bool soc_is_65n(struct mv_host_priv *hpriv)
|
|
|
|
{
|
|
|
|
void __iomem *port0_mmio = mv_port_base(hpriv->base, 0);
|
|
|
|
|
|
|
|
if (readl(port0_mmio + PHYCFG_OFS))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-05-02 06:07:51 +00:00
|
|
|
static void mv_setup_ifcfg(void __iomem *port_mmio, int want_gen2i)
|
2008-03-31 23:35:13 +00:00
|
|
|
{
|
2009-04-06 20:43:45 +00:00
|
|
|
u32 ifcfg = readl(port_mmio + SATA_IFCFG);
|
2008-03-31 23:35:13 +00:00
|
|
|
|
2008-05-02 06:07:51 +00:00
|
|
|
ifcfg = (ifcfg & 0xf7f) | 0x9b1000; /* from chip spec */
|
2008-03-31 23:35:13 +00:00
|
|
|
if (want_gen2i)
|
2008-05-02 06:07:51 +00:00
|
|
|
ifcfg |= (1 << 7); /* enable gen2i speed */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(ifcfg, port_mmio + SATA_IFCFG);
|
2008-03-31 23:35:13 +00:00
|
|
|
}
|
|
|
|
|
2008-03-31 23:33:56 +00:00
|
|
|
static void mv_reset_channel(struct mv_host_priv *hpriv, void __iomem *mmio,
|
2005-11-13 22:47:51 +00:00
|
|
|
unsigned int port_no)
|
|
|
|
{
|
|
|
|
void __iomem *port_mmio = mv_port_base(mmio, port_no);
|
|
|
|
|
2008-05-02 06:07:51 +00:00
|
|
|
/*
|
|
|
|
* The datasheet warns against setting EDMA_RESET when EDMA is active
|
|
|
|
* (but doesn't say what the problem might be). So we first try
|
|
|
|
* to disable the EDMA engine before doing the EDMA_RESET operation.
|
|
|
|
*/
|
2008-04-16 18:56:12 +00:00
|
|
|
mv_stop_edma_engine(port_mmio);
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(EDMA_RESET, port_mmio + EDMA_CMD);
|
2005-11-13 22:47:51 +00:00
|
|
|
|
2008-03-31 23:35:13 +00:00
|
|
|
if (!IS_GEN_I(hpriv)) {
|
2008-05-02 06:07:51 +00:00
|
|
|
/* Enable 3.0gb/s link speed: this survives EDMA_RESET */
|
|
|
|
mv_setup_ifcfg(port_mmio, 1);
|
2005-11-13 22:47:51 +00:00
|
|
|
}
|
2008-03-31 23:35:13 +00:00
|
|
|
/*
|
2008-05-02 06:07:51 +00:00
|
|
|
* Strobing EDMA_RESET here causes a hard reset of the SATA transport,
|
2008-03-31 23:35:13 +00:00
|
|
|
* link, and physical layers. It resets all SATA interface registers
|
2009-04-06 20:43:45 +00:00
|
|
|
* (except for SATA_IFCFG), and issues a COMRESET to the dev.
|
2005-11-13 22:47:51 +00:00
|
|
|
*/
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(EDMA_RESET, port_mmio + EDMA_CMD);
|
2008-03-31 23:35:13 +00:00
|
|
|
udelay(25); /* allow reset propagation */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(0, port_mmio + EDMA_CMD);
|
2005-11-13 22:47:51 +00:00
|
|
|
|
|
|
|
hpriv->ops->phy_errata(hpriv, mmio, port_no);
|
|
|
|
|
2007-07-12 19:51:22 +00:00
|
|
|
if (IS_GEN_I(hpriv))
|
2005-11-13 22:47:51 +00:00
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
|
2008-04-16 18:59:07 +00:00
|
|
|
static void mv_pmp_select(struct ata_port *ap, int pmp)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2008-04-16 18:59:07 +00:00
|
|
|
if (sata_pmp_supported(ap)) {
|
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
2009-04-06 20:43:45 +00:00
|
|
|
u32 reg = readl(port_mmio + SATA_IFCTL);
|
2008-04-16 18:59:07 +00:00
|
|
|
int old = reg & 0xf;
|
2005-11-17 15:59:48 +00:00
|
|
|
|
2008-04-16 18:59:07 +00:00
|
|
|
if (old != pmp) {
|
|
|
|
reg = (reg & ~0xf) | pmp;
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(reg, port_mmio + SATA_IFCTL);
|
2008-04-16 18:59:07 +00:00
|
|
|
}
|
2005-11-17 15:59:48 +00:00
|
|
|
}
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-04-16 18:59:07 +00:00
|
|
|
static int mv_pmp_hardreset(struct ata_link *link, unsigned int *class,
|
|
|
|
unsigned long deadline)
|
2005-11-17 15:59:48 +00:00
|
|
|
{
|
2008-04-16 18:59:07 +00:00
|
|
|
mv_pmp_select(link->ap, sata_srst_pmp(link));
|
|
|
|
return sata_std_hardreset(link, class, deadline);
|
|
|
|
}
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-04-16 18:59:07 +00:00
|
|
|
static int mv_softreset(struct ata_link *link, unsigned int *class,
|
|
|
|
unsigned long deadline)
|
|
|
|
{
|
|
|
|
mv_pmp_select(link->ap, sata_srst_pmp(link));
|
|
|
|
return ata_sff_softreset(link, class, deadline);
|
2005-11-17 15:59:48 +00:00
|
|
|
}
|
|
|
|
|
2007-08-06 09:36:23 +00:00
|
|
|
static int mv_hardreset(struct ata_link *link, unsigned int *class,
|
2007-07-12 18:34:26 +00:00
|
|
|
unsigned long deadline)
|
2005-09-30 05:36:00 +00:00
|
|
|
{
|
2007-08-06 09:36:23 +00:00
|
|
|
struct ata_port *ap = link->ap;
|
2007-07-12 18:34:26 +00:00
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
2008-03-31 23:34:40 +00:00
|
|
|
struct mv_port_priv *pp = ap->private_data;
|
2008-02-01 23:08:03 +00:00
|
|
|
void __iomem *mmio = hpriv->base;
|
2008-04-16 18:56:12 +00:00
|
|
|
int rc, attempts = 0, extra = 0;
|
|
|
|
u32 sstatus;
|
|
|
|
bool online;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2008-03-31 23:33:56 +00:00
|
|
|
mv_reset_channel(hpriv, mmio, ap->port_no);
|
2008-03-31 23:34:40 +00:00
|
|
|
pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
|
2009-02-25 20:17:43 +00:00
|
|
|
pp->pp_flags &=
|
|
|
|
~(MV_PP_FLAG_FBS_EN | MV_PP_FLAG_NCQ_EN | MV_PP_FLAG_FAKE_ATA_BUSY);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-04-16 18:56:12 +00:00
|
|
|
/* Workaround for errata FEr SATA#10 (part 2) */
|
|
|
|
do {
|
2008-04-16 18:56:51 +00:00
|
|
|
const unsigned long *timing =
|
|
|
|
sata_ehc_deb_timing(&link->eh_context);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-04-16 18:56:51 +00:00
|
|
|
rc = sata_link_hardreset(link, timing, deadline + extra,
|
|
|
|
&online, NULL);
|
2008-05-14 13:18:12 +00:00
|
|
|
rc = online ? -EAGAIN : rc;
|
2008-04-16 18:56:51 +00:00
|
|
|
if (rc)
|
2008-04-16 18:56:12 +00:00
|
|
|
return rc;
|
|
|
|
sata_scr_read(link, SCR_STATUS, &sstatus);
|
|
|
|
if (!IS_GEN_I(hpriv) && ++attempts >= 5 && sstatus == 0x121) {
|
|
|
|
/* Force 1.5gb/s link speed and try again */
|
2008-05-02 06:07:51 +00:00
|
|
|
mv_setup_ifcfg(mv_ap_base(ap), 0);
|
2008-04-16 18:56:12 +00:00
|
|
|
if (time_after(jiffies + HZ, deadline))
|
|
|
|
extra = HZ; /* only extend it once, max */
|
|
|
|
}
|
|
|
|
} while (sstatus != 0x0 && sstatus != 0x113 && sstatus != 0x123);
|
2009-02-25 20:13:03 +00:00
|
|
|
mv_save_cached_regs(ap);
|
2009-01-30 23:52:58 +00:00
|
|
|
mv_edma_cfg(ap, 0, 0);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-04-16 18:56:51 +00:00
|
|
|
return rc;
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_eh_freeze(struct ata_port *ap)
|
|
|
|
{
|
2008-04-19 19:05:50 +00:00
|
|
|
mv_stop_edma(ap);
|
2008-05-17 17:35:21 +00:00
|
|
|
mv_enable_port_irqs(ap, 0);
|
2007-07-12 18:34:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mv_eh_thaw(struct ata_port *ap)
|
|
|
|
{
|
2008-02-01 23:08:03 +00:00
|
|
|
struct mv_host_priv *hpriv = ap->host->private_data;
|
2008-05-17 17:35:21 +00:00
|
|
|
unsigned int port = ap->port_no;
|
|
|
|
unsigned int hardport = mv_hardport_from_port(port);
|
2008-04-19 19:05:50 +00:00
|
|
|
void __iomem *hc_mmio = mv_hc_base_from_port(hpriv->base, port);
|
2007-07-12 18:34:26 +00:00
|
|
|
void __iomem *port_mmio = mv_ap_base(ap);
|
2008-05-17 17:35:21 +00:00
|
|
|
u32 hc_irq_cause;
|
2007-07-12 18:34:26 +00:00
|
|
|
|
|
|
|
/* clear EDMA errors on this port */
|
2009-04-06 20:43:45 +00:00
|
|
|
writel(0, port_mmio + EDMA_ERR_IRQ_CAUSE);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
|
|
|
/* clear pending irq events */
|
2009-01-19 23:05:42 +00:00
|
|
|
hc_irq_cause = ~((DEV_IRQ | DMA_IRQ) << hardport);
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE);
|
2007-07-12 18:34:26 +00:00
|
|
|
|
2008-05-17 17:36:30 +00:00
|
|
|
mv_enable_port_irqs(ap, ERR_IRQ);
|
2005-09-30 05:36:00 +00:00
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_port_init - Perform some early initialization on a single port.
|
|
|
|
* @port: libata data structure storing shadow register addresses
|
|
|
|
* @port_mmio: base address of the port
|
|
|
|
*
|
|
|
|
* Initialize shadow register mmio addresses, clear outstanding
|
|
|
|
* interrupts on the port, and unmask interrupts for the future
|
|
|
|
* start of the port.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2005-09-30 05:36:00 +00:00
|
|
|
static void mv_port_init(struct ata_ioports *port, void __iomem *port_mmio)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2009-04-06 20:43:45 +00:00
|
|
|
void __iomem *serr, *shd_base = port_mmio + SHD_BLK;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2005-11-12 17:32:50 +00:00
|
|
|
/* PIO related setup
|
2005-09-30 05:36:00 +00:00
|
|
|
*/
|
|
|
|
port->data_addr = shd_base + (sizeof(u32) * ATA_REG_DATA);
|
2005-11-12 17:32:50 +00:00
|
|
|
port->error_addr =
|
2005-09-30 05:36:00 +00:00
|
|
|
port->feature_addr = shd_base + (sizeof(u32) * ATA_REG_ERR);
|
|
|
|
port->nsect_addr = shd_base + (sizeof(u32) * ATA_REG_NSECT);
|
|
|
|
port->lbal_addr = shd_base + (sizeof(u32) * ATA_REG_LBAL);
|
|
|
|
port->lbam_addr = shd_base + (sizeof(u32) * ATA_REG_LBAM);
|
|
|
|
port->lbah_addr = shd_base + (sizeof(u32) * ATA_REG_LBAH);
|
|
|
|
port->device_addr = shd_base + (sizeof(u32) * ATA_REG_DEVICE);
|
2005-11-12 17:32:50 +00:00
|
|
|
port->status_addr =
|
2005-09-30 05:36:00 +00:00
|
|
|
port->command_addr = shd_base + (sizeof(u32) * ATA_REG_STATUS);
|
|
|
|
/* special case: control/altstatus doesn't have ATA_REG_ address */
|
2009-04-06 20:43:45 +00:00
|
|
|
port->altstatus_addr = port->ctl_addr = shd_base + SHD_CTL_AST;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
|
|
|
/* unused: */
|
2007-02-16 09:40:06 +00:00
|
|
|
port->cmd_addr = port->bmdma_addr = port->scr_addr = NULL;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
/* Clear any currently outstanding port interrupt conditions */
|
2009-04-06 20:43:45 +00:00
|
|
|
serr = port_mmio + mv_scr_offset(SCR_ERROR);
|
|
|
|
writelfl(readl(serr), serr);
|
|
|
|
writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE);
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2008-01-26 23:30:37 +00:00
|
|
|
/* unmask all non-transient EDMA error interrupts */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(~EDMA_ERR_IRQ_TRANSIENT, port_mmio + EDMA_ERR_IRQ_MASK);
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-11-12 17:32:50 +00:00
|
|
|
VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n",
|
2009-04-06 20:43:45 +00:00
|
|
|
readl(port_mmio + EDMA_CFG),
|
|
|
|
readl(port_mmio + EDMA_ERR_IRQ_CAUSE),
|
|
|
|
readl(port_mmio + EDMA_ERR_IRQ_MASK));
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-05-02 06:08:32 +00:00
|
|
|
static unsigned int mv_in_pcix_mode(struct ata_host *host)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
void __iomem *mmio = hpriv->base;
|
|
|
|
u32 reg;
|
|
|
|
|
2008-05-27 21:54:48 +00:00
|
|
|
if (IS_SOC(hpriv) || !IS_PCIE(hpriv))
|
2008-05-02 06:08:32 +00:00
|
|
|
return 0; /* not PCI-X capable */
|
2009-04-06 20:43:45 +00:00
|
|
|
reg = readl(mmio + MV_PCI_MODE);
|
2008-05-02 06:08:32 +00:00
|
|
|
if ((reg & MV_PCI_MODE_MASK) == 0)
|
|
|
|
return 0; /* conventional PCI mode */
|
|
|
|
return 1; /* chip is in PCI-X mode */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mv_pci_cut_through_okay(struct ata_host *host)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
void __iomem *mmio = hpriv->base;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
if (!mv_in_pcix_mode(host)) {
|
2009-04-06 20:43:45 +00:00
|
|
|
reg = readl(mmio + MV_PCI_COMMAND);
|
|
|
|
if (reg & MV_PCI_COMMAND_MRDTRIG)
|
2008-05-02 06:08:32 +00:00
|
|
|
return 0; /* not okay */
|
|
|
|
}
|
|
|
|
return 1; /* okay */
|
|
|
|
}
|
|
|
|
|
2009-04-06 19:24:14 +00:00
|
|
|
static void mv_60x1b2_errata_pci7(struct ata_host *host)
|
|
|
|
{
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
void __iomem *mmio = hpriv->base;
|
|
|
|
|
|
|
|
/* workaround for 60x1-B2 errata PCI#7 */
|
|
|
|
if (mv_in_pcix_mode(host)) {
|
2009-04-06 20:43:45 +00:00
|
|
|
u32 reg = readl(mmio + MV_PCI_COMMAND);
|
|
|
|
writelfl(reg & ~MV_PCI_COMMAND_MWRCOM, mmio + MV_PCI_COMMAND);
|
2009-04-06 19:24:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
|
2005-11-12 17:48:15 +00:00
|
|
|
{
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
struct pci_dev *pdev = to_pci_dev(host->dev);
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
2005-11-12 17:48:15 +00:00
|
|
|
u32 hp_flags = hpriv->hp_flags;
|
|
|
|
|
2007-10-26 04:03:37 +00:00
|
|
|
switch (board_idx) {
|
2005-11-13 02:13:17 +00:00
|
|
|
case chip_5080:
|
|
|
|
hpriv->ops = &mv5xxx_ops;
|
2007-07-12 19:51:22 +00:00
|
|
|
hp_flags |= MV_HP_GEN_I;
|
2005-11-13 02:13:17 +00:00
|
|
|
|
2007-06-08 22:46:36 +00:00
|
|
|
switch (pdev->revision) {
|
2005-11-13 02:13:17 +00:00
|
|
|
case 0x1:
|
|
|
|
hp_flags |= MV_HP_ERRATA_50XXB0;
|
|
|
|
break;
|
|
|
|
case 0x3:
|
|
|
|
hp_flags |= MV_HP_ERRATA_50XXB2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_printk(KERN_WARNING, &pdev->dev,
|
|
|
|
"Applying 50XXB2 workarounds to unknown rev\n");
|
|
|
|
hp_flags |= MV_HP_ERRATA_50XXB2;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2005-11-12 17:48:15 +00:00
|
|
|
case chip_504x:
|
|
|
|
case chip_508x:
|
2005-11-13 02:13:17 +00:00
|
|
|
hpriv->ops = &mv5xxx_ops;
|
2007-07-12 19:51:22 +00:00
|
|
|
hp_flags |= MV_HP_GEN_I;
|
2005-11-12 17:48:15 +00:00
|
|
|
|
2007-06-08 22:46:36 +00:00
|
|
|
switch (pdev->revision) {
|
2005-11-13 02:13:17 +00:00
|
|
|
case 0x0:
|
|
|
|
hp_flags |= MV_HP_ERRATA_50XXB0;
|
|
|
|
break;
|
|
|
|
case 0x3:
|
|
|
|
hp_flags |= MV_HP_ERRATA_50XXB2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_printk(KERN_WARNING, &pdev->dev,
|
|
|
|
"Applying B2 workarounds to unknown rev\n");
|
|
|
|
hp_flags |= MV_HP_ERRATA_50XXB2;
|
|
|
|
break;
|
2005-11-12 17:48:15 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case chip_604x:
|
|
|
|
case chip_608x:
|
2005-11-13 02:13:17 +00:00
|
|
|
hpriv->ops = &mv6xxx_ops;
|
2007-07-12 19:51:22 +00:00
|
|
|
hp_flags |= MV_HP_GEN_II;
|
2005-11-13 02:13:17 +00:00
|
|
|
|
2007-06-08 22:46:36 +00:00
|
|
|
switch (pdev->revision) {
|
2005-11-13 02:13:17 +00:00
|
|
|
case 0x7:
|
2009-04-06 19:24:14 +00:00
|
|
|
mv_60x1b2_errata_pci7(host);
|
2005-11-13 02:13:17 +00:00
|
|
|
hp_flags |= MV_HP_ERRATA_60X1B2;
|
|
|
|
break;
|
|
|
|
case 0x9:
|
|
|
|
hp_flags |= MV_HP_ERRATA_60X1C0;
|
2005-11-12 17:48:15 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_printk(KERN_WARNING, &pdev->dev,
|
2005-11-13 02:13:17 +00:00
|
|
|
"Applying B2 workarounds to unknown rev\n");
|
|
|
|
hp_flags |= MV_HP_ERRATA_60X1B2;
|
2005-11-12 17:48:15 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2006-01-31 17:18:41 +00:00
|
|
|
case chip_7042:
|
2008-05-02 06:08:32 +00:00
|
|
|
hp_flags |= MV_HP_PCIE | MV_HP_CUT_THROUGH;
|
2007-12-04 19:07:52 +00:00
|
|
|
if (pdev->vendor == PCI_VENDOR_ID_TTI &&
|
|
|
|
(pdev->device == 0x2300 || pdev->device == 0x2310))
|
|
|
|
{
|
2007-12-11 17:58:05 +00:00
|
|
|
/*
|
|
|
|
* Highpoint RocketRAID PCIe 23xx series cards:
|
|
|
|
*
|
|
|
|
* Unconfigured drives are treated as "Legacy"
|
|
|
|
* by the BIOS, and it overwrites sector 8 with
|
|
|
|
* a "Lgcy" metadata block prior to Linux boot.
|
|
|
|
*
|
|
|
|
* Configured drives (RAID or JBOD) leave sector 8
|
|
|
|
* alone, but instead overwrite a high numbered
|
|
|
|
* sector for the RAID metadata. This sector can
|
|
|
|
* be determined exactly, by truncating the physical
|
|
|
|
* drive capacity to a nice even GB value.
|
|
|
|
*
|
|
|
|
* RAID metadata is at: (dev->n_sectors & ~0xfffff)
|
|
|
|
*
|
|
|
|
* Warn the user, lest they think we're just buggy.
|
|
|
|
*/
|
|
|
|
printk(KERN_WARNING DRV_NAME ": Highpoint RocketRAID"
|
|
|
|
" BIOS CORRUPTS DATA on all attached drives,"
|
|
|
|
" regardless of if/how they are configured."
|
|
|
|
" BEWARE!\n");
|
|
|
|
printk(KERN_WARNING DRV_NAME ": For data safety, do not"
|
|
|
|
" use sectors 8-9 on \"Legacy\" drives,"
|
|
|
|
" and avoid the final two gigabytes on"
|
|
|
|
" all RocketRAID BIOS initialized drives.\n");
|
2007-12-04 19:07:52 +00:00
|
|
|
}
|
2008-05-02 06:07:51 +00:00
|
|
|
/* drop through */
|
2006-01-31 17:18:41 +00:00
|
|
|
case chip_6042:
|
|
|
|
hpriv->ops = &mv6xxx_ops;
|
|
|
|
hp_flags |= MV_HP_GEN_IIE;
|
2008-05-02 06:08:32 +00:00
|
|
|
if (board_idx == chip_6042 && mv_pci_cut_through_okay(host))
|
|
|
|
hp_flags |= MV_HP_CUT_THROUGH;
|
2006-01-31 17:18:41 +00:00
|
|
|
|
2007-06-08 22:46:36 +00:00
|
|
|
switch (pdev->revision) {
|
2008-05-27 21:58:56 +00:00
|
|
|
case 0x2: /* Rev.B0: the first/only public release */
|
2006-01-31 17:18:41 +00:00
|
|
|
hp_flags |= MV_HP_ERRATA_60X1C0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_printk(KERN_WARNING, &pdev->dev,
|
|
|
|
"Applying 60X1C0 workarounds to unknown rev\n");
|
|
|
|
hp_flags |= MV_HP_ERRATA_60X1C0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2008-02-01 23:08:03 +00:00
|
|
|
case chip_soc:
|
2009-05-04 18:58:50 +00:00
|
|
|
if (soc_is_65n(hpriv))
|
|
|
|
hpriv->ops = &mv_soc_65n_ops;
|
|
|
|
else
|
|
|
|
hpriv->ops = &mv_soc_ops;
|
2008-08-04 11:52:55 +00:00
|
|
|
hp_flags |= MV_HP_FLAG_SOC | MV_HP_GEN_IIE |
|
|
|
|
MV_HP_ERRATA_60X1C0;
|
2008-02-01 23:08:03 +00:00
|
|
|
break;
|
2006-01-31 17:18:41 +00:00
|
|
|
|
2005-11-12 17:48:15 +00:00
|
|
|
default:
|
2008-02-01 23:08:03 +00:00
|
|
|
dev_printk(KERN_ERR, host->dev,
|
2007-10-26 04:03:37 +00:00
|
|
|
"BUG: invalid board index %u\n", board_idx);
|
2005-11-12 17:48:15 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
hpriv->hp_flags = hp_flags;
|
2007-12-01 18:07:22 +00:00
|
|
|
if (hp_flags & MV_HP_PCIE) {
|
2009-04-06 20:43:45 +00:00
|
|
|
hpriv->irq_cause_offset = PCIE_IRQ_CAUSE;
|
|
|
|
hpriv->irq_mask_offset = PCIE_IRQ_MASK;
|
2007-12-01 18:07:22 +00:00
|
|
|
hpriv->unmask_all_irqs = PCIE_UNMASK_ALL_IRQS;
|
|
|
|
} else {
|
2009-04-06 20:43:45 +00:00
|
|
|
hpriv->irq_cause_offset = PCI_IRQ_CAUSE;
|
|
|
|
hpriv->irq_mask_offset = PCI_IRQ_MASK;
|
2007-12-01 18:07:22 +00:00
|
|
|
hpriv->unmask_all_irqs = PCI_UNMASK_ALL_IRQS;
|
|
|
|
}
|
2005-11-12 17:48:15 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
2005-11-13 02:13:17 +00:00
|
|
|
* mv_init_host - Perform some early initialization of the host.
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
* @host: ATA host to initialize
|
|
|
|
* @board_idx: controller index
|
2005-10-05 21:08:53 +00:00
|
|
|
*
|
|
|
|
* If possible, do an early global reset of the host. Then do
|
|
|
|
* our port init and clear/unmask all/relevant host interrupts.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
static int mv_init_host(struct ata_host *host, unsigned int board_idx)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
|
|
|
int rc = 0, n_hc, port, hc;
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
2008-02-01 23:08:03 +00:00
|
|
|
void __iomem *mmio = hpriv->base;
|
2005-11-13 02:13:17 +00:00
|
|
|
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
rc = mv_chip_id(host, board_idx);
|
2005-11-12 17:48:15 +00:00
|
|
|
if (rc)
|
2008-04-19 18:43:42 +00:00
|
|
|
goto done;
|
2008-02-01 23:08:03 +00:00
|
|
|
|
2008-05-27 21:54:48 +00:00
|
|
|
if (IS_SOC(hpriv)) {
|
2009-04-06 20:43:45 +00:00
|
|
|
hpriv->main_irq_cause_addr = mmio + SOC_HC_MAIN_IRQ_CAUSE;
|
|
|
|
hpriv->main_irq_mask_addr = mmio + SOC_HC_MAIN_IRQ_MASK;
|
2008-05-27 21:54:48 +00:00
|
|
|
} else {
|
2009-04-06 20:43:45 +00:00
|
|
|
hpriv->main_irq_cause_addr = mmio + PCI_HC_MAIN_IRQ_CAUSE;
|
|
|
|
hpriv->main_irq_mask_addr = mmio + PCI_HC_MAIN_IRQ_MASK;
|
2008-02-01 23:08:03 +00:00
|
|
|
}
|
2008-04-19 18:43:42 +00:00
|
|
|
|
2009-01-24 19:24:58 +00:00
|
|
|
/* initialize shadow irq mask with register's value */
|
|
|
|
hpriv->main_irq_mask = readl(hpriv->main_irq_mask_addr);
|
|
|
|
|
2008-04-19 18:43:42 +00:00
|
|
|
/* global interrupt mask: 0 == mask everything */
|
2008-05-17 17:35:21 +00:00
|
|
|
mv_set_main_irq_mask(host, ~0, 0);
|
2005-11-12 17:48:15 +00:00
|
|
|
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
n_hc = mv_get_hc_count(host->ports[0]->flags);
|
2005-11-12 17:48:15 +00:00
|
|
|
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
for (port = 0; port < host->n_ports; port++)
|
2009-05-04 18:58:50 +00:00
|
|
|
if (hpriv->ops->read_preamp)
|
|
|
|
hpriv->ops->read_preamp(hpriv, port, mmio);
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-11-13 22:47:51 +00:00
|
|
|
rc = hpriv->ops->reset_hc(hpriv, mmio, n_hc);
|
2005-11-13 02:13:17 +00:00
|
|
|
if (rc)
|
2005-09-01 22:26:17 +00:00
|
|
|
goto done;
|
|
|
|
|
2005-11-13 03:14:02 +00:00
|
|
|
hpriv->ops->reset_flash(hpriv, mmio);
|
2008-01-30 22:50:45 +00:00
|
|
|
hpriv->ops->reset_bus(host, mmio);
|
2005-11-13 02:13:17 +00:00
|
|
|
hpriv->ops->enable_leds(hpriv, mmio);
|
2005-09-01 22:26:17 +00:00
|
|
|
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
for (port = 0; port < host->n_ports; port++) {
|
2007-08-18 04:14:55 +00:00
|
|
|
struct ata_port *ap = host->ports[port];
|
2005-11-13 04:05:14 +00:00
|
|
|
void __iomem *port_mmio = mv_port_base(mmio, port);
|
2007-08-18 04:14:55 +00:00
|
|
|
|
|
|
|
mv_port_init(&ap->ioaddr, port_mmio);
|
|
|
|
|
2008-01-30 22:50:45 +00:00
|
|
|
#ifdef CONFIG_PCI
|
2008-05-27 21:54:48 +00:00
|
|
|
if (!IS_SOC(hpriv)) {
|
2008-02-01 23:08:03 +00:00
|
|
|
unsigned int offset = port_mmio - mmio;
|
|
|
|
ata_port_pbar_desc(ap, MV_PRIMARY_BAR, -1, "mmio");
|
|
|
|
ata_port_pbar_desc(ap, MV_PRIMARY_BAR, offset, "port");
|
|
|
|
}
|
2008-01-30 22:50:45 +00:00
|
|
|
#endif
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (hc = 0; hc < n_hc; hc++) {
|
2005-09-30 05:36:00 +00:00
|
|
|
void __iomem *hc_mmio = mv_hc_base(mmio, hc);
|
|
|
|
|
|
|
|
VPRINTK("HC%i: HC config=0x%08x HC IRQ cause "
|
|
|
|
"(before clear)=0x%08x\n", hc,
|
2009-04-06 20:43:45 +00:00
|
|
|
readl(hc_mmio + HC_CFG),
|
|
|
|
readl(hc_mmio + HC_IRQ_CAUSE));
|
2005-09-30 05:36:00 +00:00
|
|
|
|
|
|
|
/* Clear any currently outstanding hc interrupt conditions */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(0, hc_mmio + HC_IRQ_CAUSE);
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2009-04-06 16:29:49 +00:00
|
|
|
if (!IS_SOC(hpriv)) {
|
|
|
|
/* Clear any currently outstanding host interrupt conditions */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(0, mmio + hpriv->irq_cause_offset);
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2009-04-06 16:29:49 +00:00
|
|
|
/* and unmask interrupt generation for host regs */
|
2009-04-06 20:43:45 +00:00
|
|
|
writelfl(hpriv->unmask_all_irqs, mmio + hpriv->irq_mask_offset);
|
2009-04-06 16:29:49 +00:00
|
|
|
}
|
2008-05-17 17:34:42 +00:00
|
|
|
|
2009-02-19 15:38:04 +00:00
|
|
|
/*
|
|
|
|
* enable only global host interrupts for now.
|
|
|
|
* The per-port interrupts get done later as ports are set up.
|
|
|
|
*/
|
|
|
|
mv_set_main_irq_mask(host, 0, PCI_ERR);
|
2009-03-11 02:01:17 +00:00
|
|
|
mv_set_irq_coalescing(host, irq_coalescing_io_count,
|
|
|
|
irq_coalescing_usecs);
|
2008-02-01 23:08:03 +00:00
|
|
|
done:
|
|
|
|
return rc;
|
|
|
|
}
|
2007-02-25 09:19:45 +00:00
|
|
|
|
2008-02-10 21:17:30 +00:00
|
|
|
static int mv_create_dma_pools(struct mv_host_priv *hpriv, struct device *dev)
|
|
|
|
{
|
|
|
|
hpriv->crqb_pool = dmam_pool_create("crqb_q", dev, MV_CRQB_Q_SZ,
|
|
|
|
MV_CRQB_Q_SZ, 0);
|
|
|
|
if (!hpriv->crqb_pool)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
hpriv->crpb_pool = dmam_pool_create("crpb_q", dev, MV_CRPB_Q_SZ,
|
|
|
|
MV_CRPB_Q_SZ, 0);
|
|
|
|
if (!hpriv->crpb_pool)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
hpriv->sg_tbl_pool = dmam_pool_create("sg_tbl", dev, MV_SG_TBL_SZ,
|
|
|
|
MV_SG_TBL_SZ, 0);
|
|
|
|
if (!hpriv->sg_tbl_pool)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-27 18:51:39 +00:00
|
|
|
static void mv_conf_mbus_windows(struct mv_host_priv *hpriv,
|
|
|
|
struct mbus_dram_target_info *dram)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
writel(0, hpriv->base + WINDOW_CTRL(i));
|
|
|
|
writel(0, hpriv->base + WINDOW_BASE(i));
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < dram->num_cs; i++) {
|
|
|
|
struct mbus_dram_window *cs = dram->cs + i;
|
|
|
|
|
|
|
|
writel(((cs->size - 1) & 0xffff0000) |
|
|
|
|
(cs->mbus_attr << 8) |
|
|
|
|
(dram->mbus_dram_target_id << 4) | 1,
|
|
|
|
hpriv->base + WINDOW_CTRL(i));
|
|
|
|
writel(cs->base, hpriv->base + WINDOW_BASE(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
/**
|
|
|
|
* mv_platform_probe - handle a positive probe of an soc Marvell
|
|
|
|
* host
|
|
|
|
* @pdev: platform device found
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static int mv_platform_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
static int printed_version;
|
|
|
|
const struct mv_sata_platform_data *mv_platform_data;
|
|
|
|
const struct ata_port_info *ppi[] =
|
|
|
|
{ &mv_port_info[chip_soc], NULL };
|
|
|
|
struct ata_host *host;
|
|
|
|
struct mv_host_priv *hpriv;
|
|
|
|
struct resource *res;
|
|
|
|
int n_ports, rc;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
if (!printed_version++)
|
|
|
|
dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
|
2005-11-12 17:48:15 +00:00
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
/*
|
|
|
|
* Simple resource validation ..
|
|
|
|
*/
|
|
|
|
if (unlikely(pdev->num_resources != 2)) {
|
|
|
|
dev_err(&pdev->dev, "invalid number of resources\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the register base first
|
|
|
|
*/
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (res == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* allocate host */
|
|
|
|
mv_platform_data = pdev->dev.platform_data;
|
|
|
|
n_ports = mv_platform_data->n_ports;
|
|
|
|
|
|
|
|
host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
|
|
|
|
hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!host || !hpriv)
|
|
|
|
return -ENOMEM;
|
|
|
|
host->private_data = hpriv;
|
|
|
|
hpriv->n_ports = n_ports;
|
|
|
|
|
|
|
|
host->iomap = NULL;
|
2008-02-18 18:42:28 +00:00
|
|
|
hpriv->base = devm_ioremap(&pdev->dev, res->start,
|
2009-08-06 23:05:08 +00:00
|
|
|
resource_size(res));
|
2009-04-06 20:43:45 +00:00
|
|
|
hpriv->base -= SATAHC0_REG_BASE;
|
2008-02-01 23:08:03 +00:00
|
|
|
|
2009-12-06 16:26:18 +00:00
|
|
|
#if defined(CONFIG_HAVE_CLK)
|
|
|
|
hpriv->clk = clk_get(&pdev->dev, NULL);
|
|
|
|
if (IS_ERR(hpriv->clk))
|
|
|
|
dev_notice(&pdev->dev, "cannot get clkdev\n");
|
|
|
|
else
|
|
|
|
clk_enable(hpriv->clk);
|
|
|
|
#endif
|
|
|
|
|
2008-03-27 18:51:39 +00:00
|
|
|
/*
|
|
|
|
* (Re-)program MBUS remapping windows if we are asked to.
|
|
|
|
*/
|
|
|
|
if (mv_platform_data->dram != NULL)
|
|
|
|
mv_conf_mbus_windows(hpriv, mv_platform_data->dram);
|
|
|
|
|
2008-02-10 21:17:30 +00:00
|
|
|
rc = mv_create_dma_pools(hpriv, &pdev->dev);
|
|
|
|
if (rc)
|
2009-12-06 16:26:18 +00:00
|
|
|
goto err;
|
2008-02-10 21:17:30 +00:00
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
/* initialize adapter */
|
|
|
|
rc = mv_init_host(host, chip_soc);
|
|
|
|
if (rc)
|
2009-12-06 16:26:18 +00:00
|
|
|
goto err;
|
2008-02-01 23:08:03 +00:00
|
|
|
|
|
|
|
dev_printk(KERN_INFO, &pdev->dev,
|
|
|
|
"slots %u ports %d\n", (unsigned)MV_MAX_Q_DEPTH,
|
|
|
|
host->n_ports);
|
|
|
|
|
|
|
|
return ata_host_activate(host, platform_get_irq(pdev, 0), mv_interrupt,
|
|
|
|
IRQF_SHARED, &mv6_sht);
|
2009-12-06 16:26:18 +00:00
|
|
|
err:
|
|
|
|
#if defined(CONFIG_HAVE_CLK)
|
|
|
|
if (!IS_ERR(hpriv->clk)) {
|
|
|
|
clk_disable(hpriv->clk);
|
|
|
|
clk_put(hpriv->clk);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return rc;
|
2008-02-01 23:08:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*
|
|
|
|
* mv_platform_remove - unplug a platform interface
|
|
|
|
* @pdev: platform device
|
|
|
|
*
|
|
|
|
* A platform bus SATA device has been unplugged. Perform the needed
|
|
|
|
* cleanup. Also called on module unload for any active devices.
|
|
|
|
*/
|
|
|
|
static int __devexit mv_platform_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct ata_host *host = dev_get_drvdata(dev);
|
2009-12-06 16:26:18 +00:00
|
|
|
#if defined(CONFIG_HAVE_CLK)
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
|
|
|
#endif
|
2008-02-01 23:08:03 +00:00
|
|
|
ata_host_detach(host);
|
2009-12-06 16:26:18 +00:00
|
|
|
|
|
|
|
#if defined(CONFIG_HAVE_CLK)
|
|
|
|
if (!IS_ERR(hpriv->clk)) {
|
|
|
|
clk_disable(hpriv->clk);
|
|
|
|
clk_put(hpriv->clk);
|
|
|
|
}
|
|
|
|
#endif
|
2008-02-01 23:08:03 +00:00
|
|
|
return 0;
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
static struct platform_driver mv_platform_driver = {
|
|
|
|
.probe = mv_platform_probe,
|
|
|
|
.remove = __devexit_p(mv_platform_remove),
|
|
|
|
.driver = {
|
|
|
|
.name = DRV_NAME,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-01-30 22:50:45 +00:00
|
|
|
#ifdef CONFIG_PCI
|
2008-02-01 23:08:03 +00:00
|
|
|
static int mv_pci_init_one(struct pci_dev *pdev,
|
|
|
|
const struct pci_device_id *ent);
|
|
|
|
|
2008-01-30 22:50:45 +00:00
|
|
|
|
|
|
|
static struct pci_driver mv_pci_driver = {
|
|
|
|
.name = DRV_NAME,
|
|
|
|
.id_table = mv_pci_tbl,
|
2008-02-01 23:08:03 +00:00
|
|
|
.probe = mv_pci_init_one,
|
2008-01-30 22:50:45 +00:00
|
|
|
.remove = ata_pci_remove_one,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* move to PCI layer or libata core? */
|
|
|
|
static int pci_go_64(struct pci_dev *pdev)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2009-04-07 02:01:13 +00:00
|
|
|
if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
|
|
|
|
rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
|
2008-01-30 22:50:45 +00:00
|
|
|
if (rc) {
|
2009-04-07 02:01:15 +00:00
|
|
|
rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
|
2008-01-30 22:50:45 +00:00
|
|
|
if (rc) {
|
|
|
|
dev_printk(KERN_ERR, &pdev->dev,
|
|
|
|
"64-bit DMA enable failed\n");
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2009-04-07 02:01:15 +00:00
|
|
|
rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
|
2008-01-30 22:50:45 +00:00
|
|
|
if (rc) {
|
|
|
|
dev_printk(KERN_ERR, &pdev->dev,
|
|
|
|
"32-bit DMA enable failed\n");
|
|
|
|
return rc;
|
|
|
|
}
|
2009-04-07 02:01:15 +00:00
|
|
|
rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
|
2008-01-30 22:50:45 +00:00
|
|
|
if (rc) {
|
|
|
|
dev_printk(KERN_ERR, &pdev->dev,
|
|
|
|
"32-bit consistent DMA enable failed\n");
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
|
|
|
* mv_print_info - Dump key info to kernel log for perusal.
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
* @host: ATA host to print info about
|
2005-10-05 21:08:53 +00:00
|
|
|
*
|
|
|
|
* FIXME: complete this.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
static void mv_print_info(struct ata_host *host)
|
2005-09-30 05:36:00 +00:00
|
|
|
{
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
struct pci_dev *pdev = to_pci_dev(host->dev);
|
|
|
|
struct mv_host_priv *hpriv = host->private_data;
|
2007-06-08 22:46:36 +00:00
|
|
|
u8 scc;
|
2007-07-09 16:29:31 +00:00
|
|
|
const char *scc_s, *gen;
|
2005-09-30 05:36:00 +00:00
|
|
|
|
|
|
|
/* Use this to determine the HW stepping of the chip so we know
|
|
|
|
* what errata to workaround
|
|
|
|
*/
|
|
|
|
pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &scc);
|
|
|
|
if (scc == 0)
|
|
|
|
scc_s = "SCSI";
|
|
|
|
else if (scc == 0x01)
|
|
|
|
scc_s = "RAID";
|
|
|
|
else
|
2007-07-09 16:29:31 +00:00
|
|
|
scc_s = "?";
|
|
|
|
|
|
|
|
if (IS_GEN_I(hpriv))
|
|
|
|
gen = "I";
|
|
|
|
else if (IS_GEN_II(hpriv))
|
|
|
|
gen = "II";
|
|
|
|
else if (IS_GEN_IIE(hpriv))
|
|
|
|
gen = "IIE";
|
|
|
|
else
|
|
|
|
gen = "?";
|
2005-09-30 05:36:00 +00:00
|
|
|
|
2005-10-30 19:39:11 +00:00
|
|
|
dev_printk(KERN_INFO, &pdev->dev,
|
2007-07-09 16:29:31 +00:00
|
|
|
"Gen-%s %u slots %u ports %s mode IRQ via %s\n",
|
|
|
|
gen, (unsigned)MV_MAX_Q_DEPTH, host->n_ports,
|
2005-09-30 05:36:00 +00:00
|
|
|
scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
|
|
|
|
}
|
|
|
|
|
2005-10-05 21:08:53 +00:00
|
|
|
/**
|
2008-02-01 23:08:03 +00:00
|
|
|
* mv_pci_init_one - handle a positive probe of a PCI Marvell host
|
2005-10-05 21:08:53 +00:00
|
|
|
* @pdev: PCI device found
|
|
|
|
* @ent: PCI device ID entry for the matched host
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2008-02-01 23:08:03 +00:00
|
|
|
static int mv_pci_init_one(struct pci_dev *pdev,
|
|
|
|
const struct pci_device_id *ent)
|
2005-09-01 22:26:17 +00:00
|
|
|
{
|
2007-10-19 10:42:56 +00:00
|
|
|
static int printed_version;
|
2005-09-01 22:26:17 +00:00
|
|
|
unsigned int board_idx = (unsigned int)ent->driver_data;
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
const struct ata_port_info *ppi[] = { &mv_port_info[board_idx], NULL };
|
|
|
|
struct ata_host *host;
|
|
|
|
struct mv_host_priv *hpriv;
|
|
|
|
int n_ports, rc;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-10-30 19:39:11 +00:00
|
|
|
if (!printed_version++)
|
|
|
|
dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
|
2005-09-01 22:26:17 +00:00
|
|
|
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
/* allocate host */
|
|
|
|
n_ports = mv_get_hc_count(ppi[0]->flags) * MV_PORTS_PER_HC;
|
|
|
|
|
|
|
|
host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
|
|
|
|
hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
|
|
|
|
if (!host || !hpriv)
|
|
|
|
return -ENOMEM;
|
|
|
|
host->private_data = hpriv;
|
2008-02-01 23:08:03 +00:00
|
|
|
hpriv->n_ports = n_ports;
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
|
|
|
|
/* acquire resources */
|
2007-01-20 07:00:28 +00:00
|
|
|
rc = pcim_enable_device(pdev);
|
|
|
|
if (rc)
|
2005-09-01 22:26:17 +00:00
|
|
|
return rc;
|
|
|
|
|
2007-02-01 06:06:36 +00:00
|
|
|
rc = pcim_iomap_regions(pdev, 1 << MV_PRIMARY_BAR, DRV_NAME);
|
|
|
|
if (rc == -EBUSY)
|
2007-01-20 07:00:28 +00:00
|
|
|
pcim_pin_device(pdev);
|
2007-02-01 06:06:36 +00:00
|
|
|
if (rc)
|
2007-01-20 07:00:28 +00:00
|
|
|
return rc;
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
host->iomap = pcim_iomap_table(pdev);
|
2008-02-01 23:08:03 +00:00
|
|
|
hpriv->base = host->iomap[MV_PRIMARY_BAR];
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2007-02-26 06:26:06 +00:00
|
|
|
rc = pci_go_64(pdev);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2008-01-26 23:32:45 +00:00
|
|
|
rc = mv_create_dma_pools(hpriv, &pdev->dev);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
/* initialize adapter */
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
rc = mv_init_host(host, board_idx);
|
2007-01-20 07:00:28 +00:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2009-01-21 15:31:29 +00:00
|
|
|
/* Enable message-switched interrupts, if requested */
|
|
|
|
if (msi && pci_enable_msi(pdev) == 0)
|
|
|
|
hpriv->hp_flags |= MV_HP_FLAG_MSI;
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2005-09-30 05:36:00 +00:00
|
|
|
mv_dump_pci_cfg(pdev, 0x68);
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
mv_print_info(host);
|
2005-09-01 22:26:17 +00:00
|
|
|
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
pci_set_master(pdev);
|
2007-07-17 06:21:50 +00:00
|
|
|
pci_try_set_mwi(pdev);
|
libata: convert the remaining SATA drivers to new init model
Convert ahci, sata_sil, sata_sil24, sata_svw, sata_qstor, sata_mv,
sata_sx4, sata_vsc and sata_inic162x to new init model.
Now that host and ap are available during intialization, functions are
converted to take either host or ap instead of low level parameters
which were inevitable for functions shared between init and other
paths. This simplifies code quite a bit.
* init_one()'s now follow more consistent init order
* ahci_setup_port() and ahci_host_init() collapsed into
ahci_init_one() for init order consistency
* sata_vsc uses port_info instead of setting fields manually
* in sata_svw, k2_board_info converted to port_info (info is now in
port flags). port number is honored now.
Tested on ICH7/8 AHCI, jmb360, sil3112, 3114, 3124 and 3132.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-04-17 14:44:08 +00:00
|
|
|
return ata_host_activate(host, pdev->irq, mv_interrupt, IRQF_SHARED,
|
2007-07-11 22:30:50 +00:00
|
|
|
IS_GEN_I(hpriv) ? &mv5_sht : &mv6_sht);
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
2008-01-30 22:50:45 +00:00
|
|
|
#endif
|
2005-09-01 22:26:17 +00:00
|
|
|
|
2008-02-01 23:08:03 +00:00
|
|
|
static int mv_platform_probe(struct platform_device *pdev);
|
|
|
|
static int __devexit mv_platform_remove(struct platform_device *pdev);
|
|
|
|
|
2005-09-01 22:26:17 +00:00
|
|
|
static int __init mv_init(void)
|
|
|
|
{
|
2008-01-30 22:50:45 +00:00
|
|
|
int rc = -ENODEV;
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
rc = pci_register_driver(&mv_pci_driver);
|
2008-02-01 23:08:03 +00:00
|
|
|
if (rc < 0)
|
|
|
|
return rc;
|
|
|
|
#endif
|
|
|
|
rc = platform_driver_register(&mv_platform_driver);
|
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
if (rc < 0)
|
|
|
|
pci_unregister_driver(&mv_pci_driver);
|
2008-01-30 22:50:45 +00:00
|
|
|
#endif
|
|
|
|
return rc;
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit mv_exit(void)
|
|
|
|
{
|
2008-01-30 22:50:45 +00:00
|
|
|
#ifdef CONFIG_PCI
|
2005-09-01 22:26:17 +00:00
|
|
|
pci_unregister_driver(&mv_pci_driver);
|
2008-01-30 22:50:45 +00:00
|
|
|
#endif
|
2008-02-01 23:08:03 +00:00
|
|
|
platform_driver_unregister(&mv_platform_driver);
|
2005-09-01 22:26:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Brett Russ");
|
|
|
|
MODULE_DESCRIPTION("SCSI low-level driver for Marvell SATA controllers");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
|
|
|
|
MODULE_VERSION(DRV_VERSION);
|
2008-04-16 18:56:51 +00:00
|
|
|
MODULE_ALIAS("platform:" DRV_NAME);
|
2005-09-01 22:26:17 +00:00
|
|
|
|
|
|
|
module_init(mv_init);
|
|
|
|
module_exit(mv_exit);
|